export class CharacterSheet extends ActorSheet {
    /**@override */
    static get defaultOptions() {
        return foundry.utils.mergeObject(super.defaultOptions, {
            classes: ['dsa41', 'sheet', 'actor', 'character'],
            width: 520,
            height: 480,
            tabs: [
                {
                    navSelector: '.sheet-tabs',
                    contentSelector: '.sheet-body',
                    initial: 'description',
                },
            ],
        });
    }

    /** @override */
    get template() {
        return `systems/DSA_4-1/templates/actor/actor-character-sheet.hbs`;
    }

    /** @override */
    getData() {
        // Retrieve the data structure from the base sheet. You can inspect or log
        // the context variable to see the structure, but some key properties for
        // sheets are the actor object, the data object, whether or not it's
        // editable, the items array, and the effects array.
        const context = super.getData();

        // Use a safe clone of the actor data for further operations.
        const actorData = context.data;

        // Add the actor's data to context.data for easier access, as well as flags.
        context.system = actorData.system;
        context.flags = actorData.flags;
        context.attributes = [
            {
                eigenschaft: "mu",
                name: "MU",
                tooltip: "Mut",
                wert: actorData.system.attribute.mu ?? 0,
            },
            {
                eigenschaft: "kl",
                name: "KL",
                tooltip: "Klugheit",
                wert: actorData.system.attribute.kl ?? 0,
            },
            {
                eigenschaft: "in",
                name: "IN",
                tooltip: "Intuition",
                wert: actorData.system.attribute.in ?? 0,
            },
            {
                eigenschaft: "ch",
                name: "CH", tooltip: "Charisma",
                wert: actorData.system.attribute.ch ?? 0,
            },
            {
                eigenschaft: "ff",
                name: "FF",
                tooltip: "Fingerfertigkeit",
                wert: actorData.system.attribute.ff ?? 0,
            },
            {
                eigenschaft: "ge",
                name: "GE",
                tooltip: "Geschicklichkeit",
                wert: actorData.system.attribute.ge ?? 0,
            },
            {
                eigenschaft: "ko",
                name: "KO",
                tooltip: "Konstitution",
                wert: actorData.system.attribute.ko ?? 0,
            },
            {
                eigenschaft: "kk",
                name: "KK",
                tooltip: "Körperkraft",
                wert: actorData.system.attribute.kk ?? 0,
            },

        ];
        context.skills = {};
        if ( context.system.talente?.length >= 0) {
            context.system.talente.forEach(talent => {
                const taw = talent.taw;
                console.log(taw);
                const talentObjekt = game.items.get(talent.talent);
                const talentGruppe = talentObjekt.system.gruppe;
                const eigenschaften = Object.values(talentObjekt.system.probe);
                const werte = [
                    {name: eigenschaften[0], value: this.prepareEigenschaftRoll(actorData, eigenschaften[0])},
                        {name: eigenschaften[1], value: this.prepareEigenschaftRoll(actorData, eigenschaften[1])},
                        {name: eigenschaften[2], value: this.prepareEigenschaftRoll(actorData, eigenschaften[2])}
                ]

                if(context.skills[talentGruppe] == null) {
                    context.skills[talentGruppe] = [];
                }

                context.skills[talentGruppe].push({
                    type: "talent",
                    gruppe: talentGruppe,
                    name: talentObjekt.name,
                    taw: ""+taw,
                    werte,
                    rollEigenschaft1: werte[0].value,
                    rollEigenschaft2: werte[1].value,
                    rollEigenschaft3: werte[2].value,
                    probe: `(${eigenschaften.join("/")})`
                });

            })
        }
        return context;
    }

    prepareEigenschaftRoll(actorData, name) {
        return actorData.system.attribute[name.toLowerCase()]
    }

    async _onTalentRoll(event) {
        event.preventDefault();
        const dataset = event.currentTarget.dataset;
        console.log(dataset)
        if (dataset.rolleigenschaft1) {
            let roll1 = new Roll("3d20", this.actor.getRollData());

            let evaluated1 = (await roll1.evaluate())

            const dsaDieRollEvaluated = this._evaluateRoll(evaluated1.terms[0].results, {
                taw: dataset.taw,
                werte: [dataset.rolleigenschaft1, dataset.rolleigenschaft2, dataset.rolleigenschaft3],
            })

            if (dsaDieRollEvaluated.tap >= 0) { // erfolg
                evaluated1.toMessage({
                    speaker: ChatMessage.getSpeaker({actor: this.actor}),
                    flavor: ` ${dsaDieRollEvaluated.meisterlich?'Meisterlich geschafft':'Geschafft'} mit ${dsaDieRollEvaluated.tap} Punkten übrig`,
                    rollMode: game.settings.get('core', 'rollMode'),
                })
            } else { // misserfolg
                evaluated1.toMessage({
                    speaker: ChatMessage.getSpeaker({actor: this.actor}),
                    flavor: ` ${dsaDieRollEvaluated.meisterlich?'Gepatzt':''} mit ${Math.abs(dsaDieRollEvaluated.tap)} Punkten daneben`,
                    rollMode: game.settings.get('core', 'rollMode'),
                })
            }


        }
    }

    _evaluateRoll(rolledDice, { taw, lowerThreshold = 1, upperThreshold = 20, countToMeisterlich = 3, countToPatzer = 3, werte = [] } ) {
        let tap = taw;
        let meisterlichCounter = 0;
        let patzerCounter = 0;
        let failCounter = 0;

        rolledDice.forEach( (rolledDie, index) => {
            if (tap < 0 && rolledDie.result > werte[index]) {
                tap -= rolledDie.result - werte[index];
                if (tap <0) { // konnte nicht vollständig ausgeglichen werden
                    failCounter++;
                }
            } else if (rolledDie.result > werte[index]) { // taw ist bereits aufgebraucht und wert kann nicht ausgeglichen werden
                tap -= rolledDie.result - werte[index];
                failCounter++;
            }
            if (rolledDie.result <= lowerThreshold) meisterlichCounter++;
            if (rolledDie.result > upperThreshold) patzerCounter++;
        })

        return {
            tap,
            meisterlich: meisterlichCounter === countToMeisterlich,
            patzer: patzerCounter === countToPatzer,
        }
    }

    _onAttributeRoll(event) {
        event.preventDefault();
        const dataset = event.currentTarget.dataset;
        if (dataset.roll) {
            let label = dataset.label ? `[Attribut] ${dataset.label}` : '';
            let roll = new Roll(dataset.roll, this.actor.getRollData());
            roll.toMessage({
                speaker: ChatMessage.getSpeaker({ actor: this.actor }),
                flavor: label,
                rollMode: game.settings.get('core', 'rollMode'),
            });
            return roll;
        }
    }

    activateListeners(html) {
        super.activateListeners(html);

        html.on('click', '.attribut.rollable', (evt) => {
            console.log(evt);
            this._onAttributeRoll(evt);
        });

        html.on('click', '.talent.rollable', (evt) => {
            console.log(evt);
            this._onTalentRoll(evt);
        });

        // Everything below here is only needed if the sheet is editable
        if (!this.isEditable) return;

    }

}