import BaseFunc from '../base/func';
import BaseSupport from '../base/support';
import BaseDefine from '../base/define';

import { IbaseFlagResult } from "../aim/face";


export interface IregexDefine {
    /**
     * 字段名称
     * 
     * @type {string}
     * @memberof IregexSet
     */
    label?: string
    /**
     * 基本正则标记类型
     * 
     * @type {string}
     * @memberof IregexSet
     */
    base?: string

    /**
     * 是否必填  1为必填
     * 
     * @type {number}
     * @memberof IregexDefine
     */
    require?: number

    /**
     * 正则标记
     * 
     * @type {IregexSub[]}
     * @memberof IregexDefine
     */
    regex?: IregexSub[]

}


interface IregexSub {
    /**
     * 正则规则
     * 
     * @type {string}
     * @memberof IregexSub
     */
    math: string
    /**
     * 基本提示编号  内部字段  外部请勿使用
     * 
     * @type {number}
     * @memberof IregexSub
     */
    lang?: number
    /**
     * 不符合该条规则时的提示信息
     * 
     * @type {string}
     * @memberof IregexSub
     */
    error?: string
}




interface IregexBase {
    [key: string]: IregexSub
}

const regexBaseDefine: IregexBase = {
    //数字
    number: { math: '^^[0-9]+\\.{0,1}[0-9]{0,4}$', lang: 12303 },
    //身份证号码
    cardno: { math: '(^\\d{15}$)|(^\\d{17}([0-9]|X)$)', lang: 12304 },
    //手机号
    phone: { math: '^1\\d{10}$', lang: 12304 },
    //邮件
    email: { math: '^\\w+@(\\w+\\.)+[a-z]{1,8}$', lang: 12304 }
}


export default class {



    static upRegexDefineByString(sRegexCode: string): IregexDefine {


        let oDefine: IregexDefine = {};

        if (sRegexCode.startsWith(BaseDefine.upPlusDefine().encodeStart)) {
            oDefine = JSON.parse(BaseSupport.cryptoBase64Decode(sRegexCode.substr(BaseDefine.upPlusDefine().encodeStart.length)));

        } else {
            let oMapRegex = BaseFunc.stringToMap(sRegexCode);

            if (oMapRegex.has('label')) {
                oDefine.label = oMapRegex.get('label');
            }

            if (oMapRegex.has('base')) {
                oDefine.base = oMapRegex.get('base');
            }
            if (oMapRegex.has('require')) {
                oDefine.require = parseInt(oMapRegex.get('require'));
            }
        }




        return oDefine;
    }



    static verify(sFieldValue: string, oRegexSet: IregexDefine): IbaseFlagResult {


        let oResult: IbaseFlagResult = { flagSuccess: true, errorMessage: BaseFunc.upLang(12301) };
        if (oRegexSet.regex === undefined) {
            oRegexSet.regex = [];
        }



        //校验必填操作
        if (oResult.flagSuccess) {
            if (oRegexSet.require === 1) {
                if (BaseFunc.stringIsEmpty(sFieldValue)) {
                    oResult.errorMessage = oRegexSet.label + BaseFunc.upLang(12302);
                    oResult.flagSuccess = false;
                }
            }
        }


        //基本表达式添加到列表中
        if (oResult.flagSuccess) {

            if (!BaseFunc.stringIsEmpty(oRegexSet.base)) {

                if (regexBaseDefine[oRegexSet.base] != undefined) {

                    oRegexSet.regex.splice(0, 0, regexBaseDefine[oRegexSet.base]);

                } else {
                    oResult.errorMessage = oRegexSet.label + BaseFunc.upLang(12301);
                    oResult.flagSuccess = false;
                }

            }

        }

        //开始执行正则验证
        if (oResult.flagSuccess) {
            //这里判断值非空才进行正则表达式的校验  是否非空由require来控制
            if (!BaseFunc.stringIsEmpty(sFieldValue)) {
                oRegexSet.regex.forEach(
                    (fItem) => {
                        if (oResult.flagSuccess) {

                            let oReg = new RegExp(fItem.math);
                            //如果验证不正确
                            if (!oReg.test(sFieldValue)) {
                                oResult.flagSuccess = false;
                                if (fItem.lang != undefined) {
                                    oResult.errorMessage = oRegexSet.label + BaseFunc.upLang(fItem.lang);
                                }
                                else {
                                    oResult.errorMessage = fItem.error;
                                }

                            }

                        }
                    }
                );
            }
        }




        //如果所有正则验证都成功  则标记为成功
        if (oResult.flagSuccess) {

            oResult.errorMessage = '';
        }



        return oResult;
    }


}