import { gameData } from "../pubUtils/data";
import { GuildModel, GuildType } from "../db/Guild";
import { resResult, shouldRefreshWeek, shouldRefresh } from "../pubUtils/util";
import { STATUS, GUILD_OPERATE, MAIL_TYPE } from "../consts";
import { RoleModel, RoleType } from "../db/Role";
import { UserGuildModel, UserGuildType } from "../db/UserGuild";
import { UserGuildApplyModel } from "../db/UserGuildApply";
import { SystemConfigModel } from "../db/SystemConfig";
import { nowSeconds } from "../pubUtils/timeUtil";
import { pinus } from "pinus";
import { GuildRecType } from "../db/GuildRec";
import { MailModel } from "../db/Mail";
import { RewardInter } from "../pubUtils/interface";
import { getRedis } from "./redisService";

/**
 * @description 检查该玩家是否有权限做操作
 * @param func 操作id
 * @param auth 权限
 */
export async function checkAuth(func: number, roleId: string, code?: string, userGuild?: UserGuildType) {
    const auth = await UserGuildModel.getMyAuth(roleId, code, userGuild);
    const dicGuildAuth = gameData.guildAuth.get(func);
    console.log(auth, dicGuildAuth)
    if(!dicGuildAuth) return false;

    return dicGuildAuth.includes(auth);
}

/**
 * @description 加入公会
 * @param code 公会code
 * @param lv 公会当前等级，判断人数用
 * @param roleId 加入的玩家
 */
export async function joinGuild(code: string, lv: number, roleId: string, serverId: number) {

    // TODO 加redlock
    
    const result = await RoleModel.joinGuild(roleId);
    if(!result) {
        return { status: 0, resResult: resResult(STATUS.GUILD_HAS_JOIN) };
    }

    const dicCenterBase = gameData.centerBase.get(lv);
    if(!dicCenterBase) {
        return { status: 0, resResult: resResult(STATUS.DIC_DATA_NOT_FOUND) };
    }
    const maxMemberCnt = dicCenterBase.peopleNum;
    const guild = await GuildModel.addGuild(code, roleId, maxMemberCnt, serverId);
    if(!guild) {
        return { status: 0, resResult: resResult(STATUS.GUILD_MEMBER_MAX) };
    }

    const role = await RoleModel.findByRoleId(roleId);
    const userGuild = await UserGuildModel.createUserGuild(guild.code, role, false);
    if(!userGuild) {
        return { status: 0, resResult: resResult(STATUS.GUILD_CREATE_ERROR) };
    }

    await UserGuildApplyModel.deleteApply(roleId); // 删除玩家所有对其他公会的申请

    return { status: 1, guild, userGuild, roleName: role.roleName, memberCnt: guild.memberCnt }
}

/**
 * 刷新军团活跃
 * @param guildCode 军团唯一code
 * @param serverId 区
 */
export async function getGuildWithRefActive(guildCode: string, serverId: number) {
    
    // TODO 加写锁
    let guild = await GuildModel.findByCode(guildCode, serverId, '+refTimeDaily');
    if(!guild) return false;

    console.log(JSON.stringify(guild));
    const now = new Date();
    let { activeDaily, refTimeDaily} = guild;

    let isRefDaily = shouldRefresh(refTimeDaily, now, 0);
    if(isRefDaily) {
        activeDaily = 0; refTimeDaily = now;
        guild = await GuildModel.updateInfo(guildCode, { activeDaily, refTimeDaily }, {});
    }

    return guild;
}

/**
 * 增加活跃
 * @param guildCode 军团唯一code
 * @param serverId 区
 * @param active 增加的活跃
 */
export async function addGuildActive(guildCode: string, serverId: number, active: number) {
    
    // TODO 加写锁
    let guild = await GuildModel.findByCode(guildCode, serverId, '+refTimeDaily');
    if(!guild) return false;

    const now = new Date();
    let { activeDaily, activeWeekly, refTimeDaily} = guild;

    let isRefDaily = shouldRefresh(refTimeDaily, now, 0);
    if(isRefDaily) {
        activeDaily = 0; refTimeDaily = now;
    }

    activeWeekly += active; activeDaily += active;

    guild = await GuildModel.updateInfo(guildCode, { activeDaily, activeWeekly, refTimeDaily }, {});
    return guild;
}

/**
 * 获取用户公会表并刷新活跃
 * @param roleId 用户id
 * @param select 筛选字段
 */
export async function getUserGuildWithRefActive(roleId: string, select: string) {
    let userGuild = await UserGuildModel.getMyGuild(roleId, select? select + ' +refTimeDaily': '+refTimeDaily');
    if(!userGuild) return false;
    let { receivedActive, refTimeDaily } = userGuild;

    const now = new Date();
    let isRefDaily = shouldRefresh(refTimeDaily, now, 0);
    if(isRefDaily) {
        receivedActive = 0; refTimeDaily = now;

        userGuild = await UserGuildModel.updateInfo(roleId, { receivedActive, refTimeDaily }, select);
        if(!userGuild) return false;
    }

    return userGuild;
}

/**
 * 每周结算上周公会周功勋和 活跃并发奖励（未完）
 * 
 */
export async function settleGuildWeekly() {
    console.log('————— settleGuildWeekly —————');
    const guildList = await GuildModel.findAllGuild('code activeWeekly');

    for(let { code, activeWeekly } of guildList) {
        // 转换周活跃奖励
        const userGuildList = await UserGuildModel.getListByGuild(code, 'honourWeekly', { honourWeekly: -1, honourUpdateTime: 1 });
        
    }

    await SystemConfigModel.updateSystemConfig({settleGuildWeeklyTime: nowSeconds()}); // 记录一下
}

export const message = {
    getChannel: function(name: string, create: boolean = false) {
        let channel = pinus.app.get('channelService').getChannel(name, create);
        return channel
    },
    enterChannel: function (guildCode: string, roleId: string, sid: string) {
        // 加入channel
        let channel = this.getChannel(`guild${guildCode}`, true);
        let users = channel.getMembers();
        if (users.indexOf(roleId) === -1) {
            channel.add(roleId, sid);
        }
        return channel
    },
    memberQuit: function (guildCode: string, roleId: string, guild: GuildType,sid?: string) {
        // 被踢出公会
        this.pushMessageByUids(`guild${guildCode}`, 'onMemberQuit', roleId, {
            code: guildCode,
            roleId
        }, sid);
        // 更新人数减少
        this.updateInfo(guildCode, { memberCnt: guild.memberCnt });
    },
    dismiss: function(guildCode: string) {
        let channel = this.getChannel(`guild${guildCode}`);
        if(!!channel) {
            channel.pushMessage('onDismiss', resResult(STATUS.SUCCESS, { code: guildCode }));
            channel.destroy();
        }
    },
    updateInfo: function(guildCode: string, info: any) {
        let channel = this.getChannel(`guild${guildCode}`);
        if(!!channel) {
            channel.pushMessage('onGuildInfoUpdate', resResult(STATUS.SUCCESS, {code: guildCode, ...info}));
        }
    },
    changeLeader: function(guildCode: string, managerCnt: number, newLeader: RoleType, oldLeaderId: string) {
        let { roleId, roleName, sHid, headHid, lv, loginTime } = newLeader;
        this.updateInfo(guildCode, {managerCnt, leader: { roleId, roleName, sHid, headHid, lv, loginTime }});
        this.demotion(guildCode, oldLeaderId);
        this.promotion(guildCode, roleId);
    },
    demotion: function(guildCode: string, roleId: string) {
        this.pushMessageByUids(`guild${guildCode}`, 'onDemotion', roleId, {
            code: guildCode
        });
    },
    promotion: function(guildCode: string, roleId: string) {
        this.pushMessageByUids(`guild${guildCode}`, 'onPromotion', roleId, {
            code: guildCode
        });
    },
    addRec: function(guildRecType: GuildRecType) {
        let { guildCode, type, params, createTime } = guildRecType;
        let channel = this.getChannel(`guild${guildCode}`);
        if(!!channel) {
            channel.pushMessage('onGuildRecAdd', resResult(STATUS.SUCCESS, {type, params, createTime}));
        }
    },
    pushMessageByUids: function (name: string, path: string, roleId: string, message: {code: string, roleId?: string}, sid?: string) {

        let channel = this.getChannel(name);
        let uids = [];
        if(!sid) {
            sid = channel && channel.getMember(roleId)['sid'];
        }
        if(sid) {
            uids.push({roleId, sid});
            pinus.app.get('channelService').pushMessageByUids(path, resResult(STATUS.SUCCESS, message), uids);
        }
    }

}