import Singleton from "../../patterns/Singleton";
import {MybatisRegExp} from "./MybatisRegExp";
import {logger} from "../../logger/Logger";
import {ArrayUtil} from "../../utils/ArrayUtil";

class UtilFunctions {
    [key: string]: any;

    public isnull(key: any) {
        if(typeof key == "number")
        {
            return key == null || typeof key == "undefined" || false || isNaN(key) ? false : true;
        }
        return key == null || typeof key == "undefined" || false || key == "" ? false : true;
    }

    public isnotnull(key: any) {
        if(typeof key == "number")
        {
            return key != null && typeof key != "undefined"  && true && !isNaN(key) ? true : false;
        }
        return typeof key != "undefined" && key != null && true && key != "" ? true : false;
    }

    public isEmpty(key: string) {
        return this.isnull(key.trim());
    }

}

export class QueryUtilsClass extends Singleton {
    [key: string]: any;

    public primitiveOperator = [
        {
            targetStr: "and|AND",
            operator: "&&"
        }, {
            targetStr: "or|OR",
            operator: "||"
        }, {
            targetStr: "==",
            operator: "==="
        }, {
            targetStr: "!=",
            operator: "!=="
        }, {
            targetStr: "xor|XOR",
            operator: "^"
        },
    ]

    public availableUtilityFunArr: Array<string> | undefined;

    public utilFunctions = new UtilFunctions();

    public getUtils(key: string) {
        return this.utilFunctions[key];
    }

    public parseParamsAndRunStatement(param: any, statement: string, dynamicCondition: any, isNullConvert = true): any {
        const utilName = "Utils"
        const paramValueName = "param"
        const dynamicConditionName = "dynamicCondition"
        let result;
        try {
            let that: QueryUtilsClass = QueryUtilsClass.getInstance()
            let Utils: UtilFunctions = that.utilFunctions;
            let primitiveOperator = [...that.primitiveOperator];

            for (let idx = 0; idx < primitiveOperator.length; idx++) {
                let priOps = primitiveOperator[idx];
                statement = statement.replace(MybatisRegExp.findOperator(priOps.targetStr), " " + priOps.operator + " ")
            }

            statement = that.parseParams(param, statement, dynamicCondition, utilName, paramValueName, dynamicConditionName)
            result = eval(statement);
        } catch (e) {

            if(isNullConvert)
            {
                logger.debug("convertParam error : ["+e+"] ");
            }
            return undefined;
        }
        return result;
    }

    public parseParams(param: any, statement: string, dynamicCondition: any, utilName?: string, paramValueName?: string, dynamicConditionName?: string) {

        let resultArr:any = statement.match(MybatisRegExp.getStatementToken);
        if (resultArr) {

            resultArr = ArrayUtil.uniqueArray(resultArr);

            for (let idx = 0; idx < resultArr.length; idx++) {
                let parseStr = resultArr[idx];
                if (parseStr.startsWith("@")) {
                    let utilFunName = parseStr.substring(1, parseStr.length);

                    if (dynamicCondition && dynamicCondition[utilFunName]) {
                        statement = statement.replace(MybatisRegExp.replaceQueryToken(parseStr), dynamicConditionName + "." + utilFunName);
                    } else if (QueryUtilsClass.getInstance().getUtils(utilFunName)) {
                        statement = statement.replace(MybatisRegExp.replaceQueryToken(parseStr), utilName + "." + utilFunName);
                    }
                }

                if (!MybatisRegExp.isNumber.test(parseStr)
                    &&
                    QueryUtilsClass.getInstance().getParamContains(param, parseStr)) {
                    let parmstrTmp = paramValueName + "." + parseStr;
                    if(param[parseStr] == 0 || param[parseStr] == 1)
                    {
                        parmstrTmp = "String("+ parmstrTmp+")"
                    }
                    statement = statement.replace(MybatisRegExp.replaceQueryToken(parseStr), parmstrTmp);
                }
            }
        }
        return statement;
    }


    public getParamContains(param: any, key: string) {
        if (key.indexOf(".") > 0) {
            let isFound = true;
            let checkParam = {...param};
            let keyArr = key.split(".");
            for (let idx = 0; idx < keyArr.length; idx++) {
                let subKey = keyArr[idx];
                if (!checkParam[subKey]) {
                    isFound = false;
                }
                checkParam = checkParam[subKey];
            }
            return isFound;
        }
        // return param[key];
        return Object.keys(param).indexOf(key) > -1
    }

    public parsePremitiveType(arg: any) {
        // string check
        if (
            (arg.startsWith("'") && arg.lastIndexOf("'") == arg.length - 1) ||
            (arg.startsWith("\"") && arg.lastIndexOf("\"") == arg.length - 1) ||
            (arg.startsWith("`") && arg.lastIndexOf("`") == arg.length - 1)
        ) {
            let str = arg.substring(1, arg.length - 1);
            if (MybatisRegExp.isDate.test(str)) {
                return new Date(str);
            }

            return `${str}`;
        }
        // number check
        else {
            let dotIdx = arg.indexOf(".");
            if (dotIdx != 0) {
                return eval(arg);
            }

            logger.error(`query parse parameter error : ${arg}`);
            return undefined;
        }
    }

    public replaceCdata(rawText: any) {
        let cdataRegex: any = MybatisRegExp.replaceCdata;
        let matches: any = rawText.match(cdataRegex);

        if (matches != null && matches.length > 0) {
            for (let z = 0; z < matches.length; z++) {
                let m: any = cdataRegex.exec(matches[z]);

                let cdataText = m[2];
                cdataText = cdataText.replace(/\&/g, '&amp;');
                cdataText = cdataText.replace(/\</g, '&lt;');
                cdataText = cdataText.replace(/\>/g, '&gt;');
                cdataText = cdataText.replace(/\"/g, '&quot;');

                rawText = rawText.replace(m[0], cdataText);
            }
        }

        return rawText;
    }
}

export const QueryUtils = QueryUtilsClass.getInstance();