import { ModifiableData } from "../common/common-data";
import { DS4Item } from "../item/item";
import { DS4ItemDataType, ItemType } from "../item/item-data";
import { DS4ActorDataType } from "./actor-data";

export class DS4Actor extends Actor<DS4ActorDataType, DS4ItemDataType, DS4Item> {
    /** @override */
    prepareDerivedData(): void {
        const data = this.data;
        const attributes = data.data.attributes;
        Object.values(attributes).forEach(
            (attribute: ModifiableData<number>) => (attribute.total = attribute.base + attribute.mod),
        );

        const traits = data.data.traits;
        Object.values(traits).forEach((trait: ModifiableData<number>) => (trait.total = trait.base + trait.mod));

        const combatValues = data.data.combatValues;
        Object.values(combatValues).forEach(
            (combatValue: ModifiableData<number>) => (combatValue.total = combatValue.base + combatValue.mod),
        );

        combatValues.hitPoints.max = combatValues.hitPoints.total;
    }

    /**
     * The list of item types that can be owned by this actor.
     */
    get ownableItemTypes(): Array<ItemType> {
        switch (this.data.type) {
            case "character":
                return [
                    "weapon",
                    "armor",
                    "shield",
                    "spell",
                    "trinket",
                    "equipment",
                    "talent",
                    "racialAbility",
                    "language",
                    "alphabet",
                ];
            case "creature":
                return ["weapon", "armor", "spell", "specialCreatureAbility"];
            default:
                [];
        }
    }

    /**
     * Checks whether or not the given item type can be owned by the actor.
     * @param itemType the item type to check
     */
    canOwnItemType(itemType: ItemType): boolean {
        return this.ownableItemTypes.includes(itemType);
    }
}