use serde::Deserialize;

#[cfg(feature = "mssql")]

use async_std::net::TcpStream;

#[cfg(feature = "mysql")]

use mysql_async::Pool;

#[cfg(feature = "mssql")]

use tiberius::{AuthMethod, Config};

#[cfg(feature = "postgres")]

use tokio_postgres::{Client, NoTls};

use crate::datasources::{Auth, DatasourceConfig};

/// Represents the current supported databases by Canyon

pub enum DatabaseType {

    #[serde(alias = "postgres", alias = "postgresql")]

    #[cfg(feature = "postgres")]

    PostgreSql,

    #[serde(alias = "sqlserver", alias = "mssql")]

    #[cfg(feature = "mssql")]

    SqlServer,

    #[serde(alias = "mysql")]

    #[cfg(feature = "mysql")]

    MySQL,

}

impl From<&Auth> for DatabaseType {

        }

}

/// A connection with a `PostgreSQL` database

#[cfg(feature = "postgres")]

pub struct PostgreSqlConnection {

    pub client: Client,

    // pub connection: Connection<Socket, NoTlsStream>, // TODO Hold it, or not to hold it... that's the question!

}

/// A connection with a `SqlServer` database

#[cfg(feature = "mssql")]

pub struct SqlServerConnection {

    pub client: &'static mut tiberius::Client<TcpStream>,

}

/// A connection with a `Mysql` database

#[cfg(feature = "mysql")]

pub struct MysqlConnection {

    pub client: Pool,

}

/// The Canyon database connection handler. When the client's program

/// starts, Canyon gets the information about the desired datasources,

/// process them and generates a pool of 1 to 1 database connection for

/// every datasource defined.

pub enum DatabaseConnection {

    #[cfg(feature = "postgres")]

    Postgres(PostgreSqlConnection),

    #[cfg(feature = "mssql")]

    SqlServer(SqlServerConnection),

    #[cfg(feature = "mysql")]

    MySQL(MysqlConnection),

}

unsafe impl Send for DatabaseConnection {}

unsafe impl Sync for DatabaseConnection {}

impl DatabaseConnection {

            #[cfg(feature = "postgres")]

            DatabaseType::PostgreSql => {

                        }

                    },

                    #[cfg(feature = "mssql")]

                    crate::datasources::Auth::SqlServer(_) => {

                    }

                    #[cfg(feature = "mysql")]

                    crate::datasources::Auth::MySQL(_) => {

                    }

                };

                        "postgres://{user}:{pswd}@{host}:{port}/{db}",

                        user = username,

                        pswd = password,

                        host = datasource.properties.host,

                        db = datasource.properties.db_name

                    NoTls,

                )

                    client: new_client,

                    // connection: new_connection,

                }))

            #[cfg(feature = "mssql")]

            DatabaseType::SqlServer => {

                // Using SQL Server authentication.

                    #[cfg(feature = "postgres")]

                    crate::datasources::Auth::Postgres(_) => {

                    }

                        }

                    },

                    #[cfg(feature = "mysql")]

                    crate::datasources::Auth::MySQL(_) => {

                    }

                });

                // on production, it is not a good idea to do this. We should upgrade

                // Canyon in future versions to allow the user take care about this

                // configuration

                // Taking the address from the configuration, using async-std's

                // TcpStream to connect to the server.

                    .expect("Error instantiating the SqlServer TCP Stream");

                // We'll disable the Nagle algorithm. Buffering is handled

                // internally with a `Sink`.

                    .expect("Error in the SqlServer `nodelay` config");

                // Handling TLS, login and other details related to the SQL Server.

                    )),

                }))

            #[cfg(feature = "mysql")]

            DatabaseType::MySQL => {

                    #[cfg(feature = "mssql")]

                    crate::datasources::Auth::SqlServer(_) => {

                    }

                    #[cfg(feature = "postgres")]

                    crate::datasources::Auth::Postgres(_) => {

                    }

                    #[cfg(feature = "mysql")]

                        }

                    },

                };

                //TODO add options to optionals params in url

                    "mysql://{}:{}@{}:{}/{}",

                    user,

                    password,

                    datasource.properties.host,

                    datasource.properties.db_name

                );

                    client: { mysql_connection },

                }))

        }

    #[cfg(feature = "postgres")]

            #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]

        }

    #[cfg(feature = "mssql")]

            #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]

        }

    #[cfg(feature = "mysql")]

            #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]

        }

}

#[cfg(test)]

mod database_connection_handler {

    use super::*;

    use crate::CanyonSqlConfig;

    /// Tests the behaviour of the `DatabaseType::from_datasource(...)`

    #[test]

    fn check_from_datasource() {

        #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]

        {

            const CONFIG_FILE_MOCK_ALT_ALL: &str = r#"

                [canyon_sql]

                datasources = [

                    {name = 'PostgresDS', auth = { postgresql = { basic = { username = "postgres", password = "postgres" } } }, properties.host = 'localhost', properties.db_name = 'triforce', properties.migrations='enabled' },

                    {name = 'SqlServerDS', auth = { sqlserver = { basic = { username = "sa", password = "SqlServer-10" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' },

                    {name = 'MysqlDS', auth = { mysql = { basic = { username = "root", password = "root" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' }

                ]

            "#;

            let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_ALL)

                .expect("A failure happened retrieving the [canyon_sql] section");

            assert_eq!(

                config.canyon_sql.datasources[0].get_db_type(),

                DatabaseType::PostgreSql

            );

            assert_eq!(

                config.canyon_sql.datasources[1].get_db_type(),

                DatabaseType::SqlServer

            );

            assert_eq!(

                config.canyon_sql.datasources[2].get_db_type(),

                DatabaseType::MySQL

            );

        }

        #[cfg(feature = "postgres")]

        {

            const CONFIG_FILE_MOCK_ALT_PG: &str = r#"

                [canyon_sql]

                datasources = [

                    {name = 'PostgresDS', auth = { postgresql = { basic = { username = "postgres", password = "postgres" } } }, properties.host = 'localhost', properties.db_name = 'triforce', properties.migrations='enabled' },

                ]

            "#;

            let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_PG)

                .expect("A failure happened retrieving the [canyon_sql] section");

            assert_eq!(

                config.canyon_sql.datasources[0].get_db_type(),

                DatabaseType::PostgreSql

            );

        }

        #[cfg(feature = "mssql")]

        {

            const CONFIG_FILE_MOCK_ALT_MSSQL: &str = r#"

                [canyon_sql]

                datasources = [

                    {name = 'SqlServerDS', auth = { sqlserver = { basic = { username = "sa", password = "SqlServer-10" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' }

                ]

            "#;

            let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_MSSQL)

                .expect("A failure happened retrieving the [canyon_sql] section");

            assert_eq!(

                config.canyon_sql.datasources[0].get_db_type(),

                DatabaseType::SqlServer

            );

        }

        #[cfg(feature = "mysql")]

        {

            const CONFIG_FILE_MOCK_ALT_MYSQL: &str = r#"

                [canyon_sql]

                datasources = [

                    {name = 'MysqlDS', auth = { mysql = { basic = { username = "root", password = "root" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' }

                ]

            "#;

            let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_MYSQL)

                .expect("A failure happened retrieving the [canyon_sql] section");

            assert_eq!(

                config.canyon_sql.datasources[0].get_db_type(),

                DatabaseType::MySQL

            );

        }

    }

}