import { COUNTER, ROUGELIKE_SKILLTYPE } from '../consts';
import BaseModel from './BaseModel';
import { getModelForClass, prop, DocumentType, index } from '@typegoose/typegoose';
import { CounterModel } from './Counter';


export class Card {
    @prop({ required: false })
    index: number;    // 卡槽，没有那个index表示没有解锁
    @prop({ required: false })
    cardCode: string;  //卡唯一code,为空串表示没安装
    @prop({ required: false })
    cardId: number;   // 当为0的时候表示没有装入卡片
}

/**
 * 每场获得角色(普通角色和高级角色)
 */
@index({ roleId: 1 })
@index({ gameCode: 1 })
@index({ gameCode: 1, charaCode: 1 })

export default class RougelikeChara extends BaseModel {
    @prop({ required: true })
    roleId: string;      // 角色id

    @prop({ required: true, default: '' })
    gameCode: string;    // 场次唯一code

    @prop({ required: true, default: 0 })
    seqId: number;   // 角色卡排序

    @prop({ required: true, default: '' })
    charaCode: string;   // 角色卡唯一id

    @prop({ required: true, default: 0 })
    charaId: number;     // 角色卡id

    @prop({ required: true, type: Card, default: [], _id: false })
    cards: Card[];

    @prop({ required: true, default: 0 })
    hp: number;           // 当前hp

    @prop({ required: true, default: 0 })
    maxHp: number;           // 最大hp

    @prop({ required: true, default: 0 })
    ap: number;        // 当前怒气

    @prop({ required: true, default: 0 })
    shield: number;        // 盾

    @prop({ required: true, default: 0 })
    others: string;        // 盾其他数据

    @prop({ required: true, default: 0 })
    roundSkill: number;   // 玩家选择的回合技能卡

    @prop({ required: true, default: 0 })
    apSkill: number;   // 玩家选择的怒气技能卡

    @prop({ required: true, default: 0 })
    getLayer: number;     // 在哪一层获得的

    @prop({ required: true, default: 0 })
    getWay: number;       // 在做什么的时候获得的


    public static async createCharas(updateArr: RougelikeCharaPara[]) {
        if (updateArr.length == 0) return [];
        let num = await CounterModel.getNewCounterNum(COUNTER.ROUGE_CHARA, updateArr.length);
        let resultArr: RougelikeCharaType[] = [];
        for (let index = 0; index < updateArr.length; index++) {
            let param = updateArr[index];
            let seqId = num - updateArr.length + index + 1;
            const { gameCode, charaCode } = param;
            let data = await RougelikeCharaModel.findOneAndUpdate({ gameCode, charaCode }, { $set: { ...param, seqId } }, { new: true, upsert: true }).lean();
            if (data) resultArr.push(data)
        }
        return resultArr
    }

    public static async updateByCode(gameCode: string, charaCode: string, params: { $set: RougelikeCharaPara }, lean = true) {
        const result: RougelikeCharaType = await RougelikeCharaModel.findOneAndUpdate({ gameCode, charaCode }, params, { new: true }).lean(lean);
        return result;
    }


    public static async findByGameCode(gameCode: string, lean = true) {
        const result: RougelikeCharaType[] = await RougelikeCharaModel.find({ gameCode }).lean(lean);
        return result;
    }


    public static async findByCode(gameCode: string, charaCode: string, lean = true) {
        const result: RougelikeCharaType = await RougelikeCharaModel.findOne({ gameCode, charaCode }).lean(lean);
        return result;
    }

    public static async findByCodes(gameCode: string, charaCodes: string[], lean = true) {
        const result: RougelikeCharaType[] = await RougelikeCharaModel.find({ gameCode, charaCode: { $in: charaCodes } }).lean(lean);
        return result;
    }

    public static async putOnOrOffSkillCard(gameCode: string, charaCode: string, skillType: ROUGELIKE_SKILLTYPE, id: number) {
        if (skillType == ROUGELIKE_SKILLTYPE.AP) {
            const result: RougelikeCharaType = await RougelikeCharaModel.findOneAndUpdate({ gameCode, charaCode }, { $set: { apSkill: id } }, { new: true }).lean();
            return result;
        } else {
            const result: RougelikeCharaType = await RougelikeCharaModel.findOneAndUpdate({ gameCode, charaCode }, { $set: { roundSkill: id } }, { new: true }).lean();
            return result;
        }
    }

    public static async findByGameCodeAndCharaId(gameCode: string, charaId: number, lean = true) {
        const result: RougelikeCharaType[] = await RougelikeCharaModel.find({ gameCode, charaId }).lean(lean);
        return result;
    }

    public static async bulkWriteUpdate(updateArr: RougelikeCharaPara[]) {
        if (updateArr.length == 0) return;
        await RougelikeCharaModel.bulkWrite(updateArr.map((param) => {
            delete param._id;
            const { gameCode, charaCode } = param
            return { updateOne: { filter: { gameCode, charaCode }, update: { $set: { ...param } }, upsert: true } }
        }))
    }

    public static async deleteCharaByRoleId(roleId: string) {
        let result = await RougelikeCharaModel.deleteMany({ roleId });
        return result;
    }


};
export const RougelikeCharaModel = getModelForClass(RougelikeChara);
export interface RougelikeCharaType extends Pick<DocumentType<RougelikeChara>, keyof RougelikeChara> { };
export type RougelikeCharaPara = Partial<RougelikeCharaType>; // 将所有字段变成可选项