import { ServerlistModel } from "../db/Serverlist";
import { RoleModel } from "../db/Role";
import { reduceCe } from "../pubUtils/util";
import { GUILDACTIVITY } from "../pubUtils/dicParam";
import { gameData, getGuildAuctionRewards, getCityActivityRewards } from "../pubUtils/data";
import { getCurHourPoint, getCutDay, nowSeconds } from "../pubUtils/timeUtil";
import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE, CITY_STATUS } from "../consts";
import { Record, UserGuildActivityRecModel } from "../db/UserGuildActivityRec";
import { GateMembersRec, GateActivityObject, CityActivityObject, CityParam, Member } from "../domain/battleField/guildActivity";
import { DicGuildActivity } from "../pubUtils/dictionary/DicGuildActivity";
import { getUnionRank, getRank, getGuildKeyName, getMyUnionRank, getRankScore, getCityKeyName, getAllServers } from "./redisService";
import { GuildModel } from "../db/Guild";
import { SimpleGuildRankParam, SimpleRoleRankParam } from "../domain/rank";
import { getGuildChannelSid, getWorldChannelSid, getCityChannelSid } from "./chatChannelService";
import { pinus } from "pinus";
import { GuildActivityRecordModel } from "../db/GuildActivityRec";
import { genAuction } from "./auctionService";
import { sendMail } from "./mailService";
import { getHonourObject } from '../pubUtils/itemUtils';
import { GuildActivityCityType, GuildActivityCityModel } from "../db/GuildActivityCity";

let gateActivityObj: GateActivityObject;
let cityActivityObj: CityActivityObject;
export function getGateActivityObj() {
    if(!gateActivityObj) {
        gateActivityObj = new GateActivityObject();
    }
    return gateActivityObj;
}

export function getCityActivityObj() {
    if(!cityActivityObj) {
        cityActivityObj = new CityActivityObject();
    }
    return cityActivityObj
}

/**
 * 定时任务，获得前一天的活跃玩家中位数武将战力
 */
export async function setMedianCe() {
    let servers = await ServerlistModel.getAllServerList();

    for(let server of servers) {
        if(server.serverType == 'official') {
            let medianRole = await RoleModel.getMedianRole(server.id);
            if(!medianRole) {
                await ServerlistModel.updateByServerId(server.id, { medianCe: GUILDACTIVITY.GATEACTIVITY_ENEMYCE });
            } else {
                let { topLineup } = medianRole;
                let topHero = topLineup.sort((a, b) => b.ce - a.ce);
                let medianCe = reduceCe(topHero[0].ce);
                await ServerlistModel.updateByServerId(server.id, { medianCe });
            }
        }
    }
    return servers;
}


/**
 * 获得本服前一天活跃玩家中位数玩家的最强武将战力
 * @param serverId 
 */
export async function getMedianCe(serverId: number) {
    let server = await ServerlistModel.findByServerId(serverId);
    if(server) {
        return server.medianCe;
    }
    return GUILDACTIVITY.GATEACTIVITY_ENEMYCE;
}

/**
 * 根据当前时间判断军团活动倒计时
 * @param id 军团活动id
 */
export function getGuildActivityStatus(id: number) {
    let dicGuildActivity = gameData.guildActivity.get(id);
    if(!dicGuildActivity) return false;
    return getGuildActivityByDic(dicGuildActivity);
}

export function getGuildActivityByDic(dicGuildActivity: DicGuildActivity) {
    
    let startTime = getCurHourPoint(dicGuildActivity.startTime, dicGuildActivity.startMinute);
    let countdownTime = getCurHourPoint(dicGuildActivity.countDown);
    let { duringTime, openDay } = dicGuildActivity;
    let endTime = startTime + duringTime;

    let status = 0, time = 0;
    let now = nowSeconds();
    if(now >= countdownTime && now < startTime) {
        status = GUILD_ACTIVITY_STATUS.WAITING;
        time = startTime - now;
    } else if (now >= startTime && now < endTime) {
        status = GUILD_ACTIVITY_STATUS.START;
        time = endTime - now;
    } else {
        status = GUILD_ACTIVITY_STATUS.END;
    }

    let day = getCutDay();
    let isOpen = openDay.includes(day);

    return {
        status, time, isOpen
    }
}

/**
 * 根据每回合上报数据判断军功
 * @param aid 
 * @param record 
 * @param memberRecord 
 */
export function getRecordScore(aid: number, round: number, record: { round: number, dataId: number }[], memberRecord: GateMembersRec) {
    let dicGuildActivity = gameData.guildActivity.get(aid);
    if(!dicGuildActivity) return false;

    let dicWarJson = gameData.warJson.get(dicGuildActivity.warid);
    if(!dicWarJson) return false;

    let { round: curRound, enemies: historyEnemies} = memberRecord;
    let sum = 0, newRecords = new Array<Record>();
    for(let {round, dataId} of record) {
        if(!historyEnemies.includes(dataId)) {

            let enemy = dicWarJson.find(cur => cur.dataId == dataId);
            let enemyType = enemy.enemyType;
            let score = gameData.gateActivityPoint.get(enemyType);
            newRecords.push({ round, dataId, score, enemyType});
            sum += score;
            console.log('*******', sum, score, enemyType);

            historyEnemies.push(dataId);            
        }
    }

    for(let i = curRound + 1; i <= round; i++) {
        sum += gameData.gateActivityPoint.get(GET_POINT_WAYS.ROUND_START);
        memberRecord.round = i;
        console.log('********', sum, i);
    }

    return { score: sum, newRecords, memberRecord }
}

export async function getGateActivityRank(guildCode: string, serverId: number, roleId?: string, roleName?: string) {
    let guildKey = REDIS_KEY.GATE_ACTIVITY;
    let memberKey = getGuildKeyName(REDIS_KEY.USER_GATE_ACTIVITY, guildCode);
    let rec = await getGuildActivityRank(guildKey, memberKey, guildCode, serverId, roleId, roleName);
    return rec;
}

export async function getCityActivityRank(guildCode: string, serverId: number, cityId: number, roleId?: string, roleName?: string) {
    let guildKey = getCityKeyName(REDIS_KEY.CITY_ACTIVITY, cityId);
    let memberKey = getGuildKeyName(REDIS_KEY.USER_CITY_ACTIVITY, guildCode);
    let rec = await getGuildActivityRank(guildKey, memberKey, guildCode, serverId, roleId, roleName);
    return rec;
}

/**
 * 获得军团活动排行榜
 * @param guildCode 
 * @param serverId 
 * @param roleId 
 * @param roleName 
 */
export async function getGuildActivityRank(guildKey: string, memberKey: string, guildCode: string, serverId: number, roleId?: string, roleName?: string) {
    
    let guildRankResult = await getUnionRank(guildKey, serverId, guildCode);
    let guildRank = new Array<SimpleGuildRankParam>();
    for(let { rank, code, name, num } of guildRankResult.ranks) {
        let param = new SimpleGuildRankParam(rank, code, name, num);
        guildRank.push(param);
    }
    let myGuildRank: SimpleGuildRankParam;
    if(guildRankResult.myRank) {
        let { rank, code, name, num } = guildRankResult.myRank;
        myGuildRank = new SimpleGuildRankParam(rank, code, name, num);
    } else {
        let guild = await GuildModel.findByCode(guildCode, serverId, 'name');
        myGuildRank = new SimpleGuildRankParam(0, guildCode, guild?.name, 0);
    }

    let memberRankResult = await getRank(memberKey, serverId, roleId);
    let memberRank = new Array<SimpleRoleRankParam>();
    for(let { rank, roleId, roleName, num } of memberRankResult.ranks) {
        let param = new SimpleRoleRankParam(rank, roleId, roleName, num);
        memberRank.push(param)
    }
    let myMemberRank: SimpleRoleRankParam;
    if(roleName) {
        if(memberRankResult.myRank) {
            let { rank, roleId, roleName, num } = memberRankResult.myRank;
            myMemberRank = new SimpleRoleRankParam(rank, roleId, roleName, num);
        } else {
            myMemberRank = new SimpleRoleRankParam(0, roleId, roleName, 0);
        }
    }

    return { guildRank, myGuildRank, memberRank, myMemberRank }
}

/**
 * 对这个guild服内所有军团发排行榜信息
 * @param aid 活动类型
 */
export async function sendAllGuildRanks(aid: number) {
    if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
        let obj = getGateActivityObj();
        let guilds = obj.getGuilds();
        for(let [ serverId, guildCodes ] of guilds) {
            // TODO 不需要每个军团都排序一次
            for(let guildCode of guildCodes) {
                let ranks =  await getGateActivityRank(guildCode, serverId);
                let chatSid = await getGuildChannelSid(guildCode);
                pinus.app.rpc.chat.guildRemote.pushRank.toServer(chatSid, guildCode, ranks);
            }
        }
    } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
        let obj = getCityActivityObj();
        let { cities } = obj.getAllCities();
        // console.log(JSON.stringify(cities));
        for(let { serverId, cityId, guildCodes } of cities) {
            for(let guildCode of guildCodes) {
                let ranks = await getCityActivityRank(guildCode, serverId, cityId);
                let chatSid = await getGuildChannelSid(guildCode);
                pinus.app.rpc.chat.guildRemote.pushCityActRank.toServer(chatSid, guildCode, ranks);
            }
        }
    }
}

/**
 * 活动结算奖励
 * @param aid 活动类型
 */
export async function sendGuildActEndMsg(aid: number) {

    if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
        let obj = getGateActivityObj();
        let guilds = obj.getGuilds();
        for(let [ serverId, guildCodes ] of guilds) {
            for(let guildCode of guildCodes) {
                await gateActivitySettleReward(guildCode, serverId);
            }
        }
        gateActivityObj = new GateActivityObject();
    } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
        let obj = getCityActivityObj();
        let { cities, serverlists} = obj.getAllCities();
        for(let { serverId, cityId } of cities) {
            await cityActivitySettleReward(cityId, serverId);
        }
        // 发完之后再做下周自动宣战
        for(let serverId of serverlists) {
            await autoDeclare(serverId);
        }
        cityActivityObj = new CityActivityObject();
    }
}

// 全服发送结束新号
export async function sendEndMsgToAll() {
    let serverlist =  await getAllServers();
    for(let serverId of serverlist) {
        let chatSid = await getWorldChannelSid(serverId);
        pinus.app.rpc.chat.chatRemote.sendGuildActivityEnd.toServer(chatSid, serverId);
    }
}

/**
 * 单个军团城门血条破了之后给他发奖励
 * @param guildCode 军团code
 */
export async function sendSingleGateActEndMsg(guildCode: string, serverId: number) {
    let chatSid = await getGuildChannelSid(guildCode);
    pinus.app.rpc.chat.guildRemote.sendGuildActivityEnd.toServer(chatSid, guildCode);
    await gateActivitySettleReward(guildCode, serverId);
}


/**
 * 单个城池城门血条破了之后给他发奖励
 * @param guildCode 军团code
 */
export async function sendSingleCityActEndMsg(cityId: number, serverId: number) {
    let chatSid = await getCityChannelSid(cityId);
    let obj = getCityActivityObj();
    let guildCodes = obj.getGuildsInCity(serverId, cityId);
    for(let guildCode of guildCodes) {
        pinus.app.rpc.chat.guildRemote.sendGuildActivityEnd.toServer(chatSid, guildCode);
    }
    await cityActivitySettleReward(cityId, serverId);
}


/**
 * 结算蛮夷入侵奖励
 * @param guildCode 军团code
 * @param serverId 服务器id
 */
export async function gateActivitySettleReward(guildCode: string, serverId: number) {
    let obj = getGateActivityObj();
    let { gateHp, members } = obj.getObj(guildCode, serverId);

    let rank = await getMyUnionRank(REDIS_KEY.GATE_ACTIVITY, serverId, guildCode);
    let guildScore = await getRankScore(REDIS_KEY.GATE_ACTIVITY, serverId, guildCode);

    let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY, rank);

    let rec = await GuildActivityRecordModel.updateInfo(guildCode, { 
        isSuccess: gateHp > 0, 
        isCompleted: true, 
        rank, score: guildScore, remainGateHp: gateHp,
        members, memberCnt: members.length,
        auctionType: AUCTION_SOURCE.GATE,
        rewards
    });
    // 结算功勋等奖励
    let dic = gameData.guildActivity.get(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
    let memberRankResult = await getRank(getGuildKeyName(REDIS_KEY.USER_GATE_ACTIVITY, guildCode), serverId, '');
    for(let { rank, roleId, num: myScore } of memberRankResult.ranks) {
        let honour = dic.honour + myScore * GUILDACTIVITY.GATEACTIVITY_HONOUR_RATIO;
        await updateUserRecAndSendHonour(honour, myScore, rank, roleId, members);
    }
    for(let { roleId } of members) { // 只参加了，没有分数的人
        await updateUserRecAndSendHonour(dic.honour, 0, 0, roleId, members);
    }

    // 加入拍卖行
    await genAuction(guildCode, AUCTION_SOURCE.GATE, rec.code, serverId, rewards);

    obj.delGuildRecord(guildCode, serverId);
}

async function updateUserRecAndSendHonour(honour: number, myScore: number, rank: number, roleId: string, members: Member[]) {
    let honourObj = getHonourObject(Math.floor(honour));
    await sendMail(MAIL_TYPE.GUILD_ACTIVITY_REWARD, roleId, '系统', [], [honourObj])

    await UserGuildActivityRecModel.updateInfoByRoleId(roleId, { score: myScore, rank });
    let index = members.findIndex(cur => cur.roleId == roleId);
    members.splice(index, 1);
}


/**
 * 结算诸侯入侵奖励
 * @param cityId 城镇id
 * @param serverId 服务器id
 */
export async function cityActivitySettleReward(cityId: number, serverId: number) {
    let obj = getCityActivityObj();

    let dicCity = gameData.cityActivity.get(cityId);
    if(!dicCity) return;
    let gateHp = obj.getGateHpAndInc(serverId, cityId, dicCity.hp);
    let isSuccess = gateHp <= 0; // 血条未击破则没有占领军团
    
    let guildRankRsult = await getUnionRank(getCityKeyName(REDIS_KEY.CITY_ACTIVITY, cityId), serverId, '');
    for(let { rank: guildRank, code: guildCode, name, num } of guildRankRsult.ranks) {
        if(guildRank == 1) {
            if(isSuccess) {
                await GuildActivityCityModel.guard(serverId, cityId, guildCode, name); // 占领
            } else {
                await GuildActivityCityModel.guard(serverId, cityId, "", ""); // 无人能占领
            }
        }
        let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, guildRank);
        let members = obj.getMembersOfGuild(guildCode);

        let rec = await GuildActivityRecordModel.updateInfo(guildCode, {
            memberCnt: members.length, members,
            isSuccess, isCompleted: true,
            rank: guildRank, damage: num, remainGateHp: gateHp,
            rewards,
            auctionType: AUCTION_SOURCE.CITY,
        });

        // 奖励加入拍卖行
        await genAuction(guildCode, AUCTION_SOURCE.GATE, rec.code, serverId, rewards);

        let dic = gameData.guildActivity.get(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
        let memberRankResult = await getRank(getGuildKeyName(REDIS_KEY.USER_GATE_ACTIVITY, guildCode), serverId, '');
        let userRank = 0;
        for(let { rank, roleId, num: myScore } of memberRankResult.ranks) {
            let honour = dic.honour + getCityActivityRewards(dicCity.type, guildRank, rank);
            await updateUserRecAndSendHonour(honour, myScore, rank, roleId, members);
            userRank = rank;
        }
        for(let { roleId } of members) { // 只参加了，没有分数的人
            let honour = dic.honour + getCityActivityRewards(dicCity.type, guildRank, userRank);
            await updateUserRecAndSendHonour(honour, 0, 0, roleId, members);
        }
    }

    obj.delCityRecord(cityId, serverId);
}

/**
 * 清空完declareGuilds之后，做下一次活动的自动宣战
 */
async function autoDeclare(serverId: number) {
    let allCities = await GuildActivityCityModel.getAllCities(serverId);
    for(let { cityId, guardGuildCode } of allCities) {
        let dicCity = gameData.cityActivity.get(cityId);
        if(guardGuildCode && dicCity.nextCity) {
            await GuildActivityCityModel.declare(serverId, dicCity.nextCity, guardGuildCode);
        }
    }
}

/**
 * 获取活动参加者
 * @param guildCode 军团code
 * @param sourceType 拍卖类型 AUCTION_SOURCE
 * @param sourceCode 活动唯一code
 */
export async function participants(guildCode: string, sourceType: number, sourceCode: string) {
    let rec = await GuildActivityRecordModel.findBySourceCode(guildCode, sourceType, sourceCode);
    if(!rec) return [];

    return rec.members||[];
}

/**
 * 获取诸侯入侵各个城池状态
 * @param guildCode 我方军团
 * @param dbCities 所有城池
 */
export function getCities(guildCode: string, dbCities: GuildActivityCityType[]) {

    let cities = new Array<CityParam>();
    for(let [ cityId, dic ] of gameData.cityActivity) {
        let param = new CityParam(cityId);
        let curCity = dbCities.find(cur => cur.cityId == cityId);

        if(curCity) {
            param.guardGuildCode = curCity.guardGuildCode||"";
            param.guardGuildName = curCity.guardGuildName||"";
            param.declareCount = curCity.declareCount||0;
        }

        param.status = getCityStatus(guildCode, cityId, dic.preCity, dbCities);
        cities.push(param);
    }
    return cities
}


/**
 * 诸侯混战 获取城池状态
 * @param guildCode 
 * @param cityId 
 * @param preCity 
 * @param dbCities 
 */
export function getCityStatus(guildCode: string, cityId: number, preCity: number[], dbCities: GuildActivityCityType[]) {
    let status = CITY_STATUS.NOT_OPEN;
    if(preCity && preCity.length) {
        let hasGuardCity = dbCities.find(cur => {
            return preCity.includes(cur.cityId) && cur.guardGuildCode == guildCode;
        });
        if(!!hasGuardCity) {
            status = CITY_STATUS.CAN_DECLARE;
        }
    } else {
        status = CITY_STATUS.CAN_DECLARE;
    }
    let curCity = dbCities.find(cur => cur.cityId == cityId);
    if(curCity) {
        if(curCity.guardGuildCode == guildCode) {
            status = CITY_STATUS.GUARD;
        } else if (curCity.declareGuilds.includes(guildCode)) {
            status = CITY_STATUS.DECLARED;
        }
    }
    return status;
}