/**
 * 字段验证器
 * @author ranyunlong<549510622@qq.com>
 * license MIT
 */


import { TKServer } from "./Server";
import { BadRequestException } from "./exceptions";
/**
 * i18n
 * 国际化
 * @author ranyunlong<549510622@qq.com>
 * license MIT
 */

interface I18n {
    "ar-AE"?: string;
    "ar-DZ"?: string; 
    "ar-EG"?: string; 
    "ar-JO"?: string; 
    "ar-SA"?: string; 
    "ar-SY"?: string; 
    "be-BY"?: string; 
    "bg-BG"?: string; 
    "cs-CZ"?: string; 
    "de-DE"?: string; 
    "da-DK"?: string;
    "el-GR"?: string; 
    "en-AU"?: string; 
    "en-GB"?: string; 
    "en-HK"?: string; 
    "en-IN"?: string; 
    "en-KE"?: string; 
    "en-NG"?: string; 
    "en-NZ"?: string; 
    "en-UG"?: string; 
    "en-RW"?: string; 
    "en-SG"?: string;
    "en-TZ"?: string; 
    "en-PK"?: string; 
    "en-US"?: string; 
    "en-CA"?: string; 
    "en-ZA"?: string; 
    "en-ZM"?: string; 
    "es-ES"?: string;
    "fa-IR"?: string; 
    "fi-FI"?: string; 
    "fo-FO"?: string;
    "fr-FR"?: string;
    "he-IL"?: string;
    "hu-HU"?: string;
    "id-ID"?: string;
    "it-IT"?: string;
    "ja-JP"?: string;
    "kk-KZ"?: string;
    "kl-GL"?: string;
    "ko-KR"?: string;
    "lt-LT"?: string;
    "ms-MY"?: string;
    "nb-NO"?: string;
    "nn-NO"?: string;
    "pl-PL"?: string;
    "pt-PT"?: string;
    "ro-RO"?: string;
    "ru-RU"?: string;
    "sk-SK"?: string;
    "sr-RS"?: string;
    "th-TH"?: string;
    "tr-TR"?: string;
    "uk-UA"?: string;
    "vi-VN"?: string;
    "zh-CN"?: string;
    "zh-HK"?: string;
    "zh-TW"?: string;
    [key: string]: string;
 }

interface Validator {
    validator(lang: string): boolean;
    message: I18n;
}

interface ValidatorConstructor {
    new (data: string): Validator;
    message: I18n;
}

/**
 * validate
 * 验证方法
 * @param data 验证的参数
 * @param Validator 验证器类
 * @param lang 语言
 */
function validate(data: any, Validator: ValidatorConstructor, language: string): boolean {
    return new Validator(data).validator(language)
}


/**
 * getError
 * 获取错误信息
 * @param Validator 验证器类
 * @param data 验证的参数
 * @param language 语言
 */
function getError(Validator: ValidatorConstructor, data: any, language: string) {
    return {
        debug: Validator.message['en-US'] + ',Receive parameter ' + data,
        error: Validator.message[language]
    }
}

/**
 * validator
 * 多类型验证
 * 多类型验证时 只要有一种类型验证通过，即为验证成功
 * 默认验证为惰性验证，既有参数时验证，无参数时默认通过
 * 必须验证 如果验证类型中包含名为 VRequired的验证类时 数据为必须验证
 * @param rules 验证规则
 * @param data 验证的值
 */
export function validator(rules: Rules, vDatas: Datas | undefined, options: TKServer.Options): TKServer.Validator<any> {
    // 获取系统语言
    const language = options.language;
    // 验证是失败的调试信息
    let debugs: Datas = {}
    // 验证过的数据
    let datas: Datas = {}
    // 验证失败的错误信息
    let errors: Datas = {}
    // 遍历规则
    Object.keys(rules).forEach((key: string) => {
        // 对应验证器的数据
        const data = vDatas[key]
        const Validator = rules[key]
        // 如果有多个验证器
        if (Array.isArray(Validator)) {
            // 过滤是否包含必须验证
            let error: Array<ValidatorConstructor> = [];
            
            // 验证必须验证
            error = Validator.filter((k: ValidatorConstructor) => {
                if (k.name === 'VRequired') {
                    return !validate(data, k, language)
                }
            })

            // 验证失败
            if(error.length > 0) {
                const err = getError(error[0], data, language)
                debugs[key] = err.debug
                errors[key] = err.error
                return;
            }

            // 验证必须以外的其他数据
            const result = Validator.map((k: ValidatorConstructor) => {
                if (k.name !== 'VRequired') {
                    if (!validate(data, k, language)) {
                        error.push(k)
                        return false
                    }
                    return true
                }
            })

            // 如果验证结果不包含true 验证失败
            if(result.filter(k => k).length === 0) {
                let errs: string[] = []
                let debs: string[] = []
                error.forEach((k: ValidatorConstructor)=>{
                    const err = getError(k, data, language)
                    errs.push(err.error)
                    debs.push(err.debug)
                })

                errors[key] = errs.join(',')
                debugs[key] = debs.join(',')
            }
        } else {
            if (!validate(data, Validator, language)) {
                const err = getError(Validator, data, language)
                debugs[key] = err.debug
                errors[key] = err.error
            }
        }
        
        // 验证通过的数据
        if (!errors[key]) {
            datas[key] = data
        }
    })
    
    return {
        get data() {
            if (Object.keys(errors).length > 0) {
                throw new BadRequestException(debugs, errors)
            }
            return datas
        }
    }
}

export interface Rules {
    [key:string]: ValidatorConstructor | Array<ValidatorConstructor>
}

export interface Datas {
    [key:string]: any;
}