import { _knifeType, Knife, SideModel } from "../confClass";
import { knifeData,knifeData1,knifeData2 } from "../demoKnives";
/** 刀库 管理刀具*/
export class KnifeHelper {
    knifeList: Knife[]
    constructor(_knifeList) {
        
        this.knifeList.push(knifeData);
        

        if (Array.isArray(_knifeList) && _knifeList.length >0 ) {
            this.loadKnifeList(_knifeList)
        }
    }

    loadKnifeList(_knifeList) {
        this.knifeList = _knifeList || []
    }

    /** 根据刀名称获取造型刀 */
    getModelKnifeByName(name: string): Knife | undefined {
        return this.knifeList.find(t => t.knifeName.trim() == name.trim() && t.isModelingKnife());
    }

    /** 根据半径获取造型刀 */
    getModelKnifeByRadius(radius: number, depth: number): Knife | undefined {
        return this.knifeList.find(t => t.isModelingKnife() && Math.abs(t.diameter - 2 * radius) < 0.02 && t.length >= depth - 0.01);
    }

    /** 获取合适的开料刀作为造型刀 */
    getFittedModelKnife(radius: number, depth: number): Knife | null {
        const knives = this.knifeList.filter(t => t.isModelingKnife() && t.length > depth - 0.01 && t.diameter / 2 < radius - 0.02);
        if (knives) {
            knives.sort((a, b) => b.diameter - a.diameter);     //按刀直径倒序排序
            return knives[0];
        }

        return null;
    }

    /** 根据厚度获取开料刀 */
    getKnifeByThickness(thickness: number): Knife | undefined {
        return this.knifeList.find(t => t.length >= thickness);
    }
    /** 通用 找刀具 根据查询条件 */
    getKnifeByParams(params: _knifeType) {
        let knife: Knife | null = null

        if (params) {
            let tempKnifeList: Knife[] = [...this.knifeList] // []
            let keys = Object.keys(params)
            if (keys.length > 0) {
                keys.forEach(key => {
                    if (Array.isArray(params[key]) && key == 'ability') {
                        // 进来的应该是ability  是数组  判断刀的能力
                        for (const arrItem of params[key]) {
                            let _knifeList = this.knifeList.filter(e => e.ability.includes(arrItem))
                            _knifeList.forEach(k => {
                                if (!this.KnifeIsInKnifeList(k, tempKnifeList)) {
                                    tempKnifeList.push(k)
                                }
                            })
                        }
                    } else if (['string', 'number'].includes(typeof (params[key]))) {
                        if (params && params[key] && typeof (params[key]) == 'number') {

                            if (key == 'length') {
                                tempKnifeList = tempKnifeList.filter(e => e[key] >= params[key])
                            } else {
                                tempKnifeList = tempKnifeList.filter(e => e[key] == params[key])
                            }


                        }
                    }
                });
                if (tempKnifeList.length > 0) {
                    knife = tempKnifeList[0]
                }
            } else {
                console.log('传入的查询条件 没有参数')
            }
        }
        return knife
    }

    /** 判断 刀是否在 刀列表内
     * true  存在
     * false 不存在
     */
    KnifeIsInKnifeList(_knife: Knife, _knifeList: Knife[]) {
        let k = _knifeList.find(e => _knife.axleId == e.axleId
            && _knife.diameter == e.diameter
            && _knife.knifeId == e.knifeId)

        if (k) {
            return true
        } else {
            return false
        }
    }
    getSideModelKnife(model: SideModel): Knife | undefined | null {
        if (model.knifeName && model.knifeName.trim() != '') {
            return this.getModelKnifeByName(model.knifeName.trim());
        }
        //获取刀半径(直径)和长度与造型定义的刀半径和深度一致的刀
        const knife = this.getSideModelKnifeByRadius(model.knifeRadius, model.depth, model.direction);
        if (knife) return knife;
        //获取刀半径(直径)小于造型定义的刀半径、长度不小于造型深度的刀
        return this.getFittedSideModelKnife(model.knifeRadius, model.depth, model.direction);
    }
    /** 获取合适的开料刀作为造型刀 */
    getFittedSideModelKnife(radius: number, depth: number, direction): Knife | null {
        let processFaceArr: number[] = [];
        processFaceArr.push(5)
        switch (direction) {
            case 0:
                processFaceArr.push(4)

                break;
            case 1:
                processFaceArr.push(2)

                break;
            case 2:
                processFaceArr.push(3)

                break;
            case 3:

                processFaceArr.push(1)
                break;
            case 10:


                break;
            case 11:

                break;
            case 12:

                break;
            case 13:

                break;
            default:
                break;
        }
        const knives = this.knifeList.filter(t => t.isModelingKnife() && t.length > depth - 0.01 && t.diameter / 2 < radius - 0.02 && processFaceArr.includes(t.processFace));
        if (knives) {
            knives.sort((a, b) => b.diameter - a.diameter);     //按刀直径倒序排序
            return knives[0];
        }

        return null;
    }
    /** 根据半径获取造型刀 */
    // direction 0 下 1右 2上 3左 10 左下斜  11 右下斜 12右上斜  13 左上斜
    // processFace: number // 加工面 2024 11 21 : 	正面	0 	反面	1 	左侧面	2 右侧面	3 上侧面	4 	下侧面	5 任意	6
    getSideModelKnifeByRadius(radius: number, depth: number, direction): Knife | undefined {

        let processFaceArr: number[] = [];
        processFaceArr.push(5)
        switch (direction) {
            case 0:
                processFaceArr.push(4)

                break;
            case 1:
                processFaceArr.push(2)

                break;
            case 2:
                processFaceArr.push(3)

                break;
            case 3:

                processFaceArr.push(1)
                break;
            case 10:


                break;
            case 11:

                break;
            case 12:

                break;
            case 13:

                break;
            default:
                break;
        }
        let knife = this.knifeList.find(t => t.isModelingKnife() && Math.abs(t.diameter - 2 * radius) < 0.02 && t.length >= depth - 0.01 && processFaceArr.includes(t.processFace))

        return knife;
    }

}