import SelectDialog from '../dialogs/selectDialog.mjs';
import { getTier } from '../helpers/utils.mjs';
import DhpMulticlassDialog from './multiclassDialog.mjs';

const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;

export default class DhpLevelup extends HandlebarsApplicationMixin(ApplicationV2) {
    constructor(actor) {
        super({});

        this.actor = actor;
        this.data = foundry.utils.deepClone(actor.system.levelData);
        this.activeLevel = actor.system.levelData.currentLevel + 1;
    }

    get title() {
        return `${this.actor.name} - Level Up`;
    }

    static DEFAULT_OPTIONS = {
        id: 'daggerheart-levelup',
        classes: ['daggerheart', 'views', 'levelup'],
        position: { width: 1200, height: 'auto' },
        window: {
            resizable: true
        },

        actions: {
            toggleBox: this.toggleBox,
            advanceLevel: this.advanceLevel,
            finishLevelup: this.finishLevelup
        }
    };

    static PARTS = {
        form: {
            id: 'levelup',
            template: 'systems/daggerheart/templates/views/levelup.hbs'
        }
    };

    async _prepareContext(_options) {
        let selectedChoices = 0,
            multiclassing = {},
            subclassing = {};
        const leveledTiers = Object.keys(this.data.levelups).reduce(
            (acc, levelKey) => {
                const levelData = this.data.levelups[levelKey];
                ['tier1', 'tier2', 'tier3'].forEach(tierKey => {
                    let tierUpdate = {};
                    const tierData = levelData[tierKey];
                    if (tierData) {
                        tierUpdate = Object.keys(tierData).reduce((acc, propertyKey) => {
                            const values = tierData[propertyKey];
                            const level = Number.parseInt(levelKey);

                            acc[propertyKey] = Object.values(values).map(value => {
                                if (value && level === this.activeLevel) selectedChoices++;
                                if (propertyKey === 'multiclass') multiclassing[levelKey] = true;
                                if (propertyKey === 'subclass') subclassing[tierKey] = true;

                                return { level: level, value: value };
                            });

                            return acc;
                        }, {});
                    }

                    Object.keys(tierUpdate).forEach(propertyKey => {
                        const property = tierUpdate[propertyKey];
                        const propertyValues = foundry.utils.getProperty(acc, `${tierKey}.${propertyKey}`) ?? [];
                        foundry.utils.setProperty(acc, `${tierKey}.${propertyKey}`, [...propertyValues, ...property]);
                    });
                });

                return acc;
            },
            { tier1: {}, tier2: {}, tier3: {} }
        );

        const activeTier = getTier(this.activeLevel);
        const data = Object.keys(SYSTEM.ACTOR.levelupData).reduce((acc, tierKey) => {
            const tier = SYSTEM.ACTOR.levelupData[tierKey];
            acc[tierKey] = {
                label: game.i18n.localize(tier.label),
                info: game.i18n.localize(tier.info),
                pretext: game.i18n.localize(tier.pretext),
                postext: game.i18n.localize(tier.posttext),
                active: tierKey <= activeTier,
                choices: Object.keys(tier.choices).reduce((acc, propertyKey) => {
                    const property = tier.choices[propertyKey];
                    acc[propertyKey] = { description: property.description, cost: property.cost ?? 1, values: [] };
                    for (var i = 0; i < property.maxChoices; i++) {
                        const leveledValue = leveledTiers[tierKey][propertyKey]?.[i];
                        const subclassLock =
                            propertyKey === 'subclass' &&
                            Object.keys(multiclassing).find(x => getTier(Number.parseInt(x)) === tierKey);
                        const subclassMulticlassLock = propertyKey === 'multiclass' && subclassing[tierKey];
                        const multiclassLock =
                            propertyKey === 'multiclass' &&
                            Object.keys(multiclassing).length > 0 &&
                            !(
                                leveledValue &&
                                Object.keys(multiclassing).find(x => Number.parseInt(x) === leveledValue.level)
                            );
                        const locked =
                            (leveledValue && leveledValue.level !== this.activeLevel) ||
                            subclassLock ||
                            subclassMulticlassLock ||
                            multiclassLock;
                        const disabled =
                            tierKey > activeTier ||
                            (selectedChoices === 2 && !(leveledValue && leveledValue.level === this.activeLevel)) ||
                            locked;

                        acc[propertyKey].values.push({
                            selected: leveledValue?.value !== undefined,
                            path: `levelups.${this.activeLevel}.${tierKey}.${propertyKey}.${i}`,
                            description: game.i18n.localize(property.description),
                            disabled: disabled,
                            locked: locked
                        });
                    }

                    return acc;
                }, {})
            };

            return acc;
        }, {});

        return {
            data: data,
            activeLevel: this.activeLevel,
            changedLevel: this.actor.system.levelData.changedLevel,
            completedSelection: selectedChoices === 2
        };
    }

    static async toggleBox(_, button) {
        const path = button.dataset.path;
        if (foundry.utils.getProperty(this.data, path)) {
            const pathParts = path.split('.');
            const arrayPart = pathParts.slice(0, pathParts.length - 1).join('.');
            let array = foundry.utils.getProperty(this.data, arrayPart);
            if (button.dataset.levelAttribute === 'multiclass') {
                array = [];
            } else {
                delete array[Number.parseInt(pathParts[pathParts.length - 1])];
            }
            foundry.utils.setProperty(this.data, arrayPart, array);
        } else {
            const updates = [{ path: path, value: { level: this.activeLevel } }];
            const levelChoices = SYSTEM.ACTOR.levelChoices[button.dataset.levelAttribute];
            if (button.dataset.levelAttribute === 'subclass') {
                if (!this.actor.system.multiclassSubclass) {
                    updates[0].value.value = {
                        multiclass: false,
                        feature: this.actor.system.subclass.system.specializationFeature.unlocked
                            ? 'mastery'
                            : 'specialization'
                    };
                } else {
                    const choices = [
                        { name: this.actor.system.subclass.name, value: this.actor.system.subclass.uuid },
                        {
                            name: this.actor.system.multiclassSubclass.name,
                            value: this.actor.system.multiclassSubclass.uuid
                        }
                    ];
                    const indexes = await SelectDialog.selectItem({
                        actor: this.actor,
                        choices: choices,
                        title: levelChoices.title,
                        nrChoices: 1
                    });
                    if (indexes.length === 0) {
                        this.render();
                        return;
                    }
                    const multiclassSubclass = choices[indexes[0]].name === this.actor.system.multiclassSubclass.name;
                    updates[0].value.value = {
                        multiclass: multiclassSubclass,
                        feature: this.actor.system.multiclassSubclass.system.specializationFeature.unlocked
                            ? 'mastery'
                            : 'specialization'
                    };
                }
            } else if (button.dataset.levelAttribute === 'multiclass') {
                const multiclassAwait = new Promise(resolve => {
                    new DhpMulticlassDialog(this.actor.name, this.actor.system.class, resolve).render(true);
                });
                const multiclassData = await multiclassAwait;
                if (!multiclassData) {
                    this.render();
                    return;
                }

                const pathParts = path.split('.');
                const arrayPart = pathParts.slice(0, pathParts.length - 1).join('.');
                updates[0] = {
                    path: [arrayPart, '0'].join('.'),
                    value: {
                        level: this.activeLevel,
                        value: {
                            class: multiclassData.class,
                            subclass: multiclassData.subclass,
                            domain: multiclassData.domain,
                            level: this.activeLevel
                        }
                    }
                };
                updates[1] = {
                    path: [arrayPart, '1'].join('.'),
                    value: {
                        level: this.activeLevel,
                        value: {
                            class: multiclassData.class,
                            subclass: multiclassData.subclass,
                            domain: multiclassData.domain,
                            level: this.activeLevel
                        }
                    }
                };
            } else {
                if (levelChoices.choices.length > 0) {
                    if (typeof levelChoices.choices === 'string') {
                        const choices = foundry.utils
                            .getProperty(this.actor, levelChoices.choices)
                            .map(x => ({ name: x.description, value: x.id }));
                        const indexes = await SelectDialog.selectItem({
                            actor: this.actor,
                            choices: choices,
                            title: levelChoices.title,
                            nrChoices: levelChoices.nrChoices
                        });
                        if (indexes.length === 0) {
                            this.render();
                            return;
                        }
                        updates[0].value.value = choices
                            .filter((_, index) => indexes.includes(index))
                            .map(x => x.value);
                    } else {
                        const indexes = await SelectDialog.selectItem({
                            actor: this.actor,
                            choices: levelChoices.choices,
                            title: levelChoices.title,
                            nrChoices: levelChoices.nrChoices
                        });
                        if (indexes.length === 0) {
                            this.render();
                            return;
                        }
                        updates[0].value.value = levelChoices.choices[indexes[0]].path;
                    }
                }
            }

            const update = updates.reduce((acc, x) => {
                acc[x.path] = x.value;

                return acc;
            }, {});

            this.data = foundry.utils.mergeObject(this.data, update);
        }

        this.render();
    }

    static advanceLevel() {
        this.activeLevel += 1;
        this.render();
    }

    static async finishLevelup() {
        this.data.currentLevel = this.data.changedLevel;
        let multiclass = null;
        for (var level in this.data.levelups) {
            for (var tier in this.data.levelups[level]) {
                for (var category in this.data.levelups[level][tier]) {
                    for (var value in this.data.levelups[level][tier][category]) {
                        if (category === 'multiclass') {
                            multiclass = this.data.levelups[level][tier][category][value].value;
                            this.data.levelups[level][tier][category][value] = true;
                        } else {
                            this.data.levelups[level][tier][category][value] =
                                this.data.levelups[level][tier][category][value].value ?? true;
                        }
                    }
                }
            }
        }

        const tiersMoved =
            getTier(this.actor.system.levelData.changedLevel, true) -
            getTier(this.actor.system.levelData.currentLevel, true);
        const experiences = Array.from(Array(tiersMoved), (_, index) => ({
            id: foundry.utils.randomID(),
            level: this.actor.system.experiences.length + index * 3,
            description: '',
            value: 1
        }));

        await this.actor.update(
            {
                system: {
                    levelData: this.data,
                    experiences: [...this.actor.system.experiences, ...experiences]
                }
            },
            { diff: false }
        );

        if (!this.actor.multiclass && multiclass) {
            const multiclassClass = (await fromUuid(multiclass.class.uuid)).toObject();
            multiclassClass.system.domains = [multiclass.domain.id];
            multiclassClass.system.multiclass = multiclass.level;

            const multiclassFeatures = [];
            for (var i = 0; i < multiclassClass.system.features.length; i++) {
                const feature = (await fromUuid(multiclassClass.system.features[i].uuid)).toObject();
                feature.system.multiclass = multiclass.level;
                multiclassFeatures.push(feature);
            }

            const multiclassSubclass = (await fromUuid(multiclass.subclass.uuid)).toObject();
            multiclassSubclass.system.multiclass = multiclass.level;

            const multiclassSubclassFeatures = {};
            const features = [
                multiclassSubclass.system.foundationFeature,
                multiclassSubclass.system.specializationFeature,
                multiclassSubclass.system.masteryFeature
            ];
            for (var i = 0; i < features.length; i++) {
                const path = i === 0 ? 'foundationFeature' : i === 1 ? 'specializationFeature' : 'masteryFeature';
                const feature = features[i];
                for (var ability of feature.abilities) {
                    const data = (await fromUuid(ability.uuid)).toObject();
                    if (i > 0) data.system.disabled = true;
                    data.system.multiclass = multiclass.level;
                    if (!multiclassSubclassFeatures[path]) multiclassSubclassFeatures[path] = [data];
                    else multiclassSubclassFeatures[path].push(data);
                    // data.uuid = feature.uuid;

                    // const abilityData = await this._onDropItemCreate(data);
                    // ability.uuid = abilityData[0].uuid;

                    // createdItems.push(abilityData);
                }
            }

            for (let subclassFeaturesKey in multiclassSubclassFeatures) {
                const values = multiclassSubclassFeatures[subclassFeaturesKey];
                const abilityResults = await this.actor.createEmbeddedDocuments('Item', values);
                for (var i = 0; i < abilityResults.length; i++) {
                    multiclassSubclass.system[subclassFeaturesKey].abilities[i].uuid = abilityResults[i].uuid;
                }
            }

            await this.actor.createEmbeddedDocuments('Item', [
                multiclassClass,
                ...multiclassFeatures,
                multiclassSubclass
            ]);
        }

        this.close();
    }
}