use crate::entity::{Entity, Index};

pub fn sql_for_table<T: Entity>() -> (String, String) {
    let all_columns = T::columns();

    let mut columns = vec!["id integer primary key".to_owned()];

    // skip the id column type
    for col in all_columns.iter().skip(1) {
        columns.push(format!(
            "\"{}\" {}{}",
            col.name(),
            col.sql_type(),
            if col.fk_table_name().is_some() {
                format!(
                    " REFERENCES \"{}\"(\"{}\") ON DELETE CASCADE",
                    col.fk_table_name().unwrap(),
                    col.fk_column_name().unwrap()
                )
            } else {
                "".to_owned()
            }
        ));
    }

    (
        format!("DROP TABLE IF EXISTS \"{}\"", <T as Entity>::table_name()),
        format!(
            "CREATE TABLE IF NOT EXISTS \"{}\" ({})",
            <T as Entity>::table_name(),
            columns.join(",")
        ),
    )
}

pub fn sql_for_index<I: Index>() -> (String, String) {
    (
        format!("DROP INDEX IF EXISTS \"{}\"", I::index_name()),
        format!(
            "CREATE {}INDEX \"{}\" ON \"{}\" ({})",
            if I::unique() { "UNIQUE " } else { "" },
            I::index_name(),
            I::table_name(),
            I::column_names()
                .iter()
                .map(|x| format!("\"{}\"", x))
                .collect::<Vec<_>>()
                .join(",")
        ),
    )
}

#[cfg(test)]
mod test {
    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct Empty {}

    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct Single {
        e: i32,
    }

    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct Reference {
        e: SingleID,
    }

    #[test]
    fn example_sql_for() {
        assert_eq!(
            super::sql_for_table::<Empty>(),
            (
                r#"DROP TABLE IF EXISTS "empty""#.to_owned(),
                r#"CREATE TABLE IF NOT EXISTS "empty" (id integer primary key)"#.to_owned()
            )
        );
        assert_eq!(
            super::sql_for_table::<Single>(),
            (
                r#"DROP TABLE IF EXISTS "single""#.to_owned(),
                r#"CREATE TABLE IF NOT EXISTS "single" (id integer primary key,"e" integer)"#
                    .to_owned()
            )
        );

        assert_eq!(
            super::sql_for_table::<Reference>(),
            (
                r#"DROP TABLE IF EXISTS "reference""#.to_owned(),
                r#"CREATE TABLE IF NOT EXISTS "reference" (id integer primary key,"e" integer)"#
                    .to_owned()
            )
        );
    }

    #[derive(serde::Serialize, serde::Deserialize, crate::Modelable)]
    #[microrm_internal]
    pub struct Unit(u8);
    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct UnitNewtype {
        newtype: Unit,
    }

    #[test]
    fn unit_newtype_struct() {
        assert_eq!(
            super::sql_for_table::<UnitNewtype>(),
            (
                r#"DROP TABLE IF EXISTS "unit_newtype""#.to_owned(),
                r#"CREATE TABLE IF NOT EXISTS "unit_newtype" (id integer primary key,"newtype" integer)"#
                    .to_owned()
            )
        );
    }

    #[derive(serde::Serialize, serde::Deserialize, crate::Modelable)]
    #[microrm_internal]
    pub struct NonUnit(u8, u8);
    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct NonUnitNewtype {
        newtype: NonUnit,
    }

    #[test]
    fn nonunit_newtype_struct() {
        assert_eq!(
            super::sql_for_table::<NonUnitNewtype>(),
            (
                r#"DROP TABLE IF EXISTS "non_unit_newtype""#.to_owned(),
                r#"CREATE TABLE IF NOT EXISTS "non_unit_newtype" (id integer primary key,"newtype" blob)"#.to_owned()
            )
        )
    }

    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct Child {
        #[microrm_foreign]
        parent_id: SingleID,
    }

    #[test]
    fn test_foreign_key() {
        assert_eq!(
            super::sql_for_table::<Child>(),
            (
                r#"DROP TABLE IF EXISTS "child""#.to_owned(),
                r#"CREATE TABLE IF NOT EXISTS "child" (id integer primary key,"parent_id" integer REFERENCES "single"("id") ON DELETE CASCADE)"#.to_owned()
            )
        );
    }

    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct KeyValue {
        key: String,
        value: String,
    }

    microrm_macros::make_index_internal!(ValueIndex, KeyValue::Value);
    microrm_macros::make_index_internal!(!UniqueValueIndex, KeyValue::Value);

    #[test]
    fn test_indexes() {
        assert_eq!(
            super::sql_for_index::<ValueIndex>(),
            (
                r#"DROP INDEX IF EXISTS "value_index""#.to_owned(),
                r#"CREATE INDEX "value_index" ON "key_value" ("value")"#.to_owned()
            )
        );
        assert_eq!(
            super::sql_for_index::<UniqueValueIndex>(),
            (
                r#"DROP INDEX IF EXISTS "unique_value_index""#.to_owned(),
                r#"CREATE UNIQUE INDEX "unique_value_index" ON "key_value" ("value")"#.to_owned()
            )
        )
    }

    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct VecTest {
        e: u64,
        test: Vec<usize>,
    }

    #[test]
    fn test_vec() {
        assert_eq!(
            super::sql_for_table::<VecTest>().1,
            r#"CREATE TABLE IF NOT EXISTS "vec_test" (id integer primary key,"e" integer,"test" blob)"#.to_owned()
        );
    }

    #[derive(crate::Modelable, serde::Deserialize, serde::Serialize)]
    #[microrm_internal]
    pub enum TestEnum {
        A,
        B,
        C,
    }

    #[derive(serde::Serialize, serde::Deserialize, crate::Entity)]
    #[microrm_internal]
    pub struct EnumContainer {
        before: usize,
        e: TestEnum,
        after: usize,
    }

    #[test]
    fn test_enum() {
        assert_eq!(
            super::sql_for_table::<EnumContainer>().1,
            r#"CREATE TABLE IF NOT EXISTS "enum_container" (id integer primary key,"before" integer,"e" text,"after" integer)"#.to_owned()
        )
    }
}