import { must } from "@sammo/util";
import type { General } from "./General.js";
import type { IResourceController } from "./IResourceController.js";
import type { ITroopEntity } from "./Entity/TroopEntity.js";
import type { GeneralID } from "./defs.js";
import { LazyEntityUpdater } from "./LazyEntityUpdater.js";

export class Troop extends LazyEntityUpdater<ITroopEntity> {
    protected readonly _indirectNames: (keyof ITroopEntity)[] = ["id"];
    protected readonly _entityType = "Troop";
    protected readonly _raw: ITroopEntity;
    private _leader: WeakRef<General>;
    private _members: Map<GeneralID, WeakRef<General>>;

    constructor(
        raw: ITroopEntity,
        protected rsc: IResourceController
    ){
        super();
        this._raw = raw;

        const members = rsc.generalByTroop(raw.id);
        const leaderID: GeneralID = raw.id as GeneralID;
        this._leader = new WeakRef(must(members.get(leaderID)));
        members.delete(leaderID);
        this._members = new Map([...members].map(([k,v])=>[k, new WeakRef(v)]));
    }

    public get id(){
        return this._raw.id;
    }

    public get leader(){
        return must(this._leader.deref());
    }

    public get members(): Map<GeneralID, WeakRef<General>> {
        return this._members;
    }

    public destructTroop(withLeader = true){
        this._members.forEach((member)=>{
            const general = must(member.deref());
            general.quitTroop();
        });
        if(withLeader){
            this.leader.quitTroop();
        }

        this.rsc.reserveDelete(this);
    }

    public changeName(name: string){
        this.update((raw)=>{
            raw.name = name;
        });
    }

    //joinTroop은 General에서 처리
    //quitTroop은 General에서 처리
}