import { Application, BackendSession, HandlerService, } from 'pinus';
import { getPlayerNovemberData, getPlayerNovemberDataShow } from '../../../services/activity/novemberServices';
import { genCode, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityNovemberRecModel, NovemberRecord } from '../../../db/ActivityNovemberRec';
import { RewardInter } from '../../../pubUtils/interface';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getZeroPoint } from '../../../pubUtils/timeUtil';


export default function (app: Application) {
    new HandlerService(app, {});
    return new NovemberHandler(app);
}

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

    async getData(msg: { activityId: number }, session: BackendSession) {
        const { activityId } = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');

        let playerData = await getPlayerNovemberDataShow(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);

        return resResult(STATUS.SUCCESS, playerData);
    }

    async gameStart(msg: { activityId: number, menuId: number }, session: BackendSession) {
        const { activityId, menuId } = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');

        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData || !playerData.menuMap) return resResult(STATUS.ACTIVITY_MISSING);
        let menu = playerData.menuMap.get(menuId);
        if (!menu) return resResult(STATUS.ACTIVITY_MISSING);
        if (playerData.todayIndex < menu.dayIndex) return resResult(STATUS.ACTIVITY_NOVEMBER_MENU_LOCK);


        // 检测挑战次数
        if (menu.playCnt >= menu.maxPlayCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);

        const gameCode = genCode(10);
        await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, [{
            todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, isSkip: false, menuId, isPass: false
        }]);

        return resResult(STATUS.SUCCESS, { activityId, gameCode });
    }

    async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
        const { activityId, gameCode, isSuccess } = msg;
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const serverId: number = session.get('serverId');
        const sid: string = session.get('sid');


        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);

        if (!playerData.records || playerData.records.length == 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
        let record = playerData.records.find(cur => cur.gameCode == gameCode);
        if (!record) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
        if (record.isPass) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_USE);

        let menuId = record.menuId;
        let menu = playerData.menuMap.get(menuId);
        if (!menu) return resResult(STATUS.ACTIVITY_MISSING);

        if (menu.playCnt >= menu.maxPlayCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);

        let rewards: string = menu.successRewards;
        if (!isSuccess) rewards = menu.failRewards;
        let playerRecord = await ActivityNovemberRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), rewards, true);
        if (!playerRecord) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
        playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        menu = playerData.menuMap.get(menuId);

        let goods: RewardInter[] = await addItems(roleId, roleName, sid, stringToRewardParam(rewards), ITEM_CHANGE_REASON.NOVEMBER_REWARD);

        return resResult(STATUS.SUCCESS, { activityId, menuId, playCnt: menu.playCnt, maxPlayCnt: menu.maxPlayCnt, goods });
    }

    async buyCnt(msg: { activityId: number, count: number, menuId: number }, session: BackendSession) {
        const { activityId, count, menuId } = msg;
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const serverId: number = session.get('serverId');
        const sid: string = session.get('sid');

        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
        let menu = playerData.menuMap.get(menuId);
        if (!menu) return resResult(STATUS.ACTIVITY_MISSING);
        if (playerData.todayIndex < menu.dayIndex) return resResult(STATUS.ACTIVITY_NOVEMBER_MENU_LOCK);

        if (menu.buyCnt + count > menu.maxBuyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_BUY_COUNT_OVER);

        // 扣材料
        let costResult = await handleCost(roleId, sid, stringToConsumeParam(menu.buyCost), ITEM_CHANGE_REASON.NOVEMBER_COST);
        if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);

        let buyResult = await ActivityNovemberRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, { menuId, buyCnt: count }, menu.isPushBuyRec);
        if (!buyResult) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);

        playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        menu = playerData.menuMap.get(menuId);

        return resResult(STATUS.SUCCESS, { activityId, menuId, buyCnt: menu.buyCnt, maxBuyCnt: menu.maxBuyCnt });
    }

    async gameSweep(msg: { activityId: number, count: number, menuId: number }, session: BackendSession) {
        const { activityId, count, menuId } = msg;
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const serverId: number = session.get('serverId');
        const sid: string = session.get('sid');

        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
        let menu = playerData.menuMap.get(menuId);
        if (!menu) return resResult(STATUS.ACTIVITY_MISSING);
        if (playerData.todayIndex < menu.dayIndex) return resResult(STATUS.ACTIVITY_NOVEMBER_MENU_LOCK);

        if (menu.playCnt + count > menu.maxPlayCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
        let isHasSuccess = playerData.records.find(cur => cur.isSuccess && !cur.isSkip && (getZeroPoint() * 1000 <= cur.time.getTime()));
        if (!isHasSuccess) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMESWEEP_LOCK);

        let rewards: RewardInter[] = [];
        let records: NovemberRecord[] = [];
        for (let i = 0; i < count; i++) {
            records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: menu.successRewards, isSuccess: true, isSkip: true, menuId, isPass: true })
            rewards.push(...stringToRewardParam(menu.successRewards));
        }
        await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, records);

        let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.NOVEMBER_REWARD)

        playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        menu = playerData.menuMap.get(menuId);


        return resResult(STATUS.SUCCESS, { activityId, menuId, playCnt: menu.playCnt, maxPlayCnt: menu.maxPlayCnt, goods });
    }
}