import * as Ts from './ts'
import { createPool, ConnectionConfig, MysqlError } from 'mysql';
import { ipcMain,webContents,WebContents} from 'electron'
import dayjs from 'dayjs'
type errorFun = Ts.errorFun
function passwordMath(len: number): string {
    const s = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    // prompt("请输入密码的长度");
    let pass = "";
    for (let i = 0; i < len; i++) {
        const b = Math.random() * 62;
        const c = Math.floor(b);
        pass += s[c];
    }
    return pass
}
const sqldatetime = () => dayjs().format('YYYY-MM-DD HH:mm:ss')
export default class <Tables extends Ts.TablesInterface> implements errorFun, Ts.poolFun, Ts.curdFun<Tables> {
    protected pool
    protected readonly _JOINS
    protected readonly _ipcname
    constructor(
        JOINS: { [T in keyof Tables]: readonly string[] },
        ipcName: number,
        config: ConnectionConfig
    ) {
        this._JOINS = JOINS
        this._ipcname = ipcName.toString()
        this.pool = createPool({ "dateStrings": false, ...config })
    }
    private binJoin = ({ table }: { table: keyof Tables }): string => {
        return this._JOINS[table].map(v => 'inner' + ' ' + v).join(' ')
    }
    private binUpdateSet = <K extends keyof Tables>({ table, set }: { table: K, set: Partial<Tables[K]['field']> }): [string, Array<Ts.valSqlUse>] => {
        let kv: { k: Array<string>, v: Array<Ts.valSqlUse> } = { k: [], v: [] }
        const uptimestamp = sqldatetime()
        set = { ...set, uptimestamp }
        Object.entries(set).forEach(([k, v]) => {
            if (v === null || v === undefined) {
                kv.k.push(`${table}.${k}=null`)
            } else if (v === false || v === undefined) {
                kv.k.push(`${table}.${k}=0`)
            } else if (v === true) {
                kv.k.push(`${table}.${k}=1`)
            } else {
                kv.k.push(`${table}.${k}=?`)
                kv.v.push(v)
            }
        })
        return [' set ' + kv.k.join(' , '), kv.v]
    }
    private binInsertSet = <K extends keyof Tables>({ table, set }: { table: K, set: Omit<Tables[K]['field'], 'id'> }): [string, Array<Ts.valSqlUse>] => {
        let kv: { k: Array<string>, v: Array<Ts.valSqlUse> } = { k: [], v: [] }
        const uptimestamp = sqldatetime()
        set = { ...set, uptimestamp }
        Object.entries(set).forEach(([k, v]) => {
            if (v === null || v === undefined) {
                kv.k.push(`${table}.${k}=null`)
            } else if (v === false || v === undefined) {
                kv.k.push(`${table}.${k}=0`)
            } else if (v === true) {
                kv.k.push(`${table}.${k}=1`)
            } else {
                kv.k.push(`${table}.${k}=?`)
                kv.v.push(v)
            }
        })
        return [' set ' + kv.k.join(' , '), kv.v]
    }
    private binWhere<K extends keyof Tables>(where: { [TS in Tables[K]['join'] | K]?: Partial<Tables[TS]['field']> }): [string, Array<Ts.valSqlUse>] {
        let kv: { k: Array<string>, v: Array<Ts.valSqlUse> } = { k: [], v: [] }
        Object.entries(where).forEach(([tname, obj]) => {
            Object.entries(obj as Record<string, Ts.valApiFrom>).forEach(([k, v]) => {
                if (v === null || v === undefined) {
                    kv.k.push(`${tname}.${k} is null`)
                } else if (v === false) {
                    kv.k.push(`${tname}.${k}=0`)
                } else if (v === true) {
                    kv.k.push(`${tname}.${k}=1`)
                } else {
                    kv.k.push(`${tname}.${k}=?`)
                    kv.v.push(v)
                }
            })
        })
        const wherek = kv.k.length ? ' where ' + kv.k.join(' and ') : ''
        return [wherek, kv.v]
    }
    userError: errorFun['userError'] = (message) => {
        return { api: 'userError', res: { message: 'userError', bool: true } }
    }
    configError: errorFun['configError'] = ({ message }) => {
        return { api: 'configError', res: { message, bool: true } }
    }
    queryError: errorFun['queryError'] = ({ message }) => {
        return { api: 'queryError', res: { message, bool: true } }
    }
    getConnectionError: errorFun['getConnectionError'] = ({ message }) => {
        return { api: 'getConnectionError', req: { message: '' }, res: { message, bool: true } }
    }
    testconfig: Ts.poolFun['testconfig'] = () => new Promise((ok, err) => {
        return this.pool.getConnection((errMsg) => errMsg ? err(this.configError(errMsg)) : ok(true))
    })
    setconfig: Ts.poolFun['setconfig'] = (param) => new Promise((ok, err) => {
        this.pool = createPool({ ...param, "dateStrings": false })
        return this.pool.getConnection((errMsg) => errMsg ? err(this.configError(errMsg)) : ok(true))
    })
    select: Ts.curdFun<Tables>['select'] = (c) => new Promise((ok, err) => {
        const [sqlstr, values] = this.binWhere(c['where'])
        const sql = [
            `select ${c.table}.* from ${c.table}`,
            this.binJoin(c),
            sqlstr,
        ].join(' ')
        this.pool.getConnection((errMsg, conn) => errMsg ?
            err(this.getConnectionError(errMsg)) :
            conn.query({ sql, values }, (errmsg, success, field) => {
                conn.release()
                return errmsg ? err(this.queryError(errMsg)) : ok(success)
            }))
    })
    insert: Ts.curdFun<Tables>['insert'] = (c) => new Promise((ok, err) => {
        const [sqlstr, values] = this.binInsertSet(c)
        const sql = [
            `insert into ${c.table}`,
            sqlstr,
        ].join(' ')
        this.pool.getConnection((errMsg, conn) => errMsg ?
            err(this.getConnectionError(errMsg)) :
            conn.query({ sql, values }, (errmsg, data, field) => {
                conn.release()
                if (errmsg) {
                    err(this.queryError(errMsg))
                } else {
                    const selectsql = [
                        `select ${c.table}.* from ${c.table}`,
                        'where id=?'
                    ].join(' ')
                    conn.query({ sql: selectsql, values: [data.insertId] }, (errmsg, success, field) => {
                        conn.release()
                        if (errmsg) {
                            err(this.queryError(errMsg))
                        } else {
                            ok(success)
                        }
                    })
                }
            }))
    })
    update: Ts.curdFun<Tables>['update'] = (c) => new Promise((ok, err) => {
        const [setsql, setvalues] = this.binUpdateSet(c)
        const [wheresql, wheresqlvalues] = this.binWhere(c['where'])
        const updatesql = [
            `update ${c.table}`,
            this.binJoin(c),
            setsql,
            wheresql
        ].join(' ')
        this.pool.getConnection((errMsg, conn) => errMsg ?
            err(this.getConnectionError(errMsg)) :
            conn.query({ sql: updatesql, values: setvalues.concat(wheresqlvalues) }, (errmsg, data, field) => {
                if (errmsg) {
                    err(this.queryError(errMsg))
                } else {
                    const selectsql = [
                        `select ${c.table}.* from ${c.table}`,
                        this.binJoin(c),
                        wheresql
                    ].join(' ')
                    conn.query({ sql: selectsql, values: wheresqlvalues }, (errmsg, success, field) => {
                        conn.release()
                        if (errmsg) {
                            err(this.queryError(errMsg))
                        } else {
                            ok(success)
                        }
                    })
                }
            }))
    })
    delete: Ts.curdFun<Tables>['delete'] = (c) => new Promise((ok, err) => {
        const [wheresql, wheresqlvalues] = this.binWhere(c['where'])
        const updatesql = [
            `delete ${c.table} from  ${c.table}`,
            this.binJoin(c),
            wheresql
        ].join(' ')
        this.pool.getConnection((errMsg, conn) => errMsg ?
            err(this.getConnectionError(errMsg)) :
            conn.query({ sql: updatesql, values: wheresqlvalues }, (errmsg, data, field) => {
                if (errmsg) {
                    err(this.queryError(errMsg))
                } else {
                    const selectsql = [
                        `select ${c.table}.* from ${c.table}`,
                        this.binJoin(c),
                        wheresql
                    ].join(' ')
                    conn.query({ sql: selectsql, values: wheresqlvalues }, (errmsg, success, field) => {
                        conn.release()
                        if (errmsg) {
                            err(this.queryError(errMsg))
                        } else {
                            ok(success)
                        }
                    })
                }
            }))
    })
    electronDemo(handle: typeof ipcMain.handle,webContents: typeof WebContents) {
        handle(this._ipcname, async (event, op) => {
            try {
               const data= (this as any)[op.api](op.param)
                    .then((success: any) => ({ ...op, success }))
                webContents.getAllWebContents().forEach(w=>w.send(this._ipcname,data))
            } catch (e) {
                return e
            }
        })
    }
    axios = () => { }

    socket = () => { }
}