import {Node} from "cc";
import {RedCondEvent, RedPointCoust} from "./RedPointCoust";
import RedPointBase from "./RedPointBase";
import {RedPointSignIn} from "./RedPoint/RedPointSignIn";
import {RedPointActivity} from "./RedPoint/RedPointActivity";
import {RedPointMonopoly} from "./RedPoint/RedPointMonopoly";
import {IRedTreeCond, RedPointTree} from "./RedPointTree";

export class RedPointManager {
    private static _Inst: RedPointManager;
    public static get Inst(): RedPointManager {
        if (!RedPointManager._Inst) {
            RedPointManager._Inst = new RedPointManager();
        }
        return RedPointManager._Inst;
    }

    /**
     * 所有红点
     */
    private mRedPoint: Map<string, RedPointBase> = new Map<string, RedPointBase>();

    /**
     * 每个条件一个key 对应tree上的条件key列表
     */
    private mRedCondKeys: Map<string, Array<string>> = new Map<string, Array<string>>();

    /**
     * 页面刷新列表
     */
    private mRedUINodeMap: Map<string, Array<string>> = new Map<string, Array<string>>();

    /**
     * 增加树
     * @param key （
     * @returns
     */
    public AddRedTree(key: string) {
        let keys = key.split('_');
        let baseValue = this.mRedPoint.has(keys[0]);
        if (!baseValue) {
            switch (key) {  
                case RedPointCoust.SignIn: {
                    key = RedPointCoust.SignIn;
                    let value: RedPointSignIn = new RedPointSignIn();
                    value.initSignIn();
                    this.mRedPoint.set(key, value);
                    return value;
                }
               
                case RedPointCoust.Activity://活动红点
                {
                    key = RedPointCoust.Activity;
                    let value: RedPointActivity = new RedPointActivity();
                    this.mRedPoint.set(key, value);
                    value.initActivity();
                    return value;
                }
                case RedPointCoust.Monopoly://活动红点
                {
                    key = RedPointCoust.Monopoly;
                    let value: RedPointMonopoly = new RedPointMonopoly();
                    this.mRedPoint.set(key, value);
                    value.initMonopoly();
                    return value;
                }
                default: {
                    let value = new RedPointBase();
                    value.init(keys[0])
                    this.mRedPoint.set(key, value);
                    return value;
                }
            }
        }
    }

    /**
     * 更新树节点所有红点
     * @param key 唯一Id
     */
    updateAllRedPoint(key: string) {
        let keys: Array<string> = key.split('_');
        let value = this.mRedPoint.get(keys[0]);
        if (value == null) {
            // value = this.AddRedPoint(keys[0]);
        }
        switch (keys[0]) {
            case RedPointCoust.SignIn:
                // {
                //     let val = value as RedPointSignIn;
                //     val.updateSignInPoint();

                // }
                return;
            case RedPointCoust.Guild:
                // {
                //     let val = value as RedPointGuild;
                //     val.updateGuildRedPoint();
                // }
                return;
            case RedPointCoust.Recruit: {
                // let val = value as RedPointRecruit;
                // val.updateRecruitPoint();
            }
                return;
            case RedPointCoust.Task: {
                // let val = value as RedPointTask;
                // val.updateTaskPoint();
            }
                return;
            case RedPointCoust.Activity: {
                // let val = value as RedPointActivity;
                // val.updateActivityPoint();
            }
                return;
            case RedPointCoust.Monopoly: {
                // let val = value as RedPointMonopoly;
                // val.updateMonopolyPoint();
            }
                return;
            case RedPointCoust.Hero://英雄红点
            {
                // let val = value as RedPointHero;
                // val.updateAllHeroRedPoint();
            }
                return;
            case RedPointCoust.FirstPass: {
                // let val = value as RedPointFirstPass;
                // val.updateFirstPassRedPoint();
            }
                return;

            case RedPointCoust.FirstRecharge: {
                // let val = value as RedPointFirstRecharge;
                // val.updateFirstRechargeRedPoint();
            }
                return;
            case RedPointCoust.ActivityFightRank: {
                // let val = value as RedPointActivityFightRank;
                // val.updateActivityFightRankRedPoint();
            }
                return;
            case RedPointCoust.ActivityScoreRank: {
                // let val = value as RedPointActivityScoreRank;
                // val.updateActivityScoreRankRedPoint();
            }
                return;
        }
    }

    /**
     * 插入key
     * @param key
     * @param showType
     * @returns
     */
    public insertRedPoint(key: string, parentTree: RedPointTree, callBack: Function): RedPointTree {
        let keys = key.split('_');
        let base = this.mRedPoint.get(keys[0]);
        if (base == null) {
            base = this.AddRedTree(keys[0]);
        }
        if (base != null) {
            let redTree: RedPointTree = base.redTree.findChild(key);
            if (redTree != null) {
                return redTree;
            }
            if (keys.length > 1) {
                let childTree = parentTree.getOrAddChild(key, callBack);
                childTree.data.mParent = parentTree;
                return childTree;

            } else {
                return base.redTree;
            }
        }

    }

    /**
     *
     * @param key 唯一值
     * @param isShow false 不显示，true 显示
     * @param showCount  数字展示时显示的数字
     */
    public updateRedPoint(key: string, isShow: boolean = false, showCount: number = 0) {
        let keys = key.split('_');
        let value: RedPointBase = this.mRedPoint.get(keys[0]);
        if (value) {
            value.updateRedPoint(key, isShow, showCount);
        }
    }

    /**
     * @param key 绑定节点
     * @param node
     * @param showType 展示类型
     * @param isSelfControl
     */
    public bind(key: string, node: Node, showType: number = 0, isSelfControl: boolean = false) {
        let keys = key.split("_");
        let id = keys[0];
        if (!this.mRedPoint.has(id)) {
            console.warn('节点树未初始化' + id);
            let redPoint = this.AddRedTree(id);
            redPoint.bindRedPoint(key, node, showType, isSelfControl);
            this.mRedPoint.set(id, redPoint);
        } else {
            let parent = this.mRedPoint.get(id);
            parent.bindRedPoint(key, node, showType, isSelfControl);
        }
    }

    /**
     * 增加判断条件
     * @param key
     * @param redCondition
     */
    public AddRedCondition(key: string, redCondition: IRedTreeCond) {
        let keys = key.split("_");
        let id = keys[0];
        let treeNode = this.mRedPoint.get(id);
        if (treeNode) {
            let item = treeNode.getRedPointTree(key);
            if (item) {
                item.addCond(redCondition);
            }
        }
        this.AddRedCondKeys(redCondition.condEvent, key)
    }

    /**
     *
     * @param UIId 页面Id（用来查找在什么树节点上的UI）
     * @param key 要刷新节点绑定节点的key值
     * @param isClean 是否清理
     */
    public addRefresh(UIId: string, key: string, isClean: boolean = false) {
        if (isClean) {
            this.mRedUINodeMap.set(UIId, []);

        }
        let data = this.mRedUINodeMap.get(UIId);
        if (data == null) {
            data = new Array<string>();
        }
        data.push(key);
        this.mRedUINodeMap.set(UIId, data);
    }

    /**
     * 刷新页面红点
     * @param uikey 页面Id（用来查找在什么树节点上的UI）
     */
    public refrashLayer(uikey: string) {
        let treeNode = this.getRedTreeClassByKey(uikey);
        let data = this.mRedUINodeMap.get(uikey)
        for (let index = 0; index < data.length; index++) {
            const value = data[index];
            let redPoint = treeNode.redTree.findChild(value);
            if (redPoint) {
                redPoint.refresh();
            }
        }
    }

    /**
     * 添加key到条件树
     * @param event  条件类型
     * @param key 节点树key值
     */
    private AddRedCondKeys(event: RedCondEvent, key: string) {
        let keysData = this.mRedCondKeys.get(event);
        if (keysData == null) {
            keysData = new Array<string>();

        }
        keysData.push(key)
        this.mRedCondKeys.set(event, keysData);

    }

    /**
     * 更新条件
     * @param event 条件
     * @param currValue 更新当前值
     */
    public updateCondition(event: IRedTreeCond) {
        let keysData = this.mRedCondKeys.get(event.condEvent);
        if (keysData) {
            for (const key in keysData) {
                if (Object.prototype.hasOwnProperty.call(keysData, key)) {
                    const element = keysData[key];
                    let redTree = this.getRedTreeClassByKey(element).getRedPointTree(element);
                    if (redTree) {
                        redTree.updateCondCount(event);
                    }
                }
            }
        } else {
            console.warn("没有条件", event);
        }
    }

    /**
     * 删除判断条件
     * @param key  删除判断条件的节点树key
     * @param redEvent 条件类型
     */
    public removeRedCondition(key: string, redEvent: string) {
        let keys = key.split("_");
        let id = keys[0];
        let treeNode = this.mRedPoint.get(id);
        if (treeNode) {
            let item = treeNode.getRedPointTree(key);
            if (item) {
                item.removeCond(redEvent);
            }
        }
    }

    /**
     * 获取节点树类型
     * @param key 节点树根节点
     * @returns
     */
    public getRedTreeClassByKey(key: string) {
        let keys = key.split('_');
        let value = this.mRedPoint.get(keys[0]);
        if (value) {
            return value;
        } else {
            console.log("error:not find")
            return this.AddRedTree(keys[0]);
        }
    }

    /**
     * 获取父节点key值
     * @param key key
     *
     * @returns
     */
    public getParentKey(key: string): string {
        let keys = key.split('_');
        let _key: string = keys[0];
        if (keys.length > 1) {
            for (let id = 1; id < keys.length - 1; id++) {
                const element = keys[id];
                _key += '_' + element;
            }
        }
        return _key;
    }

}

let RedMgrInst: RedPointManager = RedPointManager.Inst;
export default RedMgrInst;