import { GUILDACTIVITY } from "../../pubUtils/dicParam";
import { SimpleGuildRankParam, SimpleRoleRankParam } from '../rank'
import { prop } from "@typegoose/typegoose";
import { CITY_STATUS, RACE_EVENT, RACE_EVENT_TYPE, GUILD_ACTIVITY_STATUS } from "../../consts";
import { gameData } from "../../pubUtils/data";
import { RewardInter } from "../../pubUtils/interface";

export class WoodenHorseMember {
    roleId: string;
    roleName: string;
    sid: string;
    items: RewardInter[] = [];
    code?: string;
    hasReceiveInitItems: boolean = false;
    isOnline: boolean = false;

    constructor(roleId: string, roleName: string, sid: string, code: string) {
        this.roleId = roleId;
        this.roleName = roleName;
        this.sid = sid;
        this.code = code;
        if(sid) this.isOnline = true;
    }

    addTempItem(item: RewardInter) {
        this.items.push(item);
    }

    addTempItems(items: RewardInter[]) {
        this.items.push(...items);
    }

    getTempItems() {
        return this.items;
    }

    receiveTempItems() {
        let items = [...this.items];
        this.items = [];
        return items;
    }

    isReceived() {
        return this.hasReceiveInitItems;
    }

    setReceived(hasReceiveInitItems: boolean) {
        this.hasReceiveInitItems = hasReceiveInitItems;
    }

    updateSid(sid: string) {
        this.sid = sid;
        this.isOnline = true;
    }

    leave() {
        this.isOnline = false;
    }
}

// 木牛流马
export class WoodenHorse {
    @prop({required: true})
    serverId: number = 0;               // 服务器id
    @prop({required: true})
    guildCode: string = "";             // 军团code 木马的唯一标识
    @prop({required: true})
    guildName: string = "";             // 军团名
    @prop({required: true})
    guildCe: number = 0;                // 军团战力
    @prop({required: true})
    status: number = 0;                 // 状态 0-停止 1-开启 2-结束
    @prop({required: true})
    speed: number = GUILDACTIVITY.RACE_INIT_SPEED; // 速度
    @prop({required: true})
    durability: number = 100;           // 耐久度
    @prop({required: true})
    distance: number = 0;               // 距离
    @prop({required: true})
    allStartTime: number = 0;              // 全服开启世界
    @prop({required: true})
    startTime: number = 0;              // 开始时间
    @prop({required: true})
    time: number = 0;                   // 到达时间
    @prop({required: true})
    memberCnt: number = 0;              // 成员人数
    @prop({required: true})
    members: WoodenHorseMember[] = [];  // 成员
    @prop({required: true})
    shield: number = 0;                 // 护盾数量
    @prop({required: true})
    shieldTime: number = 0;             // 天师盾符

    remainItems: Map<number, { total: number, max: number }> = new Map();
    isRobot: boolean = false;           // debug接口生成

    constructor(guildCode: string, guildName: string, guildCe: number, serverId: number, allStartTime: number, isRobot: boolean) {
        this.guildCode = guildCode;
        this.guildName = guildName;
        this.guildCe = guildCe;
        this.serverId = serverId;
        this.allStartTime = allStartTime;
        this.isRobot = isRobot;
    }

    public getTreatTime() {
        return {...this, time: this.time - this.allStartTime }
    }
}

export class Event {
    @prop({required: true})
    id: number;
    @prop({required: true})
    fromGuild: string;
    @prop({required: true})
    toGuild: string;
    @prop({required: true})
    startTime?: number;
    @prop({required: true})
    startDistance?: number;
    @prop({required: true})
    endTime?: number;
    @prop({required: true})
    endDistance?: number;
    @prop({required: true})
    count: number = 1;
    @prop({required: true})
    type: number = 0;      // 1-时间开启 2-距离开启


    constructor(id: number, fromGuild: string, toGuild: string, count: number = 0, distance: number = 0) {
        let dicEvent = gameData.raceActivityEvents.get(id);
        this.id = id;
        this.fromGuild = fromGuild;
        this.toGuild = toGuild;
        
        this.startDistance = distance;
        this.endDistance = this.startDistance + dicEvent.continueDistance;
        this.startTime = Date.now() + dicEvent.effectTime * 1000;
        this.endTime = this.startTime + dicEvent.continueTime * 1000;
        if(count) {
            this.count = count;
        }
        this.type = dicEvent.type;
    }

    setStartTime(time: number) {
        this.startTime = time;
    }

    needReCalHorse() {
        let importantEvents = [
            RACE_EVENT.LIANNU, // 连弩，可能durability突然变0
            RACE_EVENT.GUISHOUYINFU,  // 鬼手阴符
            RACE_EVENT.FENGCHE, // 风车
            RACE_EVENT.WUGUIBANYUNFU, // 五鬼搬运符
        ];
        return importantEvents.indexOf(this.id) != -1
    }

    useDistance() {
        return this.type == RACE_EVENT_TYPE.EVENT||this.type == RACE_EVENT_TYPE.ITEM;
    }

    useTime() {
        return this.type == RACE_EVENT_TYPE.DEFAULT;
    }
}

export interface GuildRankParams {
    guildRank: SimpleGuildRankParam[],
    myGuildRank: SimpleGuildRankParam,
    memberRank?: SimpleRoleRankParam[],
    myMemberRank?: SimpleRoleRankParam
}

export class Member {
    @prop({required: true})
    roleId: string;            // 玩家id
    @prop({required: true})
    job: number;             // 在军团的职位
    @prop({required: false})
    code?: string;             // 玩家的当前记录的code
    @prop({required: false})
    startActionTime?: number;             // 玩家的当前记录的code
}

export class JoinMember extends Member{
    @prop({required: true})
    roleName: string;            // 玩家名
}

export class CityParam {
    cityId: number = 0;   // 城池id
    guardGuildCode: string = ''; // 占领军团id
    guardGuildName: string = ''; // 占领军团名
    declareCount: number = 0; // 宣战数
    status: number = CITY_STATUS.NOT_OPEN;   // 城池对于我军状态

    constructor(cityId: number) {
        this.cityId = cityId;
    }
} 

export class RaceActivityRankParam {
    rank: number = 0;
    code: string;
    name: string;
    time: number;
    sortTime: number;
    sortDistance: number;
    num: number;
    durability: number;

    constructor(woodenHorse: WoodenHorse) {
        this.code = woodenHorse.guildCode;
        this.name = woodenHorse.guildName;
        this.durability = woodenHorse.durability;
        let distance = woodenHorse.distance > GUILDACTIVITY.RACEACTIVITY_LENGTH? GUILDACTIVITY.RACEACTIVITY_LENGTH: woodenHorse.distance;
        this.sortDistance = distance;
        this.sortTime = woodenHorse.time - woodenHorse.allStartTime;
        this.num = Math.floor(distance);
        this.time = Math.floor((woodenHorse.time - woodenHorse.allStartTime)/1000)
    }

    setRank(rank: number) {
        this.rank = rank;
    }
}

export class CityActivityData {
    public guildActivityStatus = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
    public gateHp: Map<string, number> = new Map(); // 城门血条，每个cityId有一条血条 serverId&cityId => gateHp
    public maxHp: Map<string, number> = new Map(); // 城门血条，每个cityId最大城门血量 serverId&cityId => gateHp
    public members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
    public cities: Map<string, string[]> = new Map(); // 各个城池参与的军团 serverId&cityId => [guildCode]
    public guilds: Map<string, number> = new Map();  // 军团所在的城池 guildCode => cityId
    public sentCity: string[] = [];
    public startTime: number = 0;
}

export class GateMembersRec {
    roleId: string;
    round: number = 0;
    enemies: number[] = [];
    constructor(roleId: string) {
        this.roleId = roleId;
    }
}

export class GateActivityData {
    public startTime: number;
    public members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
    public membersRecord: Map<string, GateMembersRec> = new Map(); // 每个成员的回合数和敌军数，防刷 recCode => GateMembersRec
    public guilds: Map<number, string[]> = new Map(); // 参加的所有军团 server => [guildCode]
}

export class MemberInfo extends Member {
    isQuit: boolean = false;

    constructor(roleId: string, job: number, code: string) {
        super();
        this.roleId = roleId;
        this.job = job;
        this.code = code;
    }

    public quit() {
        this.isQuit = true;
    }
}

export class GuildInfo {
    serverId: number;
    guildCode: string;
    isDissmiss: boolean = false;

    constructor(serverId: number, guildCode: string) {
        this.serverId = serverId;
        this.guildCode = guildCode;
    }

    dismiss() {
        this.isDissmiss = true;
    }
}

export class RaceActivityData {
    public status = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
    public allStartTime = 0; // 开启时间，每天晚上8点
    public guildList: GuildInfo[] = []; // 所有军团
    public members: Map<string, MemberInfo[]> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
    public woodenHorses: Map<string, WoodenHorse> = new Map(); // 每个军团的木牛流马 guildCode => WoodenHorse
    public events: Map<string, Event[]> = new Map(); // 每个军团遇到的事件
    public items: Map<string, RewardInter[]> = new Map(); // 每个玩家的道具 roleId => [{id, count}]
    public hasSentGuild: string[] = [];
}