import BaseModel from './BaseModel';
import { getModelForClass, prop, DocumentType, index } from '@typegoose/typegoose';


export class Circle {
    @prop({ required: true, default: 0 })
    techId: number; // 科技点

    @prop({ required: true, default: 0 })
    circleId: number; // 法阵的索引

    @prop({ required: true, default: 0 })
    hid: number;   // 玩家放上的武将

    @prop({ required: true, default: 0 })
    ce: number;    // 武将的战力

    constructor(techId: number, circleId: number) {
        this.techId = techId;
        this.circleId = circleId;
        this.hid = 0;
        this.ce = 0;
    }
}


@index({ roleId: 1 })
export default class RougelikeTech extends BaseModel {
    @prop({ required: true })
    roleId: string;

    @prop({ required: true, default: 0 })
    techScore: number;        // 获得了的总科技点   

    @prop({ required: true, type: Number, default: [], _id: false })
    unlockedTech: number[];    // 科技点id

    @prop({ required: true, type: Circle, _id: false, default: [] })
    circles: Circle[]        // 法阵

    @prop({ required: true, type: Number, default: [], _id: false })
    effectIds: number[];    // 科技点id

    // 查询
    public static async findByRoleId(roleId: string, select = '') {
        const result: RougelikeTechType = await RougelikeTechModel.findOne({ roleId }).select(select).lean();
        return result;
    }

    // 增加
    public static async increaseScore(roleId: string, techScore: number) {
        let result: RougelikeTechType = await RougelikeTechModel.findOneAndUpdate({ roleId }, { $setOnInsert: { unlockedTech: [], circles: [] }, $inc: { techScore } }, { new: true, upsert: true }).lean();
        return result;
    }

    // 解锁科技点
    public static async unlockTech(roleId: string, techId: number, circleIds: number[]) {
        let circles = circleIds.map(circleId => new Circle(techId, circleId));
        let result: RougelikeTechType = await RougelikeTechModel.findOneAndUpdate({ roleId }, { $push: { unlockedTech: techId, circles: { $each: circles } } }, { new: true, upsert: true }).lean();
        return result;
    }

    // 法阵放武将
    public static async putOnCircle(roleId: string, circleId: number, hid: number, ce: number) {
        if(hid > 0) await this.putOffCircle(roleId, hid);
        let result: RougelikeTechType = await RougelikeTechModel.findOneAndUpdate({ roleId, 'circles.circleId': circleId }, { $set: { 'circles.$.hid': hid, 'circles.$.ce': ce } }, { new: true }).lean();
        return result;
    }

    // 法阵撤下
    public static async putOffCircle(roleId: string, hid: number) {
        let result: RougelikeTechType = await RougelikeTechModel.findOneAndUpdate({ roleId, 'circles.hid': hid }, { $set: { 'circles.$.hid': 0, 'circles.$.ce': 0 } }, { new: true }).lean();
        return result;
    }

    public static async updateEffectId(roleId: string, effectIds: number[]) {
        let result: RougelikeTechType = await RougelikeTechModel.findOneAndUpdate({ roleId }, { $set: { effectIds } }, { new: true }).lean();
        return result;
    }

    // 更新武将战力
    public static async updateCircle(roleId: string, circles: Circle[], effectIds: number[]) {
        let result: RougelikeTechType = await RougelikeTechModel.findOneAndUpdate({ roleId }, { $set: { circles, effectIds } }, { new: true }).lean();
        return result;
    }

    // 清空科技树
    public static async clearTech(roleId: string) {
        await RougelikeTechModel.deleteMany({ roleId });
    }
}

export const RougelikeTechModel = getModelForClass(RougelikeTech);
export interface RougelikeTechType extends Pick<DocumentType<RougelikeTech>, keyof RougelikeTech> { };
export type RougelikeTechPara = Partial<RougelikeTechType>; // 将所有字段变成可选项