import { Knex } from 'knex'
import moment from 'moment'

import "@total-typescript/ts-reset/dist/filter-boolean"
import { ModelTemplate } from '++/libs/models'
import { PlataSql } from '..'


declare global {
    namespace Sql {

        type SqlRawSelectColTypes =
            | 'number'
            | 'date'
            | 'string'
        ; 

        type SqlRawSelectCamp<T> = 
            [col: (s: Knex.QueryBuilder<T, any>) => Knex.QueryBuilder<T, any>, type: SqlRawSelectColTypes, required?: 'required' ]
        ;

        type SqlRawSelectColTypesValues<V extends SqlRawSelectColTypes> = 
            V extends 'number' ? number
            : V extends 'date' ? Date
            : V extends 'string' ? string
            : never
        ;

        type isRequired<I> = 
            I extends 'required' ? undefined
            : null
        ;

        interface SqlRawSelectInfo<T> {
            table: string
            cols: Record<string, SqlRawSelectCamp<T>>
            query: (s: Knex.QueryBuilder<T, any>, t: T) => Knex.QueryBuilder<any, any>,
            comments?: Record<string, string>
        }

        type ExtractSqlRawSelectInfo<const I extends SqlRawSelectInfo<any>> = 
            Prettify<{
                [K in keyof I['cols']]: Exclude<SqlRawSelectColTypesValues<I['cols'][K][1]> | isRequired<I['cols'][K][2]>, undefined>
            }>
        ;

        type SqlGetFunc<const T extends ModelTemplate,const D extends boolean = false> = 
            (builder: Sql.Builder<T['template']>, sql: PlataSql.Driver<D>) => PlataPromise<T['type'][]>
        ;

        interface CacheTable {
            coluns: Record<string | number | symbol, Knex.ColumnInfo>
            date: Date
        }

        interface InsertOptions {
            ignoreTrigger?: true 
            comments?: Record<string, string>
        }

        interface UpdateOptions {
            comments?: Record<string, string>
        }

        interface SelectOptions {
            comments?: Record<string, string>
        }

        type ModelQueryBuilder<T extends Model.Template> = 
            Knex.QueryBuilder<Model.ExtractTemplateType<T>, Model.ExtractTemplateType<T>[]>
        ;

        type Builder<T extends Model.Template> = 
            (s: ModelQueryBuilder<T>) => ModelQueryBuilder<T>
        ;

        interface StreamHandler {
            close: <Y>() => PlataPromise<Y>
            row: <T>(row: T) => Promise<boolean>
            error?: (err) => Promise<void>
        }

        type ModelList<T extends Model.Template> = PlataPromise<{
            errors: undefined
            itens: Model.ExtractTemplateType<T>[]
        } | {
            errors: PlataError[]
            itens: Model.ExtractTemplateTypeNotValid<T>[]
        }>

        type EachRowCallBack<T extends Model.Template> = 
            (x: Model.ModelValidateReturn<T>) => PlataPromise<true>
        ;

        type TimeZoneDate = Date & { __type: 'sql' }

        type TransactionFunction<T, Y> = (sql: T) => Promise<Y>

        type TransactionReturn = 
            | boolean
            | string
            | number
            | Record<string, any>
            | ((...args: any[]) => any)
        ;
        type TransactionResultFunction<T, Y extends TransactionReturn> = (sql: T) => PlataPromise<Y>

        type Joins = 
        'JOIN'
        | `${
            'LEFT' 
            | 'CROSS'
            | 'INNER'
            | 'OUTER'
            | 'RIGHT'
            | 'FULL OUTER'
            | 'LEFT OUTER'
        } JOIN`
    ;
    }
}