//! File that contains all the datatypes and logic to perform the migrations

//! over a target database

use async_trait::async_trait;

use canyon_crud::DatabaseType;

use regex::Regex;

use std::collections::HashMap;

use std::fmt::Debug;

use std::ops::Not;

use crate::canyon_crud::{crud::Transaction, DatasourceConfig};

use crate::constants::regex_patterns;

use crate::save_migrations_query_to_execute;

use super::information_schema::{ColumnMetadata, TableMetadata};

use super::memory::CanyonMemory;

#[cfg(feature = "postgres")]

use crate::migrations::transforms::{to_postgres_alter_syntax, to_postgres_syntax};

#[cfg(feature = "mssql")]

use crate::migrations::transforms::{to_sqlserver_alter_syntax, to_sqlserver_syntax};

use canyon_entities::register_types::{CanyonRegisterEntity, CanyonRegisterEntityField};

/// Responsible of generating the queries to sync the database status with the

/// Rust source code managed by Canyon, for successfully make the migrations

pub struct MigrationsProcessor {

}

impl Transaction<Self> for MigrationsProcessor {}

impl MigrationsProcessor {

        &'a mut self,

        canyon_memory: CanyonMemory,

        canyon_entities: Vec<CanyonRegisterEntity<'a>>,

        database_tables: Vec<&'a TableMetadata>,

        datasource: &'_ DatasourceConfig,

        // The database type formally represented in Canyon

        let db_type = datasource.get_db_type();

        // For each entity (table) on the register (Rust structs)

        for canyon_register_entity in canyon_entities {

            let entity_name = canyon_register_entity.entity_db_table_name;

            println!("Processing migrations for entity: {entity_name}");

            // 1st operation ->

            self.create_or_rename_tables(

                &canyon_memory,

                entity_name,

                canyon_register_entity.entity_fields.clone(),

                &database_tables,

            );

            let current_table_metadata = MigrationsHelper::get_current_table_metadata(

                &canyon_memory,

                entity_name,

                &database_tables,

            );

            self.delete_fields(

                entity_name,

                canyon_register_entity.entity_fields.clone(),

                current_table_metadata,

                db_type,

            );

            // For each field (column) on the this canyon register entity

            for canyon_register_field in canyon_register_entity.entity_fields {

                let current_column_metadata = MigrationsHelper::get_current_column_metadata(

                    canyon_register_field.field_name.clone(),

                    current_table_metadata,

                );

                // We only create or modify (right now only datatype)

                // the column when the database already contains the table,

                // if not, the columns are already create in the previous operation (create table)

                if current_table_metadata.is_some() {

                    self.create_or_modify_field(

                        entity_name,

                        db_type,

                        canyon_register_field.clone(),

                        current_column_metadata,

                    )

                }

                // Time to check annotations for the current column

                // Case when  we only need to add constraints

                if (current_table_metadata.is_none()

                    && !canyon_register_field.annotations.is_empty())

                    || (current_table_metadata.is_some() && current_column_metadata.is_none())

                {

                    self.add_constraints(entity_name, canyon_register_field.clone())

                }

                // Case when we need to compare the entity with the database contain

                #[allow(clippy::unnecessary_unwrap)]

                if current_table_metadata.is_some() && current_column_metadata.is_some() {

                    self.add_modify_or_remove_constraints(

                        entity_name,

                        canyon_register_field,

                        current_column_metadata.unwrap(),

                    )

                }

            }

        }

        for operation in &self.operations {

            operation.generate_sql(datasource).await; // This should be moved again to runtime

        }

        for operation in &self.drop_primary_key_operations {

            operation.generate_sql(datasource).await; // This should be moved again to runtime

        }

        for operation in &self.set_primary_key_operations {

            operation.generate_sql(datasource).await; // This should be moved again to runtime

        }

        for operation in &self.constraints_operations {

            operation.generate_sql(datasource).await; // This should be moved again to runtime

        }

        // TODO Still pending to decouple de executions of cargo check to skip the process if this

        // code is not processed by cargo build or cargo run

        // Self::from_query_register(datasource_name).await;

    /// The operation that checks if an entity must be update is name in the database

        &mut self,

        canyon_memory: &'_ CanyonMemory,

        entity_name: &'a str,

        entity_fields: Vec<CanyonRegisterEntityField>,

        database_tables: &'a [&'a TableMetadata],

    ) {

        // 1st operation -> Check if the current entity is already on the target database.

            // [`CanyonMemory`] holds a HashMap with the tables who changed their name in

            // the Rust side. If this table name is present, we don't create a new table,

            // just rename the already known one

                        .renamed_entities

                        .get(entity_name) // Get the old entity name (the value)

                        .unwrap()

                        .to_owned(),

                )

            } else {

            }

        }

    /// Generates a database agnostic query to change the name of a table

            table_name,

            entity_fields,

        )));

    /// Generates a database agnostic query to change the name of a table

                old_table_name,

                new_table_name,

            )));

    // Creates or modify (currently only datatype) a column for a given canyon register entity field

        &mut self,

        entity_name: &'a str,

        entity_fields: Vec<CanyonRegisterEntityField>,

        current_table_metadata: Option<&'a TableMetadata>,

        _db_type: DatabaseType,

    ) {

            return;

        }

            .unwrap()

            .columns

            .iter()

                    .iter()

                    .not()

            .collect();

            #[cfg(feature = "mssql")]

            {

                        entity_name,

                    )

                }

            }

        }

    // Creates or modify (currently only datatype and nullability) a column for a given canyon register entity field

        &mut self,

        entity_name: &str,

        db_type: DatabaseType,

        canyon_register_entity_field: CanyonRegisterEntityField,

        current_column_metadata: Option<&ColumnMetadata>,

    ) {

        // If we do not retrieve data for this database column, it does not exist yet

        // and therefore it has to be created

            )

            db_type,

            &canyon_register_entity_field,

        ) {

            )

        }

                } else {

                }

            }

        }

            column_name,

        )));

    #[cfg(feature = "mssql")]

        &mut self,

        table_name: &str,

        column_name: String,

        column_datatype: String,

    ) {

                column_name,

                column_datatype,

            )));

                table_name, field,

            )));

                table_name, field,

            )));

                table_name, field,

            )));

        &mut self,

        entity_name: &str,

        canyon_register_entity_field: CanyonRegisterEntityField,

    ) {

                );

                    "{entity_name}_{}_fkey",

                );

                    self,

                    foreign_key_name,

                    table_to_reference,

                    column_to_reference,

                    &canyon_register_entity_field,

                );

            }

                #[cfg(feature = "postgres")]

                {

                    }

                }

            }

        }

        &mut self,

        entity_name: &'_ str,

        foreign_key_name: String,

        table_to_reference: String,

        column_to_reference: String,

        canyon_register_entity_field: &CanyonRegisterEntityField,

    ) {

                foreign_key_name,

                table_to_reference,

                column_to_reference,

            )));

        &mut self,

        entity_name: &str,

        canyon_register_entity_field: CanyonRegisterEntityField,

    ) {

                canyon_register_entity_field,

            )));

    #[cfg(feature = "postgres")]

            )));

            )));

        &mut self,

        entity_name: &str,

        canyon_register_entity_field: CanyonRegisterEntityField,

        current_column_metadata: &ColumnMetadata,

    ) {

            .annotations

            .iter()

            .annotations

            .iter()

        // ------------ PRIMARY KEY ---------------

        // Case when field contains a primary key annotation, and it's not already on database, add it to constrains_operations

            #[cfg(feature = "postgres")]

            {

                }

            }

        }

        // Case when the field contains a primary key annotation, and it's already on the database

            #[cfg(feature = "postgres")]

            {

                }

            }

        }

        // Case when field doesn't contains a primary key annotation, but there is one in the database column

                self,

                    .primary_key_name

                    .as_ref()

                    .expect("PrimaryKey constrain name not found")

                    .to_string(),

            );

            #[cfg(feature = "postgres")]

            {

                }

            }

        }

        // -------------------- FOREIGN KEY CASE ----------------------------

        // Case when field contains a foreign key annotation, and it's not already on database, add it to constraints_operations

                );

                    "{entity_name}_{}_fkey",

                );

                    self,

                    foreign_key_name,

                    &canyon_register_entity_field,

                );

            }

        }

        // Case when field contains a foreign key annotation, and there is already one in the database

            // Will contain the table name (on index 0) and column name (on index 1) pointed to by the foreign key

                "{entity_name}_{}_fkey",

            );

            // Example of information in foreign_key_info: FOREIGN KEY (league) REFERENCES leagues(id)

                .captures(

                        .foreign_key_info

                        .as_ref()

                        .expect("Regex - foreign key info"),

                )

                .expect("Regex - foreign key info not found");

                .name("current_column")

                .expect("Regex - Current column not found")

                .as_str()

                .to_string();

                .name("ref_table")

                .expect("Regex - Ref tablenot found")

                .as_str()

                .to_string();

                .name("ref_column")

                .expect("Regex - Ref column not found")

                .as_str()

                .to_string();

            // If entity foreign key is not equal to the one on database, a constrains_operations is added to delete it and add a new one.

            {

                    self,

                        .foreign_key_name

                        .as_ref()

                        .expect("Annotation foreign key constrain name not found")

                        .to_string(),

                );

                    self,

                    &canyon_register_entity_field,

                )

            }

            // Case when field don't contains a foreign key annotation, but there is already one in the database column

                self,

                    .foreign_key_name

                    .as_ref()

                    .expect("ForeignKey constrain name not found")

                    .to_string(),

            );

        }

                primary_key_name,

            )));

    #[cfg(feature = "postgres")]

        &mut self,

        entity_name: &str,

        canyon_register_entity_field: CanyonRegisterEntityField,

    ) {

                canyon_register_entity_field,

            )));

                // table_with_foreign_key,constrain_name

                constrain_name,

            )));

    /// Make the detected migrations for the next Canyon-SQL run

    #[allow(clippy::await_holding_lock)]

        for datasource in queries_to_execute.iter() {

            for query_to_execute in datasource.1 {

                let res = Self::query(query_to_execute, [], datasource.0).await;

                match res {

                    Ok(_) => println!(

                        "\t[OK] - {:?} - Query: {:?}",

                        datasource.0, &query_to_execute

                    ),

                    Err(e) => println!(

                        "\t[ERR] - {:?} - Query: {:?}\nCause: {:?}",

                        datasource.0, &query_to_execute, e

                    ),

                }

                // TODO Ask for user input?

            }

        }

}

/// Contains helper methods to parse and process the external and internal input data

/// for the migrations

struct MigrationsHelper;

impl MigrationsHelper {

    /// Checks if a tracked Canyon entity is already present in the database

        entity_name: &'a str,

        database_tables: &'a [&'_ TableMetadata],

    ) -> bool {

            .iter()

    /// Get the table metadata for a given entity name or his old entity name if the table was renamed.

        canyon_memory: &'_ CanyonMemory,

        entity_name: &'a str,

        database_tables: &'a [&'_ TableMetadata],

    ) -> Option<&'a TableMetadata> {

            .renamed_entities

            .iter()

    /// Get the column metadata for a given column name

        column_name: String,

        current_table_metadata: Option<&TableMetadata>,

    ) -> Option<&ColumnMetadata> {

                .columns

                .iter()

        } else {

        }

    #[cfg(feature = "mssql")]

        // TODO Add all SQL Server text datatypes

        {

            };

        }

        db_type: DatabaseType,

        canyon_register_entity_field: &CanyonRegisterEntityField,

        current_column_metadata: &ColumnMetadata,

    ) -> bool {

        #[cfg(feature = "postgres")]

        {

            }

        }

        #[cfg(feature = "mssql")]

        {

                // TODO Search a better way to get the datatype without useless info (like "VARCHAR(MAX)")

            }

        }

            .iter()

                .split(',')

                        .collect::<Vec<&str>>()

                        .get(1)

                        .expect("Error. Unable to split annotations")

                        .trim()

                        .to_string()

                .collect::<Vec<String>>();

                .get(0)

                .expect("Error extracting table ref from FK annotation")

                .to_string();

                .get(1)

                .expect("Error extracting column ref from FK annotation")

                .to_string();

        }

}

#[cfg(test)]

mod migrations_helper_tests {

    use super::*;

    use crate::constants;

    const MOCKED_ENTITY_NAME: &str = "league";

    #[test]

    fn test_entity_already_on_database() {

        let parse_result_empty_db_tables =

            MigrationsHelper::entity_already_on_database(MOCKED_ENTITY_NAME, &[]);

        // Always should be false

        assert!(!parse_result_empty_db_tables);

        // Rust has a League entity. Database has a `league` entity. Case should be normalized

        // and a match must raise

        let mocked_league_entity_on_database = MigrationsHelper::entity_already_on_database(

            MOCKED_ENTITY_NAME,

            &[&constants::mocked_data::TABLE_METADATA_LEAGUE_EX],

        );

        assert!(mocked_league_entity_on_database);

        let mocked_league_entity_on_database = MigrationsHelper::entity_already_on_database(

            MOCKED_ENTITY_NAME,

            &[&constants::mocked_data::NON_MATCHING_TABLE_METADATA],

        );

        assert!(!mocked_league_entity_on_database)

    }

}

/// Trait that enables implementors to generate the migration queries

#[async_trait]

trait DatabaseOperation: Debug {

    async fn generate_sql(&self, datasource: &DatasourceConfig);

}

/// Helper to relate the operations that Canyon should do when it's managing a schema

#[allow(dead_code)]

enum TableOperation {

    // old table_name, new table_name

    // table_name, foreign_key_name, column_foreign_key, table_to_reference, column_to_reference

    // table_with_foreign_key, constraint_name

    // table_name, entity_field, column_name

    // table_name, constraint_name

}

impl<T: Debug> Transaction<T> for TableOperation {}

#[async_trait]

impl DatabaseOperation for TableOperation {

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql => {

                            "CREATE TABLE \"{table_name}\" ({});",

                                .iter()

                                    "\"{}\" {}",

                                    entity_field.field_name,

                                .collect::<Vec<String>>()

                                .join(", ")

                        )

                    }

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer => {

                            "CREATE TABLE {:?} ({:?});",

                            table_name,

                                .iter()

                                    "{} {}",

                                    entity_field.field_name,

                                .collect::<Vec<String>>()

                                .join(", ")

                        )

                            .replace('"', "")

                }

            }

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                        /*

                            Notes: Brackets around `old_table_name`, p.e.

                                exec sp_rename ['league'], 'leagues'  // NOT VALID!

                            is only allowed for compound names split by a dot.

                                exec sp_rename ['random.league'], 'leagues'  // OK

                            CARE! This doesn't mean that we are including the schema.

                                exec sp_rename ['dbo.random.league'], 'leagues' // OK

                                exec sp_rename 'dbo.league', 'leagues' // OK - Schema doesn't need brackets

                            Due to the automatic mapped name from Rust to DB and vice-versa, this won't

                            be an allowed behaviour for now, only with the table_name parameter on the

                            CanyonEntity annotation.

                        */

                }

            }

            TableOperation::AddTableForeignKey(

            ) => {

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                            "ALTER TABLE {_table_name} ADD CONSTRAINT {_foreign_key_name} \

                            FOREIGN KEY ({_column_foreign_key}) REFERENCES {_table_to_reference} ({_column_to_reference});"

                        ),

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                }

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                            "ALTER TABLE {_table_with_foreign_key} DROP CONSTRAINT {_constraint_name};",

                        ),

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                }

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                            "ALTER TABLE \"{_table_name}\" ADD PRIMARY KEY (\"{}\");",

                            _entity_field.field_name

                        ),

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                }

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                }

            }

        };

}

/// Helper to relate the operations that Canyon should do when a change on a field should

#[allow(dead_code)]

enum ColumnOperation {

    // AlterColumnName,

    #[cfg(feature = "mssql")]

    // SQL server specific operation - SQL server can't drop a NOT NULL column

    #[cfg(feature = "postgres")]

    #[cfg(feature = "postgres")]

}

impl Transaction<Self> for ColumnOperation {}

#[async_trait]

impl DatabaseOperation for ColumnOperation {

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                            "ALTER TABLE \"{}\" ADD COLUMN \"{}\" {};",

                            table_name,

                            entity_field.field_name,

                        ),

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                            "ALTER TABLE {} ADD \"{}\" {};",

                            table_name,

                            entity_field.field_name,

                        ),

                }

                // TODO Check if operation for SQL server is different

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                            "ALTER TABLE \"{_table_name}\" ALTER COLUMN \"{}\" TYPE {};",

                        ),

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                    #[cfg(feature = "postgres")] DatabaseType::PostgreSql =>

                    #[cfg(feature = "mssql")] DatabaseType::SqlServer =>

                            "ALTER TABLE \"{table_name}\" ALTER COLUMN {} {} NULL",

                        ),

                }

                "ALTER TABLE {table_name} ALTER COLUMN {column_name} {column_datatype} NULL; DECLARE @tableName VARCHAR(MAX) = '{table_name}'

                DECLARE @columnName VARCHAR(MAX) = '{column_name}'

                DECLARE @ConstraintName nvarchar(200)

                SELECT @ConstraintName = Name

                FROM SYS.DEFAULT_CONSTRAINTS

                WHERE PARENT_OBJECT_ID = OBJECT_ID(@tableName)

                AND PARENT_COLUMN_ID = (

                    SELECT column_id FROM sys.columns

                    WHERE NAME = @columnName AND object_id = OBJECT_ID(@tableName))

                IF @ConstraintName IS NOT NULL

                    EXEC('ALTER TABLE '+@tableName+' DROP CONSTRAINT ' + @ConstraintName);"

                        "ALTER TABLE \"{table_name}\" ALTER COLUMN \"{}\" SET NOT NULL;", entity_field.field_name

                    ),

                        "ALTER TABLE \"{table_name}\" ALTER COLUMN {} {} NOT NULL",

                        entity_field.field_name,

                    ),

                }

            }

                "ALTER TABLE \"{table_name}\" ALTER COLUMN \"{}\" ADD GENERATED ALWAYS AS IDENTITY;", entity_field.field_name

                "ALTER TABLE \"{table_name}\" ALTER COLUMN \"{}\" DROP IDENTITY;", entity_field.field_name

        };

}

/// Helper for operations involving sequences

#[cfg(feature = "postgres")]

enum SequenceOperation {

}

#[cfg(feature = "postgres")]

impl Transaction<Self> for SequenceOperation {}

#[cfg(feature = "postgres")]

#[async_trait]

impl DatabaseOperation for SequenceOperation {

        let stmt = match self {

                    "SELECT setval(pg_get_serial_sequence('\"{table_name}\"', '{}'), max(\"{}\")) from \"{table_name}\";",

                    entity_field.field_name, entity_field.field_name

                )

            }

        };

}