import { gameData } from './data';
import { DicTask } from './dictionary/DicTask';
import { TASK_TYPE, ABI_STAGE, WAR_TYPE, GUILD_JOB, TASK_FUN_TYPE, FUNCS_ID } from '../consts';
import { UserTaskRecModel, UserTaskRecType } from '../db/UserTaskRec'
import { RoleType, RoleModel } from '../db/Role';
import { TaskParam, TaskListReturn } from '../domain/roleField/task';
import { getZeroPoint } from './timeUtil';
import { HeroType } from '../db/Hero';
import { EquipType, EquipModel } from '../db/Equip';
import { ItemInter } from './interface';
import { GrowthData } from '../domain/activityField/growthField';
import { DailyChallengesData } from '../domain/activityField/dailyChallengesField';
import { splitString } from './util';
import { ActivityModel, ActivityModelType } from '../db/Activity';
import { ACTIVITY_TYPE } from '../consts/constModules/activityConst';
import { ActivityGrowthModel } from '../db/ActivityGrowth';
import { ActivityDailyChallengesModel } from '../db/ActivityDailyChallenges';
import { ThirtyDaysData } from '../domain/activityField/thirtyDaysField';
import { ActivityThirtyDaysModel, ActivityThirtyDaysModelType } from '../db/ActivityThirtyDays';



export async function checkTaskWithRoles(taskType: number, roles: RoleType[], funcs?: number[]) {
    let pushMessage = new Array<TaskListReturn>();
    for (let role of roles) {
        if (role) {
            let singlePush = await checkTaskWithRole(role.roleId, taskType, role, funcs);
            pushMessage.concat(singlePush);
        }
    }
    return pushMessage
}

export async function checkTaskWithRole(roleId: string, taskType: number, role: RoleType, funcs?: number[]) {
    let pushMessage = new Array<TaskListReturn>();

    if (taskType == TASK_TYPE.LOGIN_SUM) {
        let today = getZeroPoint();
        if (today > role.loginTime) {
            pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
            //成长任务-累计登录游戏天数
            await accomplishTask(roleId, taskType, 1)
        }
    }
    else if (taskType == TASK_TYPE.LOGIN_SERIES) {
        let today = getZeroPoint();
        if (today > role.loginTime) {
            if (today - role.loginTime > 24 * 60 * 60) {
                pushMessage = await checkTask(roleId, taskType, 1, false, {}, funcs);
            } else {
                pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
            }
        }
    }
    else if (taskType == TASK_TYPE.FRIEND_NUM) {
        let { friendCnt } = role;
        pushMessage = await checkTask(roleId, taskType, friendCnt, false, {}, funcs);
    }

    return pushMessage
}


export async function checkTaskWithHeroes(roleId: string, taskType: number, heroes: HeroType[], funcs?: number[]) {
    let pushMessage = new Array<TaskListReturn>();
    for (let hero of heroes) {
        let singlePush = await checkTaskWithHero(roleId, taskType, hero, [], funcs);
        pushMessage.concat(singlePush);
    }
    return pushMessage
}

export async function checkTaskWithHero(roleId: string, taskType: number, hero: HeroType, args: number[] = [], funcs?: number[]) {
    let pushMessage = new Array<TaskListReturn>();
    if (taskType == TASK_TYPE.HERO_STAR_UP) {
        let dicHero = gameData.hero.get(hero.hid);
        let starUp = hero.star - dicHero.initialStars;
        if (hero.colorStar > 1) starUp += hero.colorStar - 1;
        pushMessage = await checkTask(roleId, taskType, 1, true, { star: starUp }, funcs)
    }
    else if (taskType == TASK_TYPE.HERO_QUALITY) {
        let dicHero = gameData.hero.get(hero.hid);
        pushMessage = await checkTask(roleId, taskType, 1, true, { quality: dicHero.quality }, funcs);
    }
    else if (taskType == TASK_TYPE.HERO_QUALITY_STAR_UP) {
        let dicHero = gameData.hero.get(hero.hid);
        pushMessage = await checkTask(roleId, taskType, 1, true, { quality: dicHero.quality, star: hero.star }, funcs);
    }
    else if (taskType == TASK_TYPE.HERO_LV) {
        pushMessage = await checkTask(roleId, taskType, 1, true, { lv: hero.lv, oldLv: args[0] }, funcs);
    }
    else if (taskType == TASK_TYPE.HERO_TRAIN) {
        let dicHero = gameData.hero.get(hero.hid);
        let initGrage = gameData.job.get(dicHero.jobid).grade;
        let curGrade = gameData.job.get(hero.job).grade;
        let count = (curGrade - initGrage) * (ABI_STAGE.END - ABI_STAGE.START) + (hero.jobStage - ABI_STAGE.START); // 训练次数
        pushMessage = await checkTask(roleId, taskType, 1, true, { count }, funcs);
    }
    else if (taskType == TASK_TYPE.HERO_QUALITY_UP) {
        let dicHero = gameData.hero.get(hero.hid);
        if (hero.quality - dicHero.quality == 1) { // 每个武将升品算一次
            pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.HERO_STAGE_UP) {
        let dicHero = gameData.hero.get(hero.hid);
        let initGrage = gameData.job.get(dicHero.jobid).grade;
        let curGrade = gameData.job.get(hero.job).grade;
        let count = curGrade - initGrage; // 进阶次数
        pushMessage = await checkTask(roleId, taskType, 1, true, { count }, funcs);
    }
    else if (taskType == TASK_TYPE.HERO_FAVOUR_LV) {
        pushMessage = await checkTask(roleId, taskType, 1, true, { favourLv: hero.favourLv }, funcs)
    }
    else if (taskType == TASK_TYPE.EQUIP_BY_HERO) {
        // arg[0] 1：穿上 -1：脱下
        let { ePlace } = hero;
        let count = ePlace.filter(cur => cur.equip).length;
        pushMessage = await checkTask(roleId, taskType, args[0], true, { count, isPutOn: args[0] }, funcs);
    }
    else if (taskType == TASK_TYPE.EQUIP_STRENGTHEN) {
        // args: 依次为原先的装备的强化等级
        let { ePlace } = hero;
        let index = 0;
        for (let { lv } of ePlace) {
            let p = await checkTask(roleId, taskType, 1, true, { oldLv: args[index++], lv }, funcs);
            pushMessage = pushMessage.concat(p);
        }
    }

    return pushMessage
}


export async function checkTaskWithEquip(roleId: string, taskType: number, equip: EquipType, args: number[] = [], funcs?: number[]) {
    let pushMessage = new Array<TaskListReturn>();
    if (taskType == TASK_TYPE.EQUIP_QUALITY) {
        // args[0] 1：装上 -1：脱下
        let dicGood = gameData.goods.get(equip.id);
        pushMessage = await checkTask(roleId, taskType, args[0], true, { quality: dicGood.quality }, funcs)
    }
    else if (taskType == TASK_TYPE.EQUIP_JEWEL) {
        // args[0] 原来镶嵌了多少宝石
        let { holes } = equip;
        let jewelCount = holes.filter(cur => cur.jewel > 0).length;
        if (jewelCount > 0 && args[0] <= 0) { // 原来没有，镶嵌上了
            pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
        } else if (jewelCount <= 0 && args[0] > 0) { // 原来镶嵌着，现在没了
            pushMessage = await checkTask(roleId, taskType, -1, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.EQUIP_COMPOSE_SUIT) {
        let dicGood = gameData.goods.get(equip.id);
        if (dicGood.suitId) {
            pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.EQUIP_SUIT) {
        let dicGood = gameData.goods.get(equip.id);
        if (dicGood.suitId) {
            let suit = gameData.suit.get(dicGood.suitId);
            let equips = await EquipModel.getEquipsByIds(roleId, suit.tireInfo);
            let everyEquip = new Map<number, number>();
            for (let equip of equips) {
                if (everyEquip.has(equip.id)) {
                    everyEquip.set(equip.id, everyEquip.get(equip.id) + 1);
                } else {
                    everyEquip.set(equip.id, 1);
                }
            }
            let minCount = 0, curCount = 0;
            for (let id of suit.tireInfo) {
                let count = everyEquip.get(id) || 0;
                if (minCount > count) minCount = count;
                if (id == equip.id) curCount = count;
            }
            if (curCount == minCount) {
                pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
            }
        }
    }
    else if (taskType == TASK_TYPE.EQUIP_JEWEL_SUM) {
        // args[0] 原来镶嵌了多少宝石
        let { holes } = equip;
        let jewelCount = holes.filter(cur => cur.jewel > 0).length;
        pushMessage = await checkTask(roleId, taskType, jewelCount - args[0], true, {}, funcs);
    }
    return pushMessage
}

export async function checkTaskWithArgs(roleId: string, taskType: number, args: number[], funcs?: number[]) {
    let pushMessage = new Array<TaskListReturn>();

    if (taskType == TASK_TYPE.ROLE_SCHOOL_PUT_HERO) {
        let [hid, preHid] = args;
        if (hid > 0 && preHid <= 0) { // 放置
            pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
        } else if (hid <= 0 && preHid > 0) { // 卸下
            pushMessage = await checkTask(roleId, taskType, -1, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.EQUIP_JEWEL_STAGE) {
        // args 装上的， 卸下的
        let [putOnJewel, putOffJewel] = args;
        if (putOnJewel > 0) {
            let dicGood = gameData.goods.get(putOnJewel);
            let push = await checkTask(roleId, taskType, 1, true, { stage: dicGood.lvLimited }, funcs);
            pushMessage.concat(push);
        }
        if (putOffJewel > 0) {
            let dicGood = gameData.goods.get(putOffJewel);
            let push = await checkTask(roleId, taskType, -1, true, { stage: dicGood.lvLimited }, funcs);
            pushMessage.concat(push);
        }
    }
    else if (taskType == TASK_TYPE.CHAT) {
        // args[0] 聊天type 1-系统 2-世界 3-军团 4-组队 5-私聊
        pushMessage = await checkTask(roleId, taskType, 1, true, { chatType: args[0] }, funcs)
    }

    return pushMessage
}

export async function checkTaskWithWar(roleId: string, taskType: number, warId: number, heroes: number[], count: number, star: number, funcs?: number[]) {
    let dicWar = gameData.war.get(warId);
    let pushMessage = new Array<TaskListReturn>();
    if (taskType == TASK_TYPE.BATTLE_WITH_HERO) {
        pushMessage = await checkTask(roleId, taskType, count, true, { warId, heroes }, funcs);
    }
    else if (taskType == TASK_TYPE.BATTLE_MAIN) {
        if (dicWar.warType == WAR_TYPE.NORMAL) {
            pushMessage = await checkTask(roleId, taskType, count, true, { warId }, funcs);
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_MAIN_SWEEP) {
        if (dicWar.warType == WAR_TYPE.NORMAL) {
            pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_DAILY_STAR) {
        if (dicWar.warType == WAR_TYPE.DAILY) {
            pushMessage = await checkTask(roleId, taskType, count, true, { warId, star }, funcs);
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_DAILY) {
        if (dicWar.warType == WAR_TYPE.DAILY) {
            pushMessage = await checkTask(roleId, taskType, count, true, { dailyType: dicWar.dailyType }, funcs)
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_DUNGEON) {
        if (dicWar.warType == WAR_TYPE.MYSTERY || dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
            pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_DUNGEON_WAR) {
        if (dicWar.warType == WAR_TYPE.MYSTERY || dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
            pushMessage = await checkTask(roleId, taskType, count, true, { warId }, funcs);
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_TOWER) {
        if (dicWar.warType == WAR_TYPE.TOWER) {
            pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_VESTIGE) {
        if (dicWar.warType == WAR_TYPE.VESTIGE) {
            pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
        }
    }
    else if (taskType == TASK_TYPE.BATTLE_EXPEDITION) {
        if (dicWar.warType == WAR_TYPE.EXPEDITION) {
            pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
        }
    }
    return pushMessage
}


export async function checkTaskWithGoods(roleId: string, taskType: number, goods: ItemInter[], funcs?: number[]) {
    let pushMessage = new Array<TaskListReturn>();
    if (taskType == TASK_TYPE.COM_BATTLE_DROP) {
        for (let { id, count } of goods) {
            let push = await checkTask(roleId, taskType, count, true, { gid: id }, funcs);
            pushMessage.concat(push);
        }
    }
    return pushMessage
}

// 根据taskType判断有哪些任务需要check的
export async function checkTask(roleId: string, taskType: number, count: number, isInc: boolean, param: TaskParam, funcs?: number[]) {
    console.log('******checkTask', roleId, taskType, count, isInc, param, funcs)
    let tasks = gameData.taskType.get(taskType) || [];
    let pushMessage = new Array<TaskListReturn>();
    let groups = new Map<string, { task0: DicTask, tasks: DicTask[] }>();
    for (let dicTask of tasks) {
        if (!groups.has(`${dicTask.type}_${dicTask.group}`)) {
            groups.set(`${dicTask.type}_${dicTask.group}`, { task0: dicTask, tasks: new Array<DicTask>() });
        }
        groups.get(`${dicTask.type}_${dicTask.group}`).tasks.push(dicTask);
    }
    if (!funcs) {
        let role = await RoleModel.findByRoleId(roleId, 'funcs');
        funcs = role.funcs || [];
    }

    for (let [typeAndGroup, { task0, tasks }] of groups) {
        let arr = typeAndGroup.split('_');
        let type = parseInt(arr[0]);
        let group = parseInt(arr[1]);

        let rec = await checkTaskRec(roleId, type, group, task0, count, isInc, param, funcs);
        if (rec) {
            for (let dicTask of tasks) {
                if (checkRecResult(rec, dicTask.id)) {
                    let received = rec.received || [];
                    pushMessage.push({ type: dicTask.type, id: dicTask.id, count: rec.count, received: received.includes(dicTask.id) });
                }
            }
        }
    }
    return pushMessage;
}

// 检查各项任务是否达成，达成了就保存到数据库
export async function checkTaskRec(roleId: string, type: number, group: number, dicTask: DicTask, count: number, isInc: boolean, param: TaskParam, funcs: number[]) {
    let { taskParam, taskType } = dicTask;

    let sp = [TASK_TYPE.LOGIN_SUM, TASK_TYPE.LOGIN_SERIES];
    if (type == TASK_FUN_TYPE.DAILY && funcs.indexOf(FUNCS_ID.DAILY_TASK) == -1 && sp.indexOf(taskType) == -1) { // 功能未开启
        return false;
    }


    let isMatch = true; // 条件是否满足
    let checkHistory = false; // 是否检查历史
    switch (taskType) {
        case TASK_TYPE.ROLE_TITLE:
            isMatch = taskParam[0] == param.title;
            checkHistory = true;
            break;
        case TASK_TYPE.HERO_STAR_UP:
            isMatch = taskParam[1] == param.star;
            break;
        case TASK_TYPE.HERO_QUALITY:
        case TASK_TYPE.EQUIP_QUALITY:
            isMatch = taskParam[1] == param.quality;
            break;
        case TASK_TYPE.HERO_QUALITY_STAR_UP:
            isMatch = taskParam[1] == param.quality && taskParam[2] == param.star;
            break;
        case TASK_TYPE.HERO_LV:
            isMatch = param.lv >= taskParam[1] && param.oldLv < taskParam[1];
            break;
        case TASK_TYPE.HERO_TRAIN:
            isMatch = taskParam[1] == param.count;
            break;
        case TASK_TYPE.HERO_FAVOUR_LV:
            isMatch = taskParam[1] == param.favourLv;
            break;
        case TASK_TYPE.HERO_CONNECT:
            isMatch = taskParam[1] == param.connectLv;
            break;
        case TASK_TYPE.EQUIP_BY_HERO:
            isMatch = false;
            if (param.isPutOn && param.count == taskParam[1]) { // 装上之后达到 +1
                isMatch = true;
            } else if (!param.isPutOn && param.count < taskParam[1]) { // 脱下后不能达到 -1
                isMatch = true;
            }
            break;
        case TASK_TYPE.EQUIP_STRENGTHEN:
            isMatch = param.oldLv < taskParam[1] && param.lv >= taskParam[1];
            break;
        case TASK_TYPE.EQUIP_JEWEL_STAGE:
            isMatch = param.stage == taskParam[1];
            break;
        case TASK_TYPE.CHAT:
            isMatch = taskParam[0] == 0 || param.chatType == taskParam[0];
            break;
        case TASK_TYPE.BATTLE_WITH_HERO:
            isMatch = checkIdList(taskParam, 2, param.warId) && checkHero(taskParam, 0, param.heroes);
            break;
        case TASK_TYPE.BATTLE_MAIN:
        case TASK_TYPE.BATTLE_DUNGEON_WAR:
            isMatch = checkIdList(taskParam, 0, param.warId);
            break;
        case TASK_TYPE.BATTLE_EVENT:
            isMatch = taskParam[0] == 0 || param.eventType == taskParam[0];
            break;
        case TASK_TYPE.BATTLE_DAILY_STAR:
            isMatch = (taskParam[0] == 0 || param.star == taskParam[0]) && checkIdList(taskParam, 2, param.warId);
            break;
        case TASK_TYPE.BATTLE_DAILY:
            isMatch = taskParam[0] == 0 || param.dailyType == taskParam[0];
            break;
        case TASK_TYPE.BATTLE_EXPEDITION_BOX:
            isMatch = taskParam[1] == 0 || param.point == taskParam[1];
            break;
        case TASK_TYPE.COM_BATTLE_BLUEPRT:
        case TASK_TYPE.COM_BATTLE_QUALITY:
            isMatch = taskParam[0] == 0 || param.quality == taskParam[0];
            break;
        case TASK_TYPE.COM_BATTLE_DROP:
            isMatch = checkIdList(taskParam, 1, param.gid);
            break;
        case TASK_TYPE.PVP_HERO_SCORE:
            for (let { score } of param.heroScores) {
                if (score >= taskParam[0]) {
                    count++;
                }
            }
            if (count <= 0) isMatch = false;
            break;
        case TASK_TYPE.PVP_RANK:
            isMatch = taskParam[0] <= param.rankLv;
            checkHistory = true;
            break;
        case TASK_TYPE.GUILD_JOB:
            isMatch = taskParam[0] <= param.job && param.job != GUILD_JOB.DAJIANGJUN;
            checkHistory = true;
            break;
        case TASK_TYPE.GUILD_REFINE:
            isMatch = taskParam[0] == 0 || param.quality == taskParam[0];
            break;
    }
    console.log('****isMatch', isMatch, checkHistory, type, taskType, group, count)
    if (param.isDebug) {
        isMatch = true;
    }

    if (isMatch) {
        if (isInc) {
            let rec = await UserTaskRecModel.incTaskRec(roleId, type, taskType, group, count);
            return rec;
        } else {
            if (checkHistory) {
                let rec = await UserTaskRecModel.checkHistoryAndSetTaskRec(roleId, type, taskType, group, count);
                return rec;
            } else {
                let rec = await UserTaskRecModel.setTaskRec(roleId, type, taskType, group, count);
                return rec;
            }
        }
    }
}

/**
 * 检查id是否在某列表中
 * @param taskParam 条件number[] 填法 如： count&id&... 有多少id就count填几
 * @param index count在第几位，0开始
 * @param id 关卡id
 */
function checkIdList(taskParam: number[], index: number, id: number) {
    let count = taskParam[index];
    if (!count) return false;
    let idList = taskParam.slice(index + 1, index + 1 + count);
    return idList.indexOf(id) != -1;
}

function checkHero(taskParam: number[], index: number, heroes: number[]) {
    let hid = taskParam[index];
    return heroes.indexOf(hid) != -1;
}

function checkRecResult(rec: UserTaskRecType, id: number) {
    if (!rec) return false;
    if (rec.received && rec.received.includes(id)) return false; // 已领取，不再推送

    return rec
}


/**
   * 任务统计
   *
   * @param {number} serverId 区Id
   * @param {string} roleId 角色Id
   * @param {number} taskType 任务类型
   * @param {number} count 任务数据
   * @param {number} parma 参数
   *
   */
export async function accomplishTask(roleId: string, taskType: TASK_TYPE, count: number, parma?: any) {
    //成长活动统计
    let allActivity: ActivityModelType[] = await ActivityModel.findOpenActivityByType(ACTIVITY_TYPE.TASK_GROWTH, new Date());
    for (let activity of allActivity) {
        let growthActivity = new GrowthData(activity);
        let taskArray = growthActivity.findTaskByType(taskType);
        for (let task of taskArray) {
            let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
            if (addCount) {
                if (taskType == TASK_TYPE.ROLE_LV || taskType == TASK_TYPE.ROLE_TITLE) {
                    await ActivityGrowthModel.setTaskCount(growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
                } else {
                    await ActivityGrowthModel.addTaskCount(growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
                }
            }
        }
    }

    //今日挑战统计
    allActivity = await ActivityModel.findOpenActivityByType(ACTIVITY_TYPE.TASK_DAILY_CHALLENGES, new Date());
    for (let activity of allActivity) {
        let growthActivity = new DailyChallengesData(activity);
        let taskArray = growthActivity.findTaskByType(taskType, growthActivity.today());
        for (let task of taskArray) {
            let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
            if (addCount) {
                if (taskType == TASK_TYPE.ROLE_LV || taskType == TASK_TYPE.ROLE_TITLE) {
                    await ActivityDailyChallengesModel.setTaskCount(growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
                } else {
                    await ActivityDailyChallengesModel.addTaskCount(growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
                }
            }
        }
    }

    //30天任务统计
    if (taskType === TASK_TYPE.HERO_QUALITY_STAR_UP ||
        taskType === TASK_TYPE.HERO_QUALITY_TO_QUALITY_COUNT ||
        taskType === TASK_TYPE.HERO_WAKE_UP_COUNT ||
        taskType === TASK_TYPE.HERO_WAKE_UP_STAR_UP_COUNT ||

        taskType === TASK_TYPE.EQUIP_STRENGTHEN ||
        taskType === TASK_TYPE.EQUIP_REFINE_LV ||
        taskType === TASK_TYPE.HERO_STAGE_UP ||
        taskType === TASK_TYPE.EQUIP_JEWEL_SUM ||
        taskType === TASK_TYPE.EQUIP_JEWEL_STAGE ||
        taskType === TASK_TYPE.EQUIP_SUIT_JEWEL_STAGE ||
        taskType === TASK_TYPE.EQUIP_QUALITY

    ) {
        allActivity = await ActivityModel.findOpenActivityByType(ACTIVITY_TYPE.THIRTY_DAYS, new Date());
        for (let activity of allActivity) {
            let thirtyDaysActivity = new ThirtyDaysData(activity);
            let playerRecords: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.findData(activity.acvitityId, roleId);
            thirtyDaysActivity.setPlayerRecords(playerRecords);
            let taskArray = thirtyDaysActivity.findUncompleteTaskByType(taskType);
            for (let task of taskArray) {
                let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
                if (addCount) {
                    await ActivityThirtyDaysModel.addTaskCount(thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.taskType, addCount);
                }
            }
        }
    }


}

/**
   * 达成任务标准
   *
   * @param {string} roleId 角色Id
   * @param {number} taskType 任务类型
   * @param {number} taskParam 任务条件数据
   * @param {number} count 数据
   * @param {number} parma 参数
   *
   */

export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: string, count: number, paramObj?: any): number {
    console.log('达成任务标准', roleId, taskType, taskParam, count, paramObj)
    let param = splitString(taskParam, '&');
    let addCount: number = 0; // 条件是否满足
    switch (taskType) {
        case TASK_TYPE.ROLE_LV://重置数据
            addCount = param[0] <= count ? count : 0;
            break;
        case TASK_TYPE.GUILD_JOIN:
            addCount = count;
            break;
        case TASK_TYPE.LOGIN_SUM:
            addCount = count;
            break;
        case TASK_TYPE.HERO_NUM:
            addCount = count;
            break;

        case TASK_TYPE.HERO_QUALITY_STAR_UP://herocount&quality&star&
            addCount = (param[1] == paramObj.quality) && (param[2] == paramObj.star) ? count : 0;
            break;
        case TASK_TYPE.HERO_QUALITY_TO_QUALITY_COUNT://herocount&quality&star& {oldQuality, quality: hero.quality}
            addCount = (param[1] == paramObj.oldQuality) && (param[2] == paramObj.quality) ? count : 0;
            break;
        case TASK_TYPE.HERO_WAKE_UP_COUNT://herocount&quality
            addCount = (param[1] == paramObj.quality) ? count : 0;
            break;
        case TASK_TYPE.HERO_WAKE_UP_STAR_UP_COUNT://herocount&star& 
            addCount = (param[1] == paramObj.star) ? count : 0;
            break;
        case TASK_TYPE.HERO_STAGE_UP://herocount&star& 
            addCount = (param[1] == paramObj.job) ? count : 0;
            break;
        case TASK_TYPE.EQUIP_JEWEL_STAGE://count&stage& 
            addCount = (param[1] == paramObj.stage) ? count : 0;
            break;
        case TASK_TYPE.EQUIP_SUIT_JEWEL_STAGE://count&stage& 
            addCount = (param[1] == paramObj.stage) ? count : 0;
            break;
        case TASK_TYPE.EQUIP_QUALITY:
            addCount = param[1] == paramObj.quality ? count : 0;
            break;

        case TASK_TYPE.ROLE_TITLE://重置数据
            addCount = param[0] <= count ? count : 0;
            break;
        case TASK_TYPE.GASHA:
            addCount = count;
            break;
        case TASK_TYPE.EQUIP_STRENGTHEN:
            for (let obj of paramObj) {
                // obj.hid;//英雄di
                // obj.oldLv;//栏位升级前等级
                // obj.lv;//栏位升级后等级
                // obj.id;//栏位id
                if (param[1] > obj.oldLv && param[1] <= obj.lv) {
                    addCount++;
                }
            }
            break;
        case TASK_TYPE.EQUIP_REFINE_LV:
            addCount = (param[1] == paramObj.lv) ? count : 0;
            break;

        case TASK_TYPE.BATTLE_MAIN:
            addCount = param[0] == paramObj.warId ? 1 : 0;
            break;
        case TASK_TYPE.EQUIP_JEWEL_SUM:
            addCount = count;
            break;
        case TASK_TYPE.GUILD_TRAIN:
            addCount = count;
            break;
        case TASK_TYPE.ROLE_SCHOOL_PUT_HERO:
            addCount = count;
            break;
        case TASK_TYPE.GUILD_ACTIVITY:
            addCount = count;
            break;
        default:
            addCount = 0;
            break;

    }
    return addCount;
}

/**
 * 创建账号时临时获得可开启功能，主要用于check 主公升级任务
 * 该函数不会存储funcs，如pvp开启会在entryHandler里面再查一次funcs，那时候正式开启
 * @param dataFuncs 
 * @param lv 
 */
export async function getCreateUserFuncs(dataFuncs: number[], lv: number) {
    let addFuncs: number[] = [];
    for (let [id, dicFunSwitch] of gameData.funcsSwitch) {
        if (dataFuncs.includes(id)) continue; // 已开启过了

        if (dicFunSwitch && lv >= dicFunSwitch.param) {
            addFuncs.push(id);
        }
    }
    return addFuncs;
}