use std::fmt::Debug;

use canyon_connection::{

    canyon_database_connector::DatabaseType, get_database_config, DATASOURCES,

};

use crate::{

    bounds::{FieldIdentifier, FieldValueIdentifier, QueryParameter},

    crud::{CrudOperations, Transaction},

    mapper::RowMapper,

    query_elements::query::Query,

    Operator,

};

/// Contains the elements that makes part of the formal declaration

/// of the behaviour of the Canyon-SQL QueryBuilder

pub mod ops {

    pub use super::*;

    /// The [`QueryBuilder`] trait is the root of a kind of hierarchy

    /// on more specific [`super::QueryBuilder`], that are:

    ///

    /// * [`super::SelectQueryBuilder`]

    /// * [`super::UpdateQueryBuilder`]

    /// * [`super::DeleteQueryBuilder`]

    ///

    /// This trait provides the formal declaration of the behaviour that the

    /// implementors must provide in their public interfaces, groping

    /// the common elements between every element down in that

    /// hierarchy.

    ///

    /// For example, the [`super::QueryBuilder`] type holds the data

    /// necessary for track the SQL sentence while it's being generated

    /// thought the fluent builder, and provides the behaviour of

    /// the common elements defined in this trait.

    ///

    /// The more concrete types represents a wrapper over a raw

    /// [`super::QueryBuilder`], offering all the elements declared

    /// in this trait in its public interface, and which implementation

    /// only consists of call the same method on the wrapped

    /// [`super::QueryBuilder`].

    ///

    /// This allows us to declare in their public interface their

    /// specific operations, like, for example, join operations

    /// on the [`super::SelectQueryBuilder`], and the usage

    /// of the `SET` clause on a [`super::UpdateQueryBuilder`],

    /// without mixing types or convoluting everything into

    /// just one type.

    pub trait QueryBuilder<'a, T>

    where

        T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

    {

        /// Returns a read-only reference to the underlying SQL sentence,

        /// with the same lifetime as self

        fn read_sql(&'a self) -> &'a str;

        /// Public interface for append the content of an slice to the end of

        /// the underlying SQL sentece.

        ///

        /// This mutator will allow the user to wire SQL code to the already

        /// generated one

        ///

        /// * `sql` - The [`&str`] to be wired in the SQL

        fn push_sql(&mut self, sql: &str);

        /// Generates a `WHERE` SQL clause for constraint the query.

        ///

        /// * `column` - A [`FieldValueIdentifier`] that will provide the target

        /// column name and the value for the filter

        /// * `op` - Any element that implements [`Operator`] for create the comparison

        /// or equality binary operator

        fn r#where<Z: FieldValueIdentifier<'a, T>>(

            &mut self,

            column: Z,

            op: impl Operator,

        ) -> &mut Self

        where

            T: Debug + CrudOperations<T> + Transaction<T> + RowMapper<T>;

        /// Generates an `AND` SQL clause for constraint the query.

        ///

        /// * `column` - A [`FieldValueIdentifier`] that will provide the target

        /// column name and the value for the filter

        /// * `op` - Any element that implements [`Operator`] for create the comparison

        /// or equality binary operator

        fn and<Z: FieldValueIdentifier<'a, T>>(

            &mut self,

            column: Z,

            op: impl Operator,

        ) -> &mut Self;

        /// Generates an `AND` SQL clause for constraint the query that will create

        /// the filter in conjunction with an `IN` operator that will ac

        ///

        /// * `column` - A [`FieldIdentifier`] that will provide the target

        /// column name for the filter, based on the variant that represents

        /// the field name that maps the targeted column name

        /// * `values` - An array of [`QueryParameter`] with the values to filter

        /// inside the `IN` operator

        fn and_values_in<Z, Q>(&mut self, column: Z, values: &'a [Q]) -> &mut Self

        where

            Z: FieldIdentifier<T>,

            Q: QueryParameter<'a>;

        /// Generates an `OR` SQL clause for constraint the query that will create

        /// the filter in conjunction with an `IN` operator that will ac

        ///

        /// * `column` - A [`FieldIdentifier`] that will provide the target

        /// column name for the filter, based on the variant that represents

        /// the field name that maps the targeted column name

        /// * `values` - An array of [`QueryParameter`] with the values to filter

        /// inside the `IN` operator

        fn or_values_in<Z, Q>(&mut self, r#or: Z, values: &'a [Q]) -> &mut Self

        where

            Z: FieldIdentifier<T>,

            Q: QueryParameter<'a>;

        /// Generates an `OR` SQL clause for constraint the query.

        ///

        /// * `column` - A [`FieldValueIdentifier`] that will provide the target

        /// column name and the value for the filter

        /// * `op` - Any element that implements [`Operator`] for create the comparison

        /// or equality binary operator

        fn or<Z: FieldValueIdentifier<'a, T>>(&mut self, column: Z, op: impl Operator)

            -> &mut Self;

        /// Generates a `ORDER BY` SQL clause for constraint the query.

        ///

        /// * `order_by` - A [`FieldIdentifier`] that will provide the target

        /// column name

        /// * `desc` - a boolean indicating if the generated `ORDER_BY` must be

        /// in ascending or descending order

        fn order_by<Z: FieldIdentifier<T>>(&mut self, order_by: Z, desc: bool) -> &mut Self;

    }

}

/// Type for construct more complex queries than the classical CRUD ones.

#[derive(Debug, Clone)]

pub struct QueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    query: Query<'a, T>,

    datasource_name: &'a str,

    datasource_type: DatabaseType,

}

unsafe impl<'a, T> Send for QueryBuilder<'a, T> where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>

{

}

unsafe impl<'a, T> Sync for QueryBuilder<'a, T> where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>

{

}

impl<'a, T> QueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    /// Returns a new instance of the [`QueryBuilder`]

            query,

            datasource_name,

            ),

        }

    /// Launches the generated query against the database targeted

    /// by the selected datasource

        )

        .into_results::<T>())

            + column_name

            + column_name

            + column_name

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

            return;

        }

            .sql

                    .sql

            } else {

                    .sql

            }

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

            return;

        }

            .sql

                    .sql

            } else {

                    .sql

            }

    #[inline]

                " ORDER BY {}{}",

            )),

}

#[derive(Debug, Clone)]

pub struct SelectQueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    _inner: QueryBuilder<'a, T>,

}

impl<'a, T> SelectQueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    /// Generates a new public instance of the [`SelectQueryBuilder`]

                datasource_name,

            ),

        }

    /// Launches the generated query to the database pointed by the

    /// selected datasource

    #[inline]

    /// Adds a *LEFT JOIN* SQL statement to the underlying

    /// [`Query`] held by the [`QueryBuilder`], where:

    ///

    /// * `join_table` - The table target of the join operation

    /// * `col1` - The left side of the ON operator for the join

    /// * `col2` - The right side of the ON operator for the join

    ///

    /// > Note: The order on the column parameters is irrelevant

            .query

            .sql

        self

    /// Adds a *RIGHT JOIN* SQL statement to the underlying

    /// [`Query`] held by the [`QueryBuilder`], where:

    ///

    /// * `join_table` - The table target of the join operation

    /// * `col1` - The left side of the ON operator for the join

    /// * `col2` - The right side of the ON operator for the join

    ///

    /// > Note: The order on the column parameters is irrelevant

            .query

            .sql

        self

    /// Adds a *RIGHT JOIN* SQL statement to the underlying

    /// [`Query`] held by the [`QueryBuilder`], where:

    ///

    /// * `join_table` - The table target of the join operation

    /// * `col1` - The left side of the ON operator for the join

    /// * `col2` - The right side of the ON operator for the join

    ///

    /// > Note: The order on the column parameters is irrelevant

    pub fn right_join(&mut self, join_table: &str, col1: &str, col2: &str) -> &mut Self {

        self._inner

            .query

            .sql

            .push_str(&format!(" RIGHT JOIN {join_table} ON {col1} = {col2}"));

        self

    }

    /// Adds a *FULL JOIN* SQL statement to the underlying

    /// [`Query`] held by the [`QueryBuilder`], where:

    ///

    /// * `join_table` - The table target of the join operation

    /// * `col1` - The left side of the ON operator for the join

    /// * `col2` - The right side of the ON operator for the join

    ///

    /// > Note: The order on the column parameters is irrelevant

    pub fn full_join(&mut self, join_table: &str, col1: &str, col2: &str) -> &mut Self {

        self._inner

            .query

            .sql

            .push_str(&format!(" FULL JOIN {join_table} ON {col1} = {col2}"));

        self

    }

}

impl<'a, T> ops::QueryBuilder<'a, T> for SelectQueryBuilder<'a, T>

where

    T: Debug + CrudOperations<T> + Transaction<T> + RowMapper<T> + Send,

{

    #[inline]

    #[inline(always)]

    fn push_sql(&mut self, sql: &str) {

        self._inner.query.sql.push_str(sql);

    }

    #[inline]

        &mut self,

        r#where: Z,

        op: impl Operator,

    ) -> &mut Self {

        self

    #[inline]

        self

    #[inline]

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

        self

    #[inline]

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

        self

    #[inline]

        self

    #[inline]

        self

}

/// Contains the specific database operations of the *UPDATE* SQL statements.

///  

/// * `set` - To construct a new `SET` clause to determine the columns to

/// update with the provided values

#[derive(Debug, Clone)]

pub struct UpdateQueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    _inner: QueryBuilder<'a, T>,

}

impl<'a, T> UpdateQueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    /// Generates a new public instance of the [`UpdateQueryBuilder`]

                datasource_name,

            ),

        }

    /// Launches the generated query to the database pointed by the

    /// selected datasource

    #[inline]

    /// Creates an SQL `SET` clause to especify the columns that must be updated in the sentence

    where

        Z: FieldIdentifier<T> + Clone,

        Q: QueryParameter<'a>,

    {

        }

                "\n{}",

                    + "\n\tPass all the values in a unique call within the 'columns' "

                    + "array of tuples parameter\n"

            )

        }

                "{} = ${}",

            }

        }

}

impl<'a, T> ops::QueryBuilder<'a, T> for UpdateQueryBuilder<'a, T>

where

    T: Debug + CrudOperations<T> + Transaction<T> + RowMapper<T> + Send,

{

    #[inline]

    fn read_sql(&'a self) -> &'a str {

        self._inner.query.sql.as_str()

    }

    #[inline(always)]

    fn push_sql(&mut self, sql: &str) {

        self._inner.query.sql.push_str(sql);

    }

    #[inline]

        &mut self,

        r#where: Z,

        op: impl Operator,

    ) -> &mut Self {

        self

    #[inline]

        self

    #[inline]

    fn and_values_in<Z, Q>(&mut self, r#and: Z, values: &'a [Q]) -> &mut Self

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

        self._inner.and_values_in(and, values);

        self

    }

    #[inline]

    fn or_values_in<Z, Q>(&mut self, r#or: Z, values: &'a [Q]) -> &mut Self

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

        self._inner.or_values_in(or, values);

        self

    }

    #[inline]

    fn or<Z: FieldValueIdentifier<'a, T>>(&mut self, column: Z, op: impl Operator) -> &mut Self {

        self._inner.or(column, op);

        self

    }

    #[inline]

    fn order_by<Z: FieldIdentifier<T>>(&mut self, order_by: Z, desc: bool) -> &mut Self {

        self._inner.order_by(order_by, desc);

        self

    }

}

/// Contains the specific database operations associated with the

/// *DELETE* SQL statements.

///  

/// * `set` - To construct a new `SET` clause to determine the columns to

/// update with the provided values

#[derive(Debug, Clone)]

pub struct DeleteQueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    _inner: QueryBuilder<'a, T>,

}

impl<'a, T> DeleteQueryBuilder<'a, T>

where

    T: CrudOperations<T> + Transaction<T> + RowMapper<T>,

{

    /// Generates a new public instance of the [`DeleteQueryBuilder`]

                datasource_name,

            ),

        }

    /// Launches the generated query to the database pointed by the

    /// selected datasource

    #[inline]

}

impl<'a, T> ops::QueryBuilder<'a, T> for DeleteQueryBuilder<'a, T>

where

    T: Debug + CrudOperations<T> + Transaction<T> + RowMapper<T> + Send,

{

    #[inline]

    fn read_sql(&'a self) -> &'a str {

        self._inner.query.sql.as_str()

    }

    #[inline(always)]

    fn push_sql(&mut self, sql: &str) {

        self._inner.query.sql.push_str(sql);

    }

    #[inline]

        &mut self,

        r#where: Z,

        op: impl Operator,

    ) -> &mut Self {

        self

    #[inline]

        self

    #[inline]

    fn and_values_in<Z, Q>(&mut self, r#and: Z, values: &'a [Q]) -> &mut Self

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

        self._inner.or_values_in(and, values);

        self

    }

    #[inline]

    fn or_values_in<Z, Q>(&mut self, r#or: Z, values: &'a [Q]) -> &mut Self

    where

        Z: FieldIdentifier<T>,

        Q: QueryParameter<'a>,

    {

        self._inner.or_values_in(or, values);

        self

    }

    #[inline]

    fn or<Z: FieldValueIdentifier<'a, T>>(&mut self, column: Z, op: impl Operator) -> &mut Self {

        self._inner.or(column, op);

        self

    }

    #[inline]

    fn order_by<Z: FieldIdentifier<T>>(&mut self, order_by: Z, desc: bool) -> &mut Self {

        self._inner.order_by(order_by, desc);

        self

    }

}