import { pinus } from "pinus";
import { ACTIVITY_TYPE, STATUS, TASK_SUM_TYPE, TASK_TYPE } from "../../consts";
import { ActivityBuyRecordsModel } from "../../db/ActivityBuyRecords";
import { ActivityDailyChallengesModel } from "../../db/ActivityDailyChallenges";
import { ActivityGrowthModel } from "../../db/ActivityGrowth";
import { ActivityGrowthFundModel } from "../../db/ActivityGrowthFund";
import { ActivityRefreshTaskModel } from "../../db/ActivityRefreshTask";
import { ActivityThirtyDaysModel } from "../../db/ActivityThirtyDays";
import { ActivityTreasureHuntTaskModel } from "../../db/ActivityTreasureHuntTask";
import { RoleType } from "../../db/Role";
import { ServerTempModel, ServerTempModelType } from "../../db/ServerTemp";
import { UserTaskRecModel } from "../../db/UserTaskRec";
import { GrowthFundData } from "../../domain/activityField/growthFundField";
import { RefreshTaskData } from "../../domain/activityField/refreshTaskField";
import { SevenDaysData } from "../../domain/activityField/sevenDaysField";
import { ThirtyDaysData } from "../../domain/activityField/thirtyDaysField";
import { TreasureHuntData } from "../../domain/activityField/treasureHuntField";
import { TaskListReturn, UpdateTaskParam } from "../../domain/roleField/task";
import { gameData } from "../../pubUtils/data";
import { getZeroPoint } from "../../pubUtils/timeUtil";
import { resResult } from "../../pubUtils/util";
import { getActivities, getActivitiesByType, getActivityByServerId } from "../activity/activityService";
import { getRoleOnlineInfo } from "../redisService";

/**
 * @class CheckTask
 * @classdesc 检查某个玩家任务的达成情况
 */
export class CheckTask {
    serverId: number;       // 区id
    roleId: string;         // 玩家id
    taskType: TASK_TYPE;    // 任务type
    roleCreateTime: number; // 玩家的创建时间
    serverCreateTime: number; // 服务器的创建时间

    param: TaskParam;           // 检查任务时传入的参数

    treasureHuntTemp: ServerTempModelType;

    constructor(serverId: number, roleId: string, taskType: TASK_TYPE, roleCreateTime: number, serverCreateTime: number) {
        this.serverId = serverId;
        this.roleId = roleId;
        this.taskType = taskType;
        this.roleCreateTime = roleCreateTime;
        this.serverCreateTime = serverCreateTime;
        this.param = new TaskParam();
    }

    /**
     * @description 检查任务的主程序
     */
    public async check(count: number, sid: string) {
        let { taskType, roleId, serverId, roleCreateTime, serverCreateTime } = this;
        let dicTaskTypeDesc = gameData.taskDescByType.get(taskType);
        let taskPushMessages: TaskListReturn[] = [];
        let activityTaskPushMessages = [];
        
        // 检查一般任务
        let dicTasks = gameData.taskType.get(taskType);
        for (let dicTask of dicTasks) {
    
            let taskUpdateParam = this.checkIsMatch(dicTask.taskParam, count);
            if (taskUpdateParam) {
                let rec = await UserTaskRecModel.checkAndUpdateTask(roleId, dicTask.type, taskType, dicTask.group, taskUpdateParam);
                if (!rec) continue;
                if (rec.received && rec.received.includes(dicTask.id)) continue; // 已领取，不再推送
                let received = rec.received || [];
                taskPushMessages.push({ type: dicTask.type, id: dicTask.id, count: rec.count, received: received.includes(dicTask.id) });

            }
        }

        // 检查活动任务
        let activities = await getActivityByServerId(serverId);
        for(let activity of activities) {
            let { activityId, type: activityType } = activity;
            switch(activityType) {
                case ACTIVITY_TYPE.SEVEN_DAY:
                case ACTIVITY_TYPE.FOURTEEN_DAY://十四天乐活动 28
                case ACTIVITY_TYPE.COMMON_SEVEN_DAY://通用七天乐活动 29
                    {
                        //成长活动统计
                        let playerData = new SevenDaysData(activity, roleCreateTime, serverCreateTime);
                        let growthTaskArray = playerData.growth.findTaskByType(taskType); // 所有任务
                        for (let task of growthTaskArray) {
                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
                            if(taskUpdateParam) {
                                let rec = await ActivityGrowthModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
                                if(!rec) continue;
                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "growth" });
                            }
                        }
                        //今日挑战统计
                        let dailyChallengeTaskArray = playerData.dailyChallenge.findTaskByType(taskType);
                        for (let task of dailyChallengeTaskArray) {
                            if(dicTaskTypeDesc.sumType == TASK_SUM_TYPE.DO && task.dayIndex != playerData.today()) {
                                continue;
                            }
                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
                            if(taskUpdateParam) {
                                let rec = await ActivityDailyChallengesModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
                                if(!rec) continue;
                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "daily" });
                            }
                        }
                        break;
                    }
                case ACTIVITY_TYPE.REFRESH_TASK:
                    {
                        // 通用的刷新任务
                        let taskActivity = new RefreshTaskData(activity, roleCreateTime, serverCreateTime);
                        let taskArray = taskActivity.findTaskByType(taskType);
                        for (let task of taskArray) {
                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
                            if(taskUpdateParam) {
                                let rec = await ActivityRefreshTaskModel.checkAndUpdateTask(serverId, activityId, roleId, taskActivity.roundIndex, task.pageIndex, task.id, taskUpdateParam);
                                if(!rec) continue;
                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId });
                            }
                        }
                        break;
                    }
                case ACTIVITY_TYPE.TREASURE_HUNT:
                    {
                        // 寻宝奇兵任务
                        let tempData = await this.getTreasureHuntTemp();
                        if(tempData && tempData.huntActivityId == activityId) {
                            let playerData = new TreasureHuntData(activity, roleCreateTime, serverCreateTime);
                            let taskArray = playerData.tasks.findItemByTaskType(taskType);
                            for (let task of taskArray) {
                                let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
                                if(taskUpdateParam) {
                                    let rec = await ActivityTreasureHuntTaskModel.checkAndUpdateTask(serverId, activityId, roleId, tempData.huntRoundIndex, task.cellIndex, taskUpdateParam);
                                    if(!rec) continue;
                                    activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
                                }
                            }
                        }
                        break;
                    }
                case ACTIVITY_TYPE.THIRTY_DAYS:
                    {
                        //30天任务统计
                        let thirtyDaysActivity = new ThirtyDaysData(activity, roleCreateTime, serverCreateTime);
                        let taskArray = thirtyDaysActivity.findTaskByType(taskType);
                        for (let task of taskArray) {
                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
                            if(taskUpdateParam) {
                                let rec = await ActivityThirtyDaysModel.checkAndUpdateTask(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.tab, taskUpdateParam);
                                if(!rec) continue;
                                activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
                            }
                        }
                        break;
                    }
                case ACTIVITY_TYPE.GROWTH_FUND_MAIN:
                case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP:
                    {
                        //主线成长基金
                        if(taskType != TASK_TYPE.BATTLE_MAIN) continue;

                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
                        growthFundActivity.setPlayerRecords(playerRecords);
                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
                            growthFundActivity.initBuyRecords(buyRecords);
                        }
                        let taskArray = growthFundActivity.unLockItem(this.param.warId);
                        //推送
                        activityTaskPushMessages.push(...taskArray);
                        break;
                    }
                case ACTIVITY_TYPE.GROWTH_FUND_TOWER:
                case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP:
                    {
                        //镇念塔成长基金
                        if(taskType != TASK_TYPE.BATTLE_TOWER_LV) continue;

                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
                        growthFundActivity.setPlayerRecords(playerRecords);
                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
                            growthFundActivity.initBuyRecords(buyRecords);
                        }
                        let taskArray = growthFundActivity.unLockItem(this.param.towerLv);
                        //推送
                        activityTaskPushMessages.push(...taskArray);
                        break;
                    }
                case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE:
                case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP:
                    {
                        //精英成长基金
                        if(taskType != TASK_TYPE.BATTLE_MAIN_ELITE) continue;

                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
                        growthFundActivity.setPlayerRecords(playerRecords);
                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
                            growthFundActivity.initBuyRecords(buyRecords);
                        }
                        let taskArray = growthFundActivity.unLockItem(this.param.warId);
                        //推送
                        activityTaskPushMessages.push(...taskArray);
                        break;
                    }
            }
        }

        if (taskPushMessages.length > 0) {
            if (!sid) {
                let onlineUser = await getRoleOnlineInfo(roleId);
                sid = onlineUser.sid;
            }
            if (!!sid) {
                let uids = [{ uid: roleId, sid }];
                pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, taskPushMessages), uids);
            }
        }
        if (activityTaskPushMessages?.length > 0) {
            if (!sid) {
                let onlineUser = await getRoleOnlineInfo(roleId);
                sid = onlineUser.sid;
            }
            if (!!sid) {
                let uids = [{ uid: roleId, sid }];
                pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, activityTaskPushMessages), uids);
            }
        }
    }

    public checkIsMatch(dicTaskParam: number[], count: number): UpdateTaskParam {
        let param = this.param;
        switch(this.taskType) {
            case TASK_TYPE.LOGIN_SUM:
                {
                    let today = getZeroPoint();
                    if (today > param.role.loginTime) {
                        return { inc: count }
                    }
                }
        }
    }

    private async getTreasureHuntTemp() {
        if(this.treasureHuntTemp) return this.treasureHuntTemp;

        let tempData: ServerTempModelType = await ServerTempModel.findData(this.serverId);
        if (tempData) {
            this.treasureHuntTemp = tempData;
            return tempData
        } else {
            return null
        }    
    }
}

class TaskParam {
    role?: RoleType;          // 玩家数据
    warId?: number;
    towerLv?: number;

    public setRole(role: RoleType) {
        this.role = role;
    }

}