import { Application, BackendSession, pinus } from "pinus";
import { resResult, parseGoodStr } from "../../../pubUtils/util";
import { STATUS, TASK_FUN_TYPE } from "../../../consts";
import { gameData } from "../../../pubUtils/data";
import { UserTaskRecModel } from "../../../db/UserTaskRec";
import { addItems } from "../../../services/rewardService";
import { UserTaskModel } from "../../../db/UserTask";
import { getCurWeekDate, nowSeconds } from "../../../pubUtils/timeUtil";
import { DicDailyTask, DicAchievement } from "../../../pubUtils/dictionary/DicTask";
import { getMainTask, refDailyTaskBox, removeHistoryTask, getDailyTask, getCurTask } from "../../../services/taskService";
import { TASK } from "../../../pubUtils/dicParam";

export default function(app: Application) {
    return new ShopHandler(app);
}

export class ShopHandler {
    constructor(private app: Application) {
    }

    // 领取主线任务、每日任务、成就单条任务
    async receiveTask(msg: { type: number, id: number }, session: BackendSession) {
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const sid: string = session.get('sid');
        const { type, id } = msg;

        let dicTask = gameData.tasks.get(type).get(id);
        let { group, taskType, taskReward, condition } = dicTask;
        // 检查
        let rec = await UserTaskRecModel.findByRoleAndGroup(roleId, type, taskType, group);
        if(!rec) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
        if(rec.count < condition) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
        if(rec.received.includes(id)) return resResult(STATUS.TASK_HAS_RECEIVED);

        // 领取记录
        rec = await UserTaskRecModel.receiveTask(roleId, type, taskType, group, id);

        // 每日、成就增加积分
        let point = 0, weeklyPoint = 0;
        if(type == TASK_FUN_TYPE.DAILY) { // 增加积分
            let userTask = await UserTaskModel.findByRole(roleId);
            let dic = <DicDailyTask>dicTask;
            let curWeek = getCurWeekDate(1, 5);
            if(curWeek > userTask.dailyTaskRefWeekly) {
                userTask = await UserTaskModel.resetDailyScore(roleId, dic.point, curWeek);
            } else {
                userTask = await UserTaskModel.incInfo(roleId, { dailyTaskPoint: dic.point, dailyTaskPointWeekly: dic.point });
            }
            point = userTask.dailyTaskPoint;
            weeklyPoint = userTask.dailyTaskPointWeekly;
        } else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
            let dic = <DicAchievement>dicTask;
            let userTask = await UserTaskModel.incInfo(roleId, { achievementPoint: dic.point });
            point = userTask.achievementPoint;
        }

        let goods = await addItems(roleId, roleName, sid, taskReward);

        return resResult(STATUS.SUCCESS, {
            type, id, count: rec.count, received: rec.received.includes(id),
            point, weeklyPoint,
            goods
        });
    }

    // 领取主线阶段奖励
    async receiveMainStage(msg: { stage: number }, session: BackendSession) {

        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const sid: string = session.get('sid');
        const { stage } = msg;

        let dicMainStage = gameData.mainTaskStage.get(stage);
        if(!dicMainStage) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        // 检查
        let userTask = await UserTaskModel.findByRole(roleId);
        if(userTask.mainTaskStage != stage) {
            return resResult(STATUS.WRONG_PARMS);
        }
        let recs = await UserTaskRecModel.getReceiveRec(roleId, TASK_FUN_TYPE.MAIN);
        for(let id of dicMainStage.mainTaskId) {
            let curRecs = recs.find(cur => cur.received.includes(id));
            if(!curRecs) return resResult(STATUS.TASK_NOT_ALL_RECEIVED);
        }
        // 更新数据
        userTask = await UserTaskModel.incInfo(roleId, { mainTaskStage: 1 });

        let goods = await addItems(roleId, roleName, sid, dicMainStage.reward);
        let mainTask = await getMainTask(roleId, userTask);

        return resResult(STATUS.SUCCESS, {
            type: TASK_FUN_TYPE.MAIN,
            ...mainTask,
            goods
        });
    }

    // 领取每日活跃奖励
    async receiveActiveReward(msg: { }, session: BackendSession) {

        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const sid: string = session.get('sid');

        // 检查
        let userTask = await UserTaskModel.findByRole(roleId);
        let { dailyTaskPoint } = userTask;
        if(dailyTaskPoint < TASK.DAILYTASK_POINT) {
            return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
        }
        // 更新数据
        userTask = await UserTaskModel.decreaseDailyPoint(roleId, TASK.DAILYTASK_POINT);
        if(!userTask) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);

        let reward = parseGoodStr(TASK.DAILYTASK_POINT_REWARD);
        let goods = await addItems(roleId, roleName, sid, reward);

        return resResult(STATUS.SUCCESS, {
            type: TASK_FUN_TYPE.DAILY,
            point: userTask.dailyTaskPoint,
            goods
        });
    }

    // 领取每日周宝箱
    async receiveBox(msg: { type: number, id: number }, session: BackendSession) {
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const sid: string = session.get('sid');
        const { type, id } = msg;

        let userTask = await UserTaskModel.findByRole(roleId);
        let dicTaskBox = gameData.taskBox.get(type)?.get(id);
        if(!dicTaskBox) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        let point = 0, weeklyPoint = 0, box: number[] = [];
        // 每日、成就增加积分
        if(type == TASK_FUN_TYPE.DAILY) { // 增加积分
            let curWeek = getCurWeekDate(1, 5);
            let shouldRefresh = false;
            let { dailyTaskPointWeekly, dailyTaskBox, dailyTaskRefWeekly } = userTask;

            if(curWeek > dailyTaskRefWeekly) {
                shouldRefresh = true;
                dailyTaskPointWeekly = 0;
                dailyTaskBox = [];
            }
            if(dailyTaskPointWeekly > dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
            if(dailyTaskBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);

            userTask = await UserTaskModel.pushDailyBox(roleId, id, curWeek, shouldRefresh);

            point = userTask.dailyTaskPoint;
            box = userTask.dailyTaskBox;
            weeklyPoint = userTask.dailyTaskPointWeekly;

        } else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
            let { achievementPoint, achievementBox } = userTask;
            if(achievementPoint > dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
            if(achievementBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);

            userTask = await UserTaskModel.pushAchievementBox(roleId, id);

            point = userTask.achievementPoint;
            box = userTask.achievementBox;
        } else {
            return resResult(STATUS.WRONG_PARMS);
        }

        let goods = await addItems(roleId, roleName, sid, dicTaskBox.reward);

        return resResult(STATUS.SUCCESS, {
            type,
            point, weeklyPoint, box,
            goods
        });
    }

    async debugRefTask(msg: { type: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let sid = session.get('sid');
        let { type } = msg
        let userTask;
        if(type == TASK_FUN_TYPE.DAILY) {
            let uids = [{uid: roleId, sid}];
    
            // 转移每日任务
            await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
            pinus.app.get('channelService').pushMessageByUids('onDailyTaskRefresh', resResult(STATUS.SUCCESS, { taskList: [] }), uids);

            await refDailyTaskBox(roleId, sid, true);
            userTask = await UserTaskModel.updateInfo(roleId, { dailyTaskPoint: 0 });

        } else if( type == TASK_FUN_TYPE.MAIN){
            await UserTaskModel.updateInfo(roleId, { mainTaskStage: 1 });
            userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
        } else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
            await UserTaskModel.updateInfo(roleId, { achievementBox: [], achievementPoint: 0 });
            userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
        }

        let curTask = await getCurTask(roleId, session);;
        return resResult(STATUS.SUCCESS, curTask);
    }
}