import { DividendModel } from './../../../db/Dividend';
import { Application, BackendSession, ChannelService, HandlerService, pinus, } from "pinus";
import { AUCTION_STAGE, DEBUG_MAGIC_WORD, STATUS, CURRENCY_BY_TYPE, CURRENCY_TYPE, DATA_NAME, LOT_STATUS, CHANNEL_PREFIX } from "../../../consts";
import { LotModel } from "../../../db/Lot";
import { ItemReward } from "../../../domain/dbGeneral";
import { resResult } from "../../../pubUtils/util";
import { auctionStage, calculateDividend, genAuction, sendUngotDividend, startGuildAuction, startWorldAuction, stopAuction, todayGuildBegin, getBasePrice, debugAuctionLots, officialAuctionLots, auctionBidStatus, getMaxPrice, guildBidStatus, getAuction } from "../../../services/auctionService";
import { addItems, handleCost } from '../../../services/rewardService';
import { getSimpleRoleInfo } from '../../../services/roleService';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { lockData } from '../../../services/redLockService';
import { GuildModel } from '../../../db/Guild';
import { RoleModel, RoleType } from '../../../db/Role';
import { openGuildRefine } from '../../../services/guildRefineService';
import { unlockTrain } from '../../../services/guildTrainService';
import { UserGuildModel } from '../../../db/UserGuild';
import { UserGuildApplyModel } from '../../../db/UserGuildApply';
import * as dicParam from '../../../pubUtils/dicParam';
import { getAuctionRewardByPoolId } from '../../../pubUtils/data';
import { channelServer, groupRoomId } from '../../../services/chatService';

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

export class AuctionHandler {
    channelService: ChannelService;
    constructor(private app: Application) {
        this.channelService = app.get('channelService');
    }

    async getAuction(msg: { magicWord: string }, session: BackendSession) {
        const { magicWord } = msg;

        const guildCode = session.get('guildCode');
        // if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND);
        let result = await getAuction(guildCode, session, magicWord);

        return resResult(STATUS.SUCCESS, result);
    }

    async offer(msg: { code: string, max: boolean }, session: BackendSession) {
        const { code, max } = msg;
        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        const sid = session.get('sid');
        const serverId = session.get('serverId');
        const guildCode = session.get('guildCode');
        let res: any = await lockData(serverId, DATA_NAME.AUCTION_LOT, code);// 加锁

        try {
            if (!res) {
                return resResult(STATUS.REDLOCK_ERR);
            }

            const lot = await LotModel.findLot(code);
            if (!lot || lot.status === LOT_STATUS.SOLD || lot.status === LOT_STATUS.MAX) {
                res.releaseCallback();
                return resResult(STATUS.GUILD_LOT_NOT_FOUND);
            }

            if (lot.auctionStage === AUCTION_STAGE.GUILD && lot.guildCode !== guildCode) {
                res.releaseCallback();
                return resResult(STATUS.AUCTION_GUILD_MEMBER_ONLY);
            }

            const { curBuyer, curPrice, maxPrice, gid, count, bidRoles, watchingRoles } = lot;
            if (curBuyer === roleId && !max) {
                res.releaseCallback();
                return resResult(STATUS.LOT_OFFER_SERIAL);
            }
            let newPrice = Math.floor(curPrice * dicParam.GUILD_AUCTION.AUCTION_PRICE_RISE);
            let maxFlag = max;
            if (newPrice >= maxPrice) {
                newPrice = maxPrice;
                maxFlag = true;
            }
            const costRes = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: newPrice }]);
            if (!costRes) {
                res.releaseCallback();
                return resResult(STATUS.ROLE_COIN_NOT_ENOUGH);
            }

            if (curBuyer) {
                const { roleName: buyerName } = await getSimpleRoleInfo(curBuyer);
                const { isOnline, sid: buyerSid } = await getRoleOnlineInfo(curBuyer);
                await addItems(curBuyer, buyerName, buyerSid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: curPrice }]);
                if (isOnline) {
                    this.channelService.pushMessageByUids('onAuctionOver', resResult(STATUS.SUCCESS, { code }), [{ uid: curBuyer, sid: buyerSid }]);
                }
            }

            if (maxFlag) {
                newPrice = maxPrice;
                await addItems(roleId, roleName, sid, [{ id: gid, count }]);
            }
            bidRoles.push({ roleId, price: newPrice, time: new Date() });
            const newLot = await LotModel.updateLot({ code, curBuyer: roleId, curPrice: newPrice, bidRoles, status: max ? LOT_STATUS.MAX : (maxFlag ? LOT_STATUS.SOLD : LOT_STATUS.ING), watchingRoles: Array.from(new Set([...watchingRoles, roleId])) });
            res.releaseCallback();

            const incPrice = newPrice - (curBuyer ? curPrice : 0);
            let newDividend = null;
            if (lot.auctionStage === AUCTION_STAGE.GUILD) {
                const dividend = await DividendModel.updateLot(code, gid, newPrice, incPrice, max);
                newDividend = await calculateDividend(dividend);
            }
            return resResult(STATUS.SUCCESS, { lot: newLot, dividend: newDividend });
        } catch (e) {
            console.log('offer got err:', e);
            res.releaseCallback();
            return resResult(STATUS.INTERNAL_ERR);
        }
    }

    async watchLot(msg: { code: string }, session: BackendSession) {
        const roleId = session.get('roleId');
        const { code } = msg;
        const lot = await LotModel.watchLot(code, roleId);
        if (!lot) return resResult(STATUS.WRONG_PARMS);
        return resResult(STATUS.SUCCESS, { lot });
    }

    async unWatchLot(msg: { code: string }, session: BackendSession) {
        const roleId = session.get('roleId');
        const { code } = msg;
        const lot = await LotModel.unWatchLot(code, roleId);
        if (!lot) return resResult(STATUS.WRONG_PARMS);
        return resResult(STATUS.SUCCESS, { lot });
    }

    async checkDividend(msg: {}, session: BackendSession) {
        const begin = todayGuildBegin();
        const guildCode = session.get('guildCode');
        if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND);
        const dividends = await DividendModel.findGuildDividendsByBegin(guildCode, begin);
        return resResult(STATUS.SUCCESS, { dividends });
    }

    async getDividend(msg: { code: string }, session: BackendSession) {
        const roleId = session.get('roleId');
        const sid = session.get('sid');
        const roleName = session.get('roleName');
        const { code } = msg;
        const dividendData = await DividendModel.findReadyDividend(code);
        if (!dividendData) return resResult(STATUS.DIVIDEND_NOT_READY);
        const { dividends } = dividendData;
        const dividend = dividends.find(item => { return item.roleId === roleId });
        if (!dividend) return resResult(STATUS.DIVIDEND_GUILD_PLAYER_ONLY);
        await addItems(roleId, roleName, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: dividend.total }]);
        await DividendModel.updateReceiveStatus(dividendData.code, roleId);
        return resResult(STATUS.SUCCESS, { dividend });
    }

    async myWatching(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');
        const begin = todayGuildBegin();
        const lots = await LotModel.watchingLotsByBegin(serverId, roleId, begin);
        const stage = auctionStage();
        return resResult(STATUS.SUCCESS, { lots: stage === AUCTION_STAGE.END ? [] : lots });
    }

    async offerRecs(msg: { count: number }, session: BackendSession) {
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');
        const lotsData = await LotModel.recentBidLots(serverId, roleId, msg.count);
        const bidRecs = lotsData.map(lot => {
            const bidRec = lot.bidRoles.find(role => { return role.roleId === roleId });
            const { gid } = lot;
            return { ...bidRec, gid, status: auctionBidStatus(roleId, lot) };
        });
        return resResult(STATUS.SUCCESS, { bidRecs });
    }

    async guildLotRecs(msg: { count: number }, session: BackendSession) {
        const guildCode = session.get('guildCode');
        const dividends = await DividendModel.findDividendsByGuild(guildCode, msg.count);
        let lotsData = [];
        dividends.forEach(dividend => {
            const lots = dividend.lots.map(lot => {
                return { ...lot, sourceType: dividend.sourceType, dividendStatus: dividend.status };
            })
            lotsData = [...lotsData, ...lots];
        });
        const lotRecs = lotsData.map(lot => {
            const { gid, count, price: lotPrice } = lot;
            const price = lotPrice === 0 ? getBasePrice(gid, count) : lotPrice;
            const sold = guildBidStatus(lot);
            return { ...lot, price, sold };
        });

        return resResult(STATUS.SUCCESS, { lotRecs });
    }

    // ! 测试接口
    async debugSetDividendStatus(msg: { magicWord: string, sourceType: number, status: number }, session: BackendSession) {
        const { magicWord, sourceType, status } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }

        const guildCode: string = session.get('guildCode');
        if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND)
        const dividend = await DividendModel.updateDividendStatus(guildCode, sourceType, status);
        return resResult(STATUS.SUCCESS, { dividend });
    }

    // ! 测试接口
    async debugSetLotStage(msg: { magicWord: string, code: string, auctionStage: number }, session: BackendSession) {
        const { magicWord, code, auctionStage } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }
        const lot = await LotModel.updateLotStage(code, auctionStage);
        return resResult(STATUS.SUCCESS, { lot });
    }

    // ! 测试接口
    async debugAddLots(msg: { magicWord: string, sourceType: number, sourceCode: string, poolId: number }, session: BackendSession) {
        const { magicWord, sourceType, sourceCode, poolId } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }

        const guildCode: string = session.get('guildCode');
        const serverId: number = session.get('serverId');
        if (!guildCode) {//创建公会
            const roleId = session.get('roleId');
            const role: RoleType = await RoleModel.findByRoleId(roleId);
            // 创建公会
            const name = '测试公会'
            const icon = 1
            const notice = '测试公会'
            const guild = await GuildModel.createGuild({ name, icon, notice }, role, serverId);
            if (!guild) return resResult(STATUS.GUILD_CREATE_ERROR);
            guild.leader = <RoleType>guild.leader;
            //创建科技树
            await openGuildRefine(guild.code);
            await unlockTrain(guild.code, 1);
            const userGuild = await UserGuildModel.createUserGuild(guild.code, role, true);
            if (!userGuild) return resResult(STATUS.GUILD_CREATE_ERROR);

            await RoleModel.joinGuild(roleId, guild.code, guild.name);
            await UserGuildApplyModel.deleteApply(roleId); // 删除玩家所有对其他公会的申请
        }

        let rewards = getAuctionRewardByPoolId(poolId);
        if(!rewards) return resResult(STATUS.WRONG_PARMS);
        const result = await genAuction(guildCode, sourceType, magicWord, serverId, rewards);
        if (!result) {
            return resResult(STATUS.WRONG_PARMS);
        }

        return resResult(STATUS.SUCCESS, result);
    }

    // ! 测试接口
    async debugScheduleStartGuild(msg: { magicWord: string }, session: BackendSession) {
        const { magicWord } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }
        const result = await startGuildAuction();
        if (result === true) {
            return resResult(STATUS.SUCCESS);
        }
        return resResult(STATUS.INTERNAL_ERR);
    }

    // ! 测试接口
    async debugScheduleStartWorld(msg: { magicWord: string }, session: BackendSession) {
        const { magicWord } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }
        const result = await startWorldAuction();
        if (result === true) {
            return resResult(STATUS.SUCCESS);
        }
        return resResult(STATUS.INTERNAL_ERR);
    }

    // ! 测试接口
    async debugScheduleStopAuction(msg: { magicWord: string }, session: BackendSession) {
        const { magicWord } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }
        const result = await stopAuction();
        if (result === true) {
            return resResult(STATUS.SUCCESS);
        }
        return resResult(STATUS.INTERNAL_ERR);
    }

    // ! 测试接口
    async debugScheduleSendUngotDividend(msg: { magicWord: string }, session: BackendSession) {
        const { magicWord } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }
        const result = await sendUngotDividend(true);
        if (result === true) {
            return resResult(STATUS.SUCCESS);
        }
        return resResult(STATUS.INTERNAL_ERR);
    }

    async debugSetPlayTime(msg: { magicWord: string, time: string }, session: BackendSession) {
        const { magicWord, time } = msg;
        if (magicWord !== DEBUG_MAGIC_WORD) {
            return resResult(STATUS.TOKEN_ERR);
        }

        let serverId = session.get('serverId');
        let roomId = groupRoomId(CHANNEL_PREFIX.WORLD, serverId);
        const channelSid = await channelServer(roomId);
        await pinus.app.rpc.chat.chatRemote.pushCurrentTime.toServer(channelSid, serverId, new Date(time).getTime());

        return resResult(STATUS.SUCCESS);
    }
}