import { ModifiableDataTotal } from "../common/common-data";
import { DS4 } from "../config";
import { DS4Item } from "../item/item";
import { ItemType } from "../item/item-data";
import { DS4ActorData } from "./actor-data";

/**
 * The Actor class for DS4
 */
export class DS4Actor extends Actor<DS4ActorData, DS4Item> {
    /** @override */
    prepareData(): void {
        this.data = duplicate(this._data) as DS4ActorData;
        if (!this.data.img) this.data.img = CONST.DEFAULT_TOKEN;
        if (!this.data.name) this.data.name = "New " + this.entity;
        this.prepareBaseData();
        this.prepareEmbeddedEntities();
        this.applyActiveEffectsToBaseData();
        this.prepareDerivedData();
        this.applyActiveEffectsToDerivedData();
        this.prepareFinalDerivedData();
    }

    /** @override */
    prepareBaseData(): void {
        const data = this.data;

        data.data.rolling = {
            minimumFumbleResult: 20,
            maximumCoupResult: 1,
        };

        const attributes = data.data.attributes;
        Object.values(attributes).forEach(
            (attribute: ModifiableDataTotal<number>) => (attribute.total = attribute.base + attribute.mod),
        );

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

    applyActiveEffectsToBaseData(): void {
        // reset overrides because our variant of applying active effects does not set them, it only adds overrides
        this.overrides = {};
        this.applyActiveEffectsFiltered(
            (change) =>
                !this.derivedDataProperties.includes(change.key) &&
                !this.finalDerivedDataProperties.includes(change.key),
        );
    }

    applyActiveEffectsToDerivedData(): void {
        this.applyActiveEffectsFiltered((change) => this.derivedDataProperties.includes(change.key));
    }

    /**
     * Apply ActiveEffectChanges to the Actor data which are caused by ActiveEffects and satisfy the given predicate.
     *
     * @param predicate - The predicate that ActiveEffectChanges need to satisfy in order to be applied
     */
    applyActiveEffectsFiltered(predicate: (change: ActiveEffectChange) => boolean): void {
        const overrides: Record<string, unknown> = {};

        // Organize non-disabled effects by their application priority
        const changes = this.effects.reduce(
            (changes: Array<ActiveEffectChange & { effect: ActiveEffect<DS4Actor> }>, e) => {
                if (e.data.disabled) return changes;
                const item = this._getOriginatingItemOfActiveEffect(e);
                if (item?.isNonEquippedEuipable()) return changes;

                const factor = item?.activeEffectFactor ?? 1;

                return changes.concat(
                    e.data.changes.filter(predicate).flatMap((c) => {
                        const duplicatedChange = duplicate(c) as ActiveEffect.Change;
                        duplicatedChange.priority = duplicatedChange.priority ?? duplicatedChange.mode * 10;
                        return Array(factor).fill({
                            ...duplicatedChange,
                            effect: e,
                        });
                    }),
                );
            },
            [],
        );
        changes.sort((a, b) => a.priority - b.priority);

        // Apply all changes
        for (const change of changes) {
            const result = change.effect.apply(this, change);
            if (result !== null) overrides[change.key] = result;
        }

        // Expand the set of final overrides
        this.overrides = expandObject({ ...flattenObject(this.overrides), ...overrides });
    }

    protected _getOriginatingItemOfActiveEffect(effect: ActiveEffect<DS4Actor>): DS4Item | undefined {
        return this.items.find((item) => item.uuid === effect.data.origin) ?? undefined;
    }

    /**
     * Apply transformations to the Actor data after effects have been applied to the base data.
     * @override
     */
    prepareDerivedData(): void {
        this._prepareCombatValues();
    }

    /**
     * The list of properties that are derived from others, given in dot notation.
     */
    get derivedDataProperties(): Array<string> {
        return Object.keys(DS4.i18n.combatValues).map((combatValue) => `data.combatValues.${combatValue}.total`);
    }

    /**
     * Apply final transformations to the Actor data after all effects have been applied.
     */
    prepareFinalDerivedData(): void {
        this.data.data.combatValues.hitPoints.max = this.data.data.combatValues.hitPoints.total;
    }

    /**
     * The list of properties that are completely derived (i.e. {@link ActiveEffect}s cannot be applied to them),
     * given in dot notation.
     */
    get finalDerivedDataProperties(): string[] {
        return ["data.combatValues.hitPoints.max"];
    }

    /**
     * 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",
                    "equipment",
                    "loot",
                    "spell",
                    "talent",
                    "racialAbility",
                    "language",
                    "alphabet",
                ];
            case "creature":
                return ["weapon", "armor", "shield", "equipment", "loot", "spell", "specialCreatureAbility"];
            default:
                return [];
        }
    }

    /**
     * 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);
    }

    /**
     *  Prepares the combat values of the actor.
     */
    protected _prepareCombatValues(): void {
        const data = this.data.data;
        const armorValueOfEquippedItems = this._calculateArmorValueOfEquippedItems();

        data.combatValues.hitPoints.base =
            (data.attributes.body.total ?? 0) + (data.traits.constitution.total ?? 0) + 10;
        data.combatValues.defense.base =
            (data.attributes.body.total ?? 0) + (data.traits.constitution.total ?? 0) + armorValueOfEquippedItems;
        data.combatValues.initiative.base = (data.attributes.mobility.total ?? 0) + (data.traits.agility.total ?? 0);
        data.combatValues.movement.base = (data.attributes.mobility.total ?? 0) / 2 + 1;
        data.combatValues.meleeAttack.base = (data.attributes.body.total ?? 0) + (data.traits.strength.total ?? 0);
        data.combatValues.rangedAttack.base =
            (data.attributes.mobility.total ?? 0) + (data.traits.dexterity.total ?? 0);
        data.combatValues.spellcasting.base =
            (data.attributes.mind.total ?? 0) + (data.traits.aura.total ?? 0) - armorValueOfEquippedItems;
        data.combatValues.targetedSpellcasting.base =
            (data.attributes.mind.total ?? 0) + (data.traits.dexterity.total ?? 0) - armorValueOfEquippedItems;

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

    /**
     * Calculates the total armor value of all equipped items.
     */
    protected _calculateArmorValueOfEquippedItems(): number {
        return this.items
            .map((item) => {
                if (item.data.type === "armor" || item.data.type === "shield") {
                    return item.data.data.equipped ? item.data.data.armorValue : 0;
                } else {
                    return 0;
                }
            })
            .reduce((a, b) => a + b, 0);
    }

    /**
     * Handle how changes to a Token attribute bar are applied to the Actor.
     * This only differs from the base implementation by also allowing negative values.
     * @override
     */
    async modifyTokenAttribute(attribute: string, value: number, isDelta = false, isBar = true): Promise<this> {
        const current = getProperty(this.data.data, attribute);

        // Determine the updates to make to the actor data
        let updates: Record<string, number>;
        if (isBar) {
            if (isDelta) value = Math.min(Number(current.value) + value, current.max);
            updates = { [`data.${attribute}.value`]: value };
        } else {
            if (isDelta) value = Number(current) + value;
            updates = { [`data.${attribute}`]: value };
        }

        // Call a hook to handle token resource bar updates
        const allowed = Hooks.call("modifyTokenAttribute", { attribute, value, isDelta, isBar }, updates);
        return allowed !== false ? this.update(updates) : this;
    }
}