import { EBoardKeyList } from "./BoardKeyList";
import { safeEval } from "./eval";
import { isNum } from "./Utils";

export enum CheckObjectType
{
    BR = "board",
    DR = "drill",
    AR = "array",
    Do = "door",
    RC = "referenceCutting",
    WR = "winerack",
    Lat = "lattice",
    RLB = "rotateLayerBoard",
    BBC = "boardbatchcurtail",
    BBS = "lookoverboardinfos",
    OnlyNumber = "onlyNum",
    None = "none",
}

export namespace CheckoutValid
{
    export function HasInvailValue(obj: Object, objType: CheckObjectType)
    {
        switch (objType)
        {
            case CheckObjectType.BR:
                return !Object.keys(obj).every(k =>
                    CheckoutBoardOption(k, obj[k]) === ""
                );
            case CheckObjectType.AR:
                return !Object.keys(obj).every(k =>
                    CheckoutArrayOption(k, obj[k]) === ""
                );
            case CheckObjectType.Do:
                return !Object.keys(obj).every(k =>
                    CheckoutDoorOption(k, obj[k]) === ""
                );
            case CheckObjectType.RC:
                return !Object.keys(obj).every(k =>
                    CheckOutReferenceCuttingOption(k, obj[k]) === ""
                );
            case CheckObjectType.WR:
                return !Object.keys(obj).every(k =>
                    CheckoutWineRackOption(k, obj[k]) === ""
                );
            case CheckObjectType.Lat:
                return !Object.keys(obj).every(k =>
                    CheckoutLatticeOption(k, obj[k]) === ""
                );
            case CheckObjectType.RLB:
                return !Object.keys(obj).every(k =>
                    CheckoutRotateLayerBoardOption(k, obj[k]) === ""
                );
            case CheckObjectType.BBC:
                return !Object.keys(obj).every(k =>
                    CheckBoardBatchCurtail(k, obj[k]) === ""
                );
            case CheckObjectType.BBS:
                return !Object.keys(obj).every(k =>
                    CheckLookOverBoardInfos(k, obj[k]) === ""
                );
            case CheckObjectType.DR:
                return !Object.keys(obj).every(k =>
                    CheckoutDrillOption(k, obj[k]) === ""
                );
            default:
                return true;
        }
    }
    export function CheckOption(type: CheckObjectType, k: string, v: string)
    {
        switch (type)
        {
            case CheckObjectType.BR:
                return CheckoutBoardOption(k, v);
            case CheckObjectType.DR:
                return CheckoutDrillOption(k, v);
            case CheckObjectType.AR:
                return CheckoutArrayOption(k, v);
            case CheckObjectType.Do:
                return CheckoutDoorOption(k, v);
            case CheckObjectType.RC:
                return CheckOutReferenceCuttingOption(k, v);
            case CheckObjectType.WR:
                return CheckoutWineRackOption(k, v);
            case CheckObjectType.Lat:
                return CheckoutLatticeOption(k, v);
            case CheckObjectType.RLB:
                return CheckoutRotateLayerBoardOption(k, v);
            case CheckObjectType.BBC:
                return CheckBoardBatchCurtail(k, v);
            case CheckObjectType.BBS:
                return CheckLookOverBoardInfos(k, v);
            case CheckObjectType.OnlyNumber:
                if (!isNum(v))
                    return "数值不能为空且必须为数字";
            default:
                return "";
        }
    }
    export function CheckoutBoardOption(k: string, v: string): string
    {
        let val = safeEval(v);
        switch (k)
        {
            case "calcHeight":
            case "calcWidth":
                if (isNaN(safeEval(v, { L: 1, H: 1, W: 1 })))
                    return "表达式错误";
                return "";
            case "sealedUp":
            case "sealedDown":
            case "sealedLeft":
            case "sealedRight":
            case "divCount":
                if (isNaN(val))
                    return "数值不能为空且必须为数字";
                if (!(val >= 0))
                    return "数值必须大于等于0";
                return "";
            case "spliteHeight":
            case "spliteWidth":
            case "spliteThickness":
                if (v !== "" && isNaN(safeEval(v, { L: 1, H: 1, W: 1 })))
                {
                    return "表达式错误";
                }
                return "";
            case "height":
            case "width":
            case "count":
            case "thickness":
            case "footThickness":
            case "knifeRadius":
                if (isNaN(val))
                    return "数值不能为空且必须为数字";
                if (!(val > 0))
                    return "数值必须大于0";
                return "";
            case "leftExt":
            case "rightExt":
            case "topExt":
            case "bottomExt":
            case "moveDist":
            case "spaceSize":
            case "frontShrink":
            case "rightShrink":
            case "leftShrink":
            case "bottomShrink":
            case "addCount":
            case "dist":
            case "front":
            case "behind":
            case "left":
            case "right":
            case "rad":
            case "length":
            case "depth":
            case "frontDist":
            case "behindDistance":
            case "leftExt":
            case "rightExt":
            case "offset":
            case "footBehindShrink":
            case "footerOffset":
            case "rotateX":
            case "rotateY":
            case "rotateZ":
            case "grooveAddLength":
            case "grooveAddDepth":
            case "grooveAddWidth":
            case "back":
                if (isNaN(val))
                    return "数值不能为空且必须为数字";
            default:
                return "";
        }
    }
    export function CheckoutDrillOption(k: string, v: string | boolean): string
    {
        if (typeof v === 'boolean')
            return "";
        switch (k)
        {
            case "ljgPos":
            case "woodPinPos":
                if (isNaN(safeEval(v, { L: 1, H: 1, W: 1 })))
                    return "表达式错误";
                return "";
            case "name":
            case "spacing":
            case "tempId":
            case "tempDirId":
                return "";
            case "pxlOffset":
            case "collsionDist":
            case "tHoleOffset":
            case "notGangDist":
                if (v === "")
                    return "不能为空";
                if (!(isNum(v)))
                    return "数值不能为空且必须为数字";
                return "";
            case "count":
            case "pxlRad":
            case "startDist":
            case "endDist":
            case "wbHoleRad":
            case "startDist":
            case "endDist":
                if (!(isNum(v)))
                    return "数值不能为空且必须为数字";
                else if ((safeEval(v) < 0))
                    return "数值不能小于0";
                else
                    return "";
            case "pxlDepth":
            case "ljgRad":
            case "ljgLength":
            case "ymjRad":
            case "ymjDepth":
            case "wbHoleDepth":
            case "wsHoleLength":
            case "wdepth":
            case "originDist":
            case "retDist":
            default:
                if (!(isNum(v)))
                    return "数值不能为空且必须为数字";
                else if (!(safeEval(v) > 0))
                    return "数值必须大于0";
        }
        return "";
    }
    export function CheckoutArrayOption(k: string, v: string): string
    {
        switch (k)
        {
            case "type":
            case "method":
            case "isCorrect":
                return "";
        }

        let val = safeEval(v);
        if (isNaN(val))
            return "数值不能为空且必须为数字";

        switch (k)
        {
            case "row":
            case "col":
                if (val > 32767 || val < 1 || val % 1 !== 0)
                    return "请输入1-32767间的整数";
                break;
            case "itemTotal":
                if (val > 32767 || val < 2 || val % 1 !== 0)
                    return "请输入2-32767间整数";
                break;
            case "betweenAngle":
                if (val <= 0)
                    return "数值不可小于或等于0";
                break;
            case "fillAngle":
                if (val === 0)
                    return "数值不可等于0";
                break;
            case "arrayAngle":
                if (Math.abs(val) > 360)
                    return "角度不可大于360";
                break;
            default:

        }
        return "";//ok
    }
    export function CheckoutDoorOption(k: string, v: string): string
    {
        let val = safeEval(v);
        switch (k)
        {
            case "drawerTotalDepth":
                if (isNaN(safeEval(v, { L: 1, H: 1, W: 1 })))
                    return "表达式错误";
                return "";
            case "row":
            case "col":
                if (isNaN(val))
                    return "数值不能为空,并且必须为数字";
                if (!isNaN(val) && val !== Math.floor(val))
                    return "数值必须1~20整数";
                return "";
            case "topOffset":
            case "bottomOffset":
            case "hingeCount":
            case "hindeTopDist":
            case "hindeBottomDist":
            case "handleAngle":
            case "topSpace":
            case "bottomSpace":
            case "leftSpace":
            case "rightSpace":
            case "midSpace":
            case "horSpacing":
            case "veSpacing":
                if (isNaN(val))
                    return "数值不能为空,并且必须为数字";
                return "";
            case "doorThickness":
                if (isNaN(val))
                    return "数值不能为空且必须为数字";
                if (!(val > 0))
                    return "数值必须大于0";
                return "";
            case "topBrSeal":
            case "bottomBrSeal":
            case "leftBrSeal":
            case "rightBrSeal":
            case "topDoorSeal":
            case "bottomDoorSeal":
            case "leftDoorSeal":
            case "rightDoorSeal":
                if (isNaN(val))
                    return "数值不能为空且必须为数字";
                if (!(val >= 0))
                    return "数值必须大于等于0";
                return "";
            default:
                return CheckoutBoardOption(k, v);
        }
    }
    export function CheckoutRotateLayerBoardOption(k: string, v: string): string
    {
        switch (k)
        {
            case "angle":
                let angle = safeEval(v);
                if (!(Math.abs(angle) <= 45))
                    return "数值必须为±45间的整数";
            case "length":
            case "frontDist":
            case "backDist":
            default:
                if (!isNum(v))
                    return "数值不能为空且必须为数字";
                return "";
        }
    }
    export function CheckBoardBatchCurtail(k: string, v: string): string
    {
        switch (k)
        {
            case "front":
            case "back":
            case "left":
            case "right":
            default:
                if (!isNum(v))
                    return "数值不能为空且必须为数字";
                return "";
        }
    }
    export function CheckLookOverBoardInfos(k: string, v: string): string
    {
        switch (k)
        {
            case EBoardKeyList.Height:
            case EBoardKeyList.Width:
            case EBoardKeyList.Thick:
            case EBoardKeyList.UpSealed:
            case EBoardKeyList.DownSealed:
            case EBoardKeyList.LeftSealed:
            case EBoardKeyList.RightSealed:
                if (!isNum(v))
                    return "数值不能为空且必须为数字";
            default:
                return "";
        }
    }
    export function CheckOutReferenceCuttingOption(k: string, v: string): string
    {
        switch (k)
        {
            case "offset":
                if (!isNum(v))
                    return "数值不能为空且必须为数字";
            default:
                return "";
        }
    }
    export function CheckoutWineRackOption(k: string, v: string): string
    {
        switch (k)
        {
            case "calcDepth":
                if (isNaN(safeEval(v, { L: 1, H: 1, W: 1 })))
                    return "表达式错误";
                return "";
            case "heightCount":
            case "widthCount":
            case "leftEdge":
            case "rightEdge":
            case "topEdge":
            case "bottomEdge":
            case "boardThick":
            case "brThick2":
            case "gripWidth":
                if (!(safeEval(v) > 0))
                    return "数值必须大于0";
            default:
                if (!isNum(v))
                {
                    return "数值不能为空且必须为数字";
                }
                return "";
        }
    }
    export function CheckoutLatticeOption(k: string, v: string): string
    {
        switch (k)
        {
            case "thickness":
            case "gripWidth":
            case "gripDepth":
                if (safeEval(v) <= 0)
                    return "数值必须大于0";
            case "arcLen":
            case "widthCount":
            case "depthCount":
            case "upSealed":
            case "downSealed":
            case "leftSealed":
            case "rightSealed":
            case "knifeRad":
            case "upCut":
            case "downCut":
                if (safeEval(v) < 0)
                    return "数值不能小于0";
            default:
                if (!(isNum(v)))
                {
                    return "数值不能为空且必须为数字";
                }
                return "";
        }
    }
}