import {DBConnection} from "../DBConnection";
import {logger} from "../../logger/Logger";
import QueryMapper from "../QueryMapper";
import {__is_prod} from "../../config/ApplicationEnvironment";
import {Pool, PoolConnection} from "mysql2/promise";
export default class MysqlDBConnection implements DBConnection {
    public pool: Pool;
    public conn: PoolConnection | undefined;
    public mapper:QueryMapper = QueryMapper.getInstance();
    public formatOption: any = {language: 'mysql', indent: '  '};

    constructor(pool: Pool) {
        this.pool = pool;
    }

    public async connect(): Promise<PoolConnection> {
        let conn
        try {
            conn = await this.pool.getConnection();
            return conn
        } catch (err) {
            logger.debug(`mysql connection error[${err}]`);
            //connection 제거
            try{
                if(conn) conn.destroy();
            } catch (e) {}
            throw err;
        }
    }

    public async selectNumber(queryId: string, param?: any, dynamicCondition?:any): Promise<number> {
        let val:number = 0;
        try {
            let query:string = this.mapper.getStatement(queryId, this.formatOption, param, dynamicCondition) as string
            if(!query || query == "" || !this.conn) throw new Error(`${queryId} is not exist.`);
            if(!__is_prod) logger.debug(`query id:${queryId}\n${query}`);
            // await this.conn.beginTransaction();
            let result:any = await this.conn.query(query);

            if (result[0] && result[0].length > 0) {
                const row = result[0][0];
                Object.keys(row).every((key)=> {
                    if(row.hasOwnProperty(key)) val = Number(row[key]);
                });
            }
        } catch (err) {
        }
        return val;
    }

    public async selectString(queryId: string, param?: any, dynamicCondition?:any): Promise<string> {
        let val = "";
        try {
            let query:string = this.mapper.getStatement(queryId, this.formatOption, param, dynamicCondition) as string
            if(!query || query == "" || !this.conn) throw new Error(`${queryId} is not exist.`);
            if(!__is_prod) logger.debug(`query id:${queryId}\n${query}`);
            // await this.conn.beginTransaction();
            let result:any = await this.conn.query(query);

            if (result[0] && result[0].length > 0) {
                const row = result[0][0];
                Object.keys(row).every((key)=> {
                    if(row.hasOwnProperty(key)) val = row[key];
                });
            }
        } catch (err) {
        }
        return val;
    }

    public async row<T>(queryId: string, param?: any, dynamicCondition?:any): Promise<any> {
        try {
            let query:string = this.mapper.getStatement(queryId, this.formatOption, param, dynamicCondition) as string
            if(!query || query == "" || !this.conn) throw new Error(`${queryId} is not exist.`);
            if(!__is_prod) logger.debug(`query id:${queryId}\n${query}`);
            // await this.conn.beginTransaction();
            let result:any = await this.conn.query(query);

            if (result[0] && result[0].length > 0) {
                return result[0][0] as T;
            }
            return undefined;
        } catch (err) {
            throw err
        }
    }

    public async query<T>(queryId: string, param?: any, dynamicCondition?:any): Promise<T> {
        try {
            let query:string = this.mapper.getStatement(queryId, this.formatOption, param, dynamicCondition) as string
            if(!query || query == "" || !this.conn) throw new Error(`${queryId} is not exist.`);
            if(!__is_prod) logger.debug(`query id:${queryId}\n${query}`);
            // await this.conn.beginTransaction();
            let result: any = await this.conn.query(query);

            return result[0] as T;
        } catch (err) {
            throw err
        }
    }

    public release() {
        try {
            if (this.conn) {
                this.conn.release();
            }
        } catch (e) {
            logger.info("db connection release.", e);
        }
    }

    public async beginTransaction(): Promise<void> {
        try {
            if (this.conn) {
                await this.conn.beginTransaction();
            }
        } catch (e) {
            logger.info("db connection beginTransaction.", e);
        }
    }

    public async commit(): Promise<void> {
        try {
            if (this.conn) {
                await this.conn.commit();
            }
        } catch (e) {
            logger.info("db connection commit.", e);
        }
    }

    public async rollback(): Promise<void> {
        try {
            if (this.conn) {
                await this.conn.rollback();
            }
        } catch (e) {
            logger.info("db connection rollback.", e);
        }
    }


}