const { TypeDataModel }                                       = foundry.abstract;
const { ApplicationV2, HandlebarsApplicationMixin }           = foundry.applications.api;
const { DocumentSheetConfig }                                 = foundry.applications.apps;
const { loadTemplates, renderTemplate }                       = foundry.applications.handlebars;
const { ActorSheetV2, ItemSheetV2 }                           = foundry.applications.sheets;
const { Notifications }                                       = foundry.applications.ui;
const { SetField, SchemaField, NumberField, StringField, BooleanField } = foundry.data.fields;
const { Roll }                                                = foundry.dice;
const { OperatorTerm, NumericTerm }                           = foundry.dice.terms;
const { ChatMessage }                                         = foundry.documents;

Hooks.once("i18nInit", async function() {
    const lang = game.i18n.lang;

    await game.i18n.setLanguage("de");
    const fallback = game.i18n.translations;
    await game.i18n.setLanguage(lang);

    game.i18n._fallback = foundry.utils.mergeObject(fallback, game.i18n._fallback);
});

class DSA41_Notifications extends Notifications {
    notify(message, type="info", {localize=false, permanent=false, console=true}={}) {
        if (permanent && message === "ERROR.RESOLUTION.Window")
            return;

        return super.notify(message, type, { localize, permanent, console });
    }
}

Hooks.once("init", async function() {
    // CONFIG.debug.applications = true;
    // CONFIG.debug.combat       = true;
    // CONFIG.debug.dice         = true;
    // CONFIG.debug.documents    = true;
    // CONFIG.debug.hooks        = true;
    // CONFIG.debug.rollParsing  = true;

    // CONFIG.ActiveEffect.documentClass     = ActiveEffect;
    // CONFIG.ActiveEffect.legacyTransferral = false;

    CONFIG.ui.notifications = DSA41_Notifications

    CONFIG.Actor.dataModels.Player = DSA41_CharacterData;
    CONFIG.Actor.documentClass     = DSA41_CharacterDocument;

    CONFIG.ChatMessage.documentClass = DSA41_ChatMessage;

    CONFIG.Combat.initiative.formula = "1d6 + @computed.initiative.wert";

    CONFIG.Item.dataModels.Gegenstand       = DSA41_GegenstandData;
    CONFIG.Item.dataModels.Ruestung         = DSA41_RuestungData;
    CONFIG.Item.dataModels.Bewaffnung       = DSA41_BewaffnungData;
    CONFIG.Item.dataModels.Talent           = DSA41_TalentData;
    CONFIG.Item.dataModels.Kampftalent      = DSA41_KampftalentData;
    CONFIG.Item.dataModels.Sonderfertigkeit = DSA41_SonderfertigkeitData;
    CONFIG.Item.dataModels.VorNachteil      = DSA41_VorNachteilData;
    CONFIG.Item.dataModels.Zauber           = DSA41_ZauberData;

    CONFIG.statusEffects = [];

    DocumentSheetConfig.registerSheet(Actor, "dsa41", DSA41_ActorSheet, { 
        makeDefault: true, 
        types: [
            "Player",
        ] 
    });

    DocumentSheetConfig.registerSheet(Item, "dsa41", DSA41_ItemSheetV2, { 
        makeDefault: true, 
        types: [
            "Gegenstand",
            "Ruestung",
            "Bewaffnung",
            "Talent",
            "Kampftalent",
            "Sonderfertigkeit",
            "VorNachteil",
            "Zauber",
        ] 
    });

    Handlebars.registerHelper({
        "string-length": (value, options) => {
            return value.toString().length;
        }
    });

    Handlebars.registerHelper({
        "mul": (a, b, options) => {
            return a * b;
        }
    });

    Handlebars.registerHelper({
        maybeLocalize: (value, options) => {
            const prefix = options.hash.prefix ? options.hash.prefix.string : null;
            if (prefix) {
                const id = prefix + "." + value;
                const localized = game.i18n.localize(id);

                return id === localized ? value : localized;
            }

            return value;
        }
    });

    Handlebars.registerHelper({
        sorted: (array, options) => {
            return array.toSorted((a, b) => a.sort - b.sort);
        }
    });
    
    Handlebars.registerHelper({
        DSA41_input: (field_name, options) => {
            field_name = field_name.toString();

            let fields = field_name.startsWith("system.") ? options.data.root.document.system.schema.fields : options.data.root.document.schema.fields;
            let field = foundry.utils.getProperty(fields, field_name.replace(/^(system\.)/, "").replaceAll(".", ".fields."));

            if (!field) {
                console.error("Non-existent data field provided to {{DSA4_input}} handlebars helper.");
                return Handlebars.SafeString("");
            }

            options.hash.placeholder ??= game.i18n.localize(options.hash.subtitle);

            const value = foundry.utils.getProperty(options.data.root.document, field_name);
            const input = field.toInput({ localize: true, value: value, ...options.hash });

            if (options.hash.subtitle) {
                let subtitle_div = document.createElement("div");
                subtitle_div.className = "subtitle";
                subtitle_div.innerText = game.i18n.localize(options.hash.subtitle);

                let outer_div = document.createElement("div");
                outer_div.replaceChildren(input, subtitle_div);

                return new Handlebars.SafeString(outer_div.outerHTML);
            }

            return new Handlebars.SafeString(input.outerHTML);
        }
    });

    await loadTemplates({
        "editable-input":    "systems/dsa-4th-edition/src/EditableInput.hbs",

        "attribute_tooltip": "systems/dsa-4th-edition/src/Tooltips/Attribute.hbs",

        "attacke_tooltip":       "systems/dsa-4th-edition/src/Tooltips/Attacke.hbs",
        "parade_tooltip":        "systems/dsa-4th-edition/src/Tooltips/Parade.hbs",
        "trefferpunkte_tooltip": "systems/dsa-4th-edition/src/Tooltips/Trefferpunkte.hbs",

        "fernkampf_attacke_tooltip":       "systems/dsa-4th-edition/src/Tooltips/FernkampfAttacke.hbs",
        "fernkampf_trefferpunkte_tooltip": "systems/dsa-4th-edition/src/Tooltips/FernkampfTrefferpunkte.hbs",

        "CHAT_HEADER":          "systems/dsa-4th-edition/src/Chat/Header.hbs",
        "TrefferpunkteTargets": "systems/dsa-4th-edition/src/Chat/TrefferpunkteTargets.hbs",
        "talent_chat":          "systems/dsa-4th-edition/src/Chat/Talent.hbs",
        "zauber_chat":          "systems/dsa-4th-edition/src/Chat/Zauber.hbs",
    });
});

function string_compare(a, b) {
    return a > b ? 1 : a < b ? -1 : 0;
}

function get_targeted_actors() {
    const targets = [];

    for (const token of game.user.targets) {
        if (token.actor) {
            targets.push(token.actor.uuid);
        }
    }

    return targets;
}

async function instantiateTemplate(template, context) {
    const html = await renderTemplate(template, context);

    const template_element = document.createElement("template");
    template_element.innerHTML = html;

    return template_element.content.firstChild;
}

class DSA41_ChatMessage extends ChatMessage {
    get actor() {
        if (this.speaker.scene && this.speaker.token) {
            const scene = game.scenes.get(this.speaker.scene);
            const token = scene?.tokens.get(this.speaker.token);
            if (token) return token.actor;
        }
        
        return game.actors.get(this.speaker.actor);
    }

    async renderHTML({ canDelete, canClose=false, ...rest }={}) {
        const html = await super.renderHTML({ canDelete, canClose, ...rest });

        const img    = this.actor?.img ?? this.author.avatar;
        const name   = this.alias;
        const header = await instantiateTemplate("CHAT_HEADER", { img: img, name: name, author: this.author?.name ?? "" });

        const sender = html.querySelector(".message-sender");
        sender?.replaceChildren(header);

        if (this.flags.dsa41?.type === "trefferpunkte" && this.flags.dsa41?.targets?.length != 0) {
            const targets = this.flags.dsa41?.targets.map(x => fromUuidSync(x, { strict: false })).filter(x => x !== null);
            const targets_list = await instantiateTemplate("TrefferpunkteTargets", targets);

            html.querySelector(".message-content")?.appendChild(targets_list);
        }

        for (const element of html.querySelectorAll("[data-action]")) {
            element.addEventListener("click", async event => {
                const target = event.target;
                const action = target.dataset.action;
                if (action === null) return;

                if (action === "apply_damage") {
                    const target_actor_id = target.closest("[data-actor-id]")?.dataset.actorId;
                    if (!target_actor_id) return;
                    
                    const target_actor = fromUuidSync(target_actor_id);
                    if (!target_actor) return;

                    const dialog_data = await DSA41_Dialog.wait("Trefferzone", { window: {title: "Trefferzone"} });
                    const trefferzone = dialog_data.trefferzone;

                    const rolled_damage = this.rolls[0].total;
                    const target_hp     = target_actor.system.lebenspunkte.aktuell;
                    const target_rs     = target_actor.system.computed.kampf.ruestungen_gesamt[trefferzone];

                    const damage = Math.max(rolled_damage - target_rs, 0);
                    const new_hp = target_hp - damage;

                    target_actor.update({ "system.lebenspunkte.aktuell": new_hp });
                }
            });
        }

        return html;
    }
}

function get_minified_formula(formula, data) {
    const terms = Roll.simplifyTerms(Roll.parse(formula, data));
    let output = [];

    let is_combinable = true;
    for (let i = 0; i < terms.length; i++) {
        const term = terms[i];
        
        if (is_combinable && term instanceof NumericTerm) {
            for (let j = i + 1; j < terms.length - 1; j += 2) {
                let operator = terms[j];
                let next     = terms[j + 1];

                if (!(operator instanceof OperatorTerm && next instanceof NumericTerm))
                    break;
                
                switch (operator.operator) {
                    case "+": {
                        term.number += next.number;
                        i += 2;
                    } break;

                    case "-": {
                        term.number -= next.number;
                        i += 2;
                    } break;

                    default: 
                        break;
                }
            }

            is_combinable = false;
        } else {
            if (term instanceof OperatorTerm && (term.operator == "+" || term.operator == "-")) {
                is_combinable = true;
            } else {
                is_combinable = false;
            }
        }
        
        output.push(term);
    }

    output = Roll.simplifyTerms(output);
    return Roll.getFormula(output);
}

class PreisUnitField extends StringField {
    constructor(options={}, context={}) {
        return super({
            required: true,
            choices: {
                "kreuzer":     "DSA41.currency.kreuzer",
                "heller":      "DSA41.currency.heller",
                "silbertaler": "DSA41.currency.silbertaler",
                "dukaten":     "DSA41.currency.dukaten",
            },
            initial: "silbertaler",
            ...options
        }, context);
    }
}

class PreisField extends SchemaField {
    constructor() {
        return super({
            value: new NumberField({ initial: 0, min: 0 }),
            unit:  new PreisUnitField(),
        });
    }

    _toInput(config) {
        const value_input = this.fields["value"].toInput({ value: config.value.value, });
        const unit_input  = this.fields["unit"] .toInput({ value: config.value.unit, localize: true });

        let outer_div = document.createElement("div");
        outer_div.className = "price-input";
        outer_div.replaceChildren(value_input, unit_input);

        return outer_div;
    }
}

class GewichtUnitField extends StringField {
    constructor(options={}, context={}) {
        return super({
            required: true,
            choices: {
                "gran":    "DSA41.weight.gran",
                "karat":   "DSA41.weight.karat",
                "skrupel": "DSA41.weight.skrupel",
                "unze":    "DSA41.weight.unze",
                "stein":   "DSA41.weight.stein",
                "sack":    "DSA41.weight.sack",
                "quader":  "DSA41.weight.quader",
            },
            initial: "stein",
            ...options
        }, context);
    }
}

class GewichtField extends SchemaField {
    constructor() {
        return super({
            value: new NumberField({ initial: 0, min: 0 }),
            unit:  new GewichtUnitField(),
        });
    }

    _toInput(config) {
        const value_input = this.fields["value"].toInput({ value: config.value.value, });
        const unit_input  = this.fields["unit"] .toInput({ value: config.value.unit, localize: true });

        let outer_div = document.createElement("div");
        outer_div.className = "weight-input";
        outer_div.replaceChildren(value_input, unit_input);

        return outer_div;
    }
}

class LaengeUnitField extends StringField {
    constructor(options={}, context={}) {
        return super({
            required: true,
            choices: {
                "halbfinger": "DSA41.laenge.halbfinger",
                "finger":     "DSA41.laenge.finger",
                "spann":      "DSA41.laenge.spann",
                "schritt":    "DSA41.laenge.schritt",
                "faden":      "DSA41.laenge.faden",
                "lot":        "DSA41.laenge.lot",
                "meile":      "DSA41.laenge.meile",
                "tagesreise": "DSA41.laenge.tagesreise",
                "baryd":      "DSA41.laenge.baryd",
            },
            initial: "schritt",
            ...options
        }, context);
    }
}

class LaengeField extends SchemaField {
    constructor() {
        return super({
            value: new NumberField({ initial: 0, min: 0 }),
            unit:  new LaengeUnitField(),
        });
    }

    _toInput(config) {
        const value_input = this.fields["value"].toInput({ value: config.value.value, });
        const unit_input  = this.fields["unit"] .toInput({ value: config.value.unit, localize: true });

        let outer_div = document.createElement("div");
        outer_div.className = "length-input";
        outer_div.replaceChildren(value_input, unit_input);

        return outer_div;
    }
}

class AttributeField extends SchemaField {
    constructor() {
        return super({
            initial:     new NumberField({ integer: true, initial: 8, min: 0 }),
            advancement: new NumberField({ integer: true, initial: 0, min: 0 }),
            modifier:    new NumberField({ integer: true, initial: 0 }),
        });
    }
}

class AttributeChoiceField extends StringField {
    constructor(options={}, context={}) {
        return super({
            required: true,
            choices: {
                "courage":      "DSA41.attributes.long.courage",
                "cleverness":   "DSA41.attributes.long.cleverness",
                "intuition":    "DSA41.attributes.long.intuition",
                "charisma":     "DSA41.attributes.long.charisma",
                "dexterity":    "DSA41.attributes.long.dexterity",
                "agility":      "DSA41.attributes.long.agility",
                "constitution": "DSA41.attributes.long.constitution",
                "strength":     "DSA41.attributes.long.strength",
            },
            initial: "courage",
            ...options,
        }, context);
    }
}

class SteigerungsKategorieField extends StringField {
    constructor(options={}, context={}) {
        return super({
            required: true,
            choices: {
                "A_Star": "DSA41.steigerungskategorie.A_Star",
                "A":      "DSA41.steigerungskategorie.A",
                "B":      "DSA41.steigerungskategorie.B",
                "C":      "DSA41.steigerungskategorie.C",
                "D":      "DSA41.steigerungskategorie.D",
                "E":      "DSA41.steigerungskategorie.E",
                "F":      "DSA41.steigerungskategorie.F",
                "G":      "DSA41.steigerungskategorie.G",
                "H":      "DSA41.steigerungskategorie.H",
            },
            initial: "A_Star",
            ...options,
        }, context);
    }
}

class DSA41_CharacterDocument extends Actor {
    static async create(data, operation) {
        const actor = await super.create(data, operation);

        if (data.type === "Player") {
            actor.prototypeToken.update({ actorLink: true });

            const talente_compendium = game.packs.get("dsa-4th-edition.talente");
            const talente = await talente_compendium.getDocuments({ name__in: [
                // Basis Körperliche Talente
                "Athletik",
                "Klettern",
                "Körperbeherrschung",
                "Schleichen",
                "Schwimmen",
                "Selbstbeherrschung",
                "Sich Verstecken",
                "Singen",
                "Sinnenschärfe",
                "Tanzen",
                "Zechen",

                // Basis Gesellschaftliche Talente
                "Menschenkenntnis",
                "Überreden",

                // Basis Natur Talente
                "Fährtensuchen",
                "Orientierung",
                "Wildnisleben",

                // Basis Wissens Talente
                "Götter/Kulte",
                "Rechnen",
                "Sagen/Legenden",

                // Basis Handwerks Talente
                "Heilkunde Wunden",
                "Holzbearbeitung",
                "Kochen",
                "Lederarbeiten",
                "Malen/Zeichnen",
                "Schneidern",

                // Basis Kampftalente
                "Dolche",
                "Hiebwaffen",
                "Raufen",
                "Ringen",
                "Säbel",
                "Wurfmesser",
            ]});

            await actor.createEmbeddedDocuments("Item", talente);
        }

        return actor;
    }

    get_hp_roll_modifier() {
        if (this.system.lebenspunkte.aktuell < Math.round(this.system.computed.lebenspunkte.max / 4)) return 3;
        if (this.system.lebenspunkte.aktuell < Math.round(this.system.computed.lebenspunkte.max / 3)) return 2;
        if (this.system.lebenspunkte.aktuell < Math.round(this.system.computed.lebenspunkte.max / 2)) return 1;

        return 0;
    }
}

class DSA41_CharacterData extends TypeDataModel {
    static defineSchema() {
        return {
            race:         new StringField(),
            culture:      new StringField(),
            profession:   new StringField(),
            sozialstatus: new NumberField({ integer: true, inital: 1 }),

            allgemein: new SchemaField({
                geschlecht: new StringField(),
                alter:      new StringField(),
                groesse:    new LaengeField(),
                gewicht:    new GewichtField(),
                haarfarbe:  new StringField(),
                augenfarbe: new StringField(),
                stand:      new StringField(),
                titel:      new StringField(),

                aussehen:    new StringField(),
                hintergrund: new StringField(),
                biografie:   new StringField(),
            }),

            abenteuerpunkte: new SchemaField({
                ausgegeben: new NumberField({ integer: true, initial: 0 }),
                gesamt:     new NumberField({ integer: true, initial: 0 }),
            }),

            currency: new SchemaField({
                dukaten:     new NumberField({ integer: true, initial: 0 }),
                silbertaler: new NumberField({ integer: true, initial: 0 }),
                heller:      new NumberField({ integer: true, initial: 0 }),
                kreuzer:     new NumberField({ integer: true, initial: 0 }),
            }),

            attributes: new SchemaField({
                courage:      new AttributeField(),
                cleverness:   new AttributeField(),
                intuition:    new AttributeField(),
                charisma:     new AttributeField(),
                dexterity:    new AttributeField(),
                agility:      new AttributeField(),
                constitution: new AttributeField(),
                strength:     new AttributeField(),
            }),

            lebenspunkte: new SchemaField({
                modifikator: new NumberField({integer: true, initial: 0}),
                zukauf:      new NumberField({integer: true, initial: 0}),
                verlust:     new NumberField({integer: true, initial: 0}),

                aktuell: new NumberField({integer: true, initial: 0}),
            }),

            ausdauer: new SchemaField({
                modifikator: new NumberField({integer: true, initial: 0}),
                zukauf:      new NumberField({integer: true, initial: 0}),
                verlust:     new NumberField({integer: true, initial: 0}),

                aktuell: new NumberField({integer: true, initial: 0}),
            }),

            astralenergie: new SchemaField({
                modifikator: new NumberField({integer: true, initial: 0}),
                zukauf:      new NumberField({integer: true, initial: 0}),
                verlust:     new NumberField({integer: true, initial: 0}),

                aktuell: new NumberField({integer: true, initial: 0}),
            }),

            karmalenergie: new NumberField({integer: true, inital: 0}),

            magieresistenz: new SchemaField({
                modifikator: new NumberField({integer: true, initial: 0}),
                zukauf:      new NumberField({integer: true, initial: 0}),

                aktuell: new NumberField({integer: true, initial: 0}),
            }),

            modifikator_initiative: new NumberField({integer: true, initial: 0}),
            modifikator_attacke:    new NumberField({integer: true, initial: 0}),
            modifikator_parade:     new NumberField({integer: true, initial: 0}),
            modifikator_fernkampf:  new NumberField({integer: true, initial: 0}),

            wunden: new SchemaField({
                kopf:         new NumberField({integer: true, initial: 0, min: 0, max: 3 }),
                brust:        new NumberField({integer: true, initial: 0, min: 0, max: 3 }),
                bauch:        new NumberField({integer: true, initial: 0, min: 0, max: 3 }),
                linker_arm:   new NumberField({integer: true, initial: 0, min: 0, max: 3 }),
                rechter_arm:  new NumberField({integer: true, initial: 0, min: 0, max: 3 }),
                linkes_bein:  new NumberField({integer: true, initial: 0, min: 0, max: 3 }),
                rechtes_bein: new NumberField({integer: true, initial: 0, min: 0, max: 3 }),
            }),
        }
    }

    async prepareDerivedData() {
        super.prepareDerivedData();
        this.computed = {
            abenteuerpunkte:              {},
            attributes:                   {},
            attributes_without_modifiers: {},

            num_vorteile:                      0,
            num_nachteile:                     0,
            num_allgemeine_sonderfertigkeiten: 0,
            num_kampf_sonderfertigkeiten:      0,
            num_magische_sonderfertigkeiten:   0,
            num_waffen:                        0,
            num_fernkampf_waffen:              0,

            kampf: {
                talente:          {},
                waffen:           {},
                fernkampf_waffen: {},
                ruestungen:       {},
                ruestungen_gesamt: {
                    kopf:         0,
                    brust:        0,
                    ruecken:      0, 
                    bauch:        0, 
                    linker_arm:   0,
                    rechter_arm:  0,
                    linkes_bein:  0,
                    rechtes_bein: 0,

                    gesamt_ruestungsschutz: 0.0,
                    gesamt_behinderung:     0.0,
                },
            },

            wunden_modifiers: {
                courage:           0,
                cleverness:        0,
                intuition:         0,
                dexterity:         0,
                agility:           0,
                constitution:      0,
                strength:          0,
                initiative_basis:  0,
                initiative:        "",
                attacke:           0,
                parade:            0,
                schaden:           "",
            },
        };

        if (this.wunden.kopf >= 1) {
            this.computed.wunden_modifiers.courage           += -2 * this.wunden.kopf;
            this.computed.wunden_modifiers.cleverness        += -2 * this.wunden.kopf;
            this.computed.wunden_modifiers.intuition         += -2 * this.wunden.kopf;
            this.computed.wunden_modifiers.initiative_basis  += -2 * this.wunden.kopf;
            this.computed.wunden_modifiers.initiative        += (-2 * this.wunden.kopf) + "d6";

            if (this.wunden.kopf >= 3) this.computed.wunden_modifiers.schaden += "+ 2d6";
        }

        if (this.wunden.brust >= 1) {
            this.computed.wunden_modifiers.attacke      += -this.wunden.brust;
            this.computed.wunden_modifiers.parade       += -this.wunden.brust;
            this.computed.wunden_modifiers.constitution += -this.wunden.brust;
            this.computed.wunden_modifiers.strength     += -this.wunden.brust;
            this.computed.wunden_modifiers.schaden      += "+" + this.wunden.brust + "d6";
        }

        if (this.wunden.bauch >= 1) {
            this.computed.wunden_modifiers.attacke          += -this.wunden.bauch;
            this.computed.wunden_modifiers.parade           += -this.wunden.bauch;
            this.computed.wunden_modifiers.constitution     += -this.wunden.bauch;
            this.computed.wunden_modifiers.strength         += -this.wunden.bauch;
            this.computed.wunden_modifiers.initiative_basis += -this.wunden.bauch;
            this.computed.wunden_modifiers.schaden          += "+" + this.wunden.bauch + "d6";
        }

        if (this.wunden.linker_arm >= 1) {
            this.computed.wunden_modifiers.attacke   += -2 * this.wunden.linker_arm;
            this.computed.wunden_modifiers.parade    += -2 * this.wunden.linker_arm;
            this.computed.wunden_modifiers.strength  += -2 * this.wunden.linker_arm;
            this.computed.wunden_modifiers.dexterity += -2 * this.wunden.linker_arm;
        }

        if (this.wunden.rechter_arm >= 1) {
            this.computed.wunden_modifiers.attacke   += -2 * this.wunden.rechter_arm;
            this.computed.wunden_modifiers.parade    += -2 * this.wunden.rechter_arm;
            this.computed.wunden_modifiers.strength  += -2 * this.wunden.rechter_arm;
            this.computed.wunden_modifiers.dexterity += -2 * this.wunden.rechter_arm;
        }

        if (this.wunden.linkes_bein >= 1) {
            this.computed.wunden_modifiers.attacke          += -2 * this.wunden.linkes_bein;
            this.computed.wunden_modifiers.parade           += -2 * this.wunden.linkes_bein;
            this.computed.wunden_modifiers.agility          += -2 * this.wunden.linkes_bein;
            this.computed.wunden_modifiers.initiative_basis += -2 * this.wunden.linkes_bein;
        }

        if (this.wunden.rechtes_bein >= 1) {
            this.computed.wunden_modifiers.attacke          += -2 * this.wunden.rechtes_bein;
            this.computed.wunden_modifiers.parade           += -2 * this.wunden.rechtes_bein;
            this.computed.wunden_modifiers.agility          += -2 * this.wunden.rechtes_bein;
            this.computed.wunden_modifiers.initiative_basis += -2 * this.wunden.rechtes_bein;
        }

        this.computed.abenteuerpunkte.uebrig = this.abenteuerpunkte.gesamt - this.abenteuerpunkte.ausgegeben;

        this.computed.attributes_without_modifiers.courage      = this.attributes.courage.initial      + this.attributes.courage.advancement;
        this.computed.attributes_without_modifiers.cleverness   = this.attributes.cleverness.initial   + this.attributes.cleverness.advancement;
        this.computed.attributes_without_modifiers.intuition    = this.attributes.intuition.initial    + this.attributes.intuition.advancement;
        this.computed.attributes_without_modifiers.charisma     = this.attributes.charisma.initial     + this.attributes.charisma.advancement;
        this.computed.attributes_without_modifiers.dexterity    = this.attributes.dexterity.initial    + this.attributes.dexterity.advancement;
        this.computed.attributes_without_modifiers.agility      = this.attributes.agility.initial      + this.attributes.agility.advancement;
        this.computed.attributes_without_modifiers.constitution = this.attributes.constitution.initial + this.attributes.constitution.advancement;
        this.computed.attributes_without_modifiers.strength     = this.attributes.strength.initial     + this.attributes.strength.advancement;

        this.computed.attributes.courage      = this.computed.attributes_without_modifiers.courage      + this.attributes.courage.modifier      + this.computed.wunden_modifiers.courage;
        this.computed.attributes.cleverness   = this.computed.attributes_without_modifiers.cleverness   + this.attributes.cleverness.modifier   + this.computed.wunden_modifiers.cleverness;
        this.computed.attributes.intuition    = this.computed.attributes_without_modifiers.intuition    + this.attributes.intuition.modifier    + this.computed.wunden_modifiers.intuition;
        this.computed.attributes.charisma     = this.computed.attributes_without_modifiers.charisma     + this.attributes.charisma.modifier;
        this.computed.attributes.dexterity    = this.computed.attributes_without_modifiers.dexterity    + this.attributes.dexterity.modifier    + this.computed.wunden_modifiers.dexterity;
        this.computed.attributes.agility      = this.computed.attributes_without_modifiers.agility      + this.attributes.agility.modifier      + this.computed.wunden_modifiers.agility;
        this.computed.attributes.constitution = this.computed.attributes_without_modifiers.constitution + this.attributes.constitution.modifier + this.computed.wunden_modifiers.constitution;
        this.computed.attributes.strength     = this.computed.attributes_without_modifiers.strength     + this.attributes.strength.modifier     + this.computed.wunden_modifiers.strength;

        this.computed.lebenspunkte   = {};
        this.computed.ausdauer       = {};
        this.computed.astralenergie  = {};
        this.computed.magieresistenz = {};

        this.computed.lebenspunkte.basiswert   = Math.round((this.computed.attributes_without_modifiers.constitution + this.computed.attributes_without_modifiers.constitution + this.computed.attributes_without_modifiers.strength)     / 2);
        this.computed.ausdauer.basiswert       = Math.round((this.computed.attributes_without_modifiers.courage      + this.computed.attributes_without_modifiers.constitution + this.computed.attributes_without_modifiers.agility)      / 2);
        this.computed.astralenergie.basiswert  = Math.round((this.computed.attributes_without_modifiers.courage      + this.computed.attributes_without_modifiers.intuition    + this.computed.attributes_without_modifiers.charisma)     / 2);
        this.computed.magieresistenz.basiswert = Math.round((this.computed.attributes_without_modifiers.courage      + this.computed.attributes_without_modifiers.cleverness   + this.computed.attributes_without_modifiers.constitution) / 5);

        this.computed.lebenspunkte.max   = this.computed.lebenspunkte.basiswert   + this.lebenspunkte.modifikator   + this.lebenspunkte.zukauf   - this.lebenspunkte.verlust;
        this.computed.ausdauer.max       = this.computed.ausdauer.basiswert       + this.ausdauer.modifikator       + this.ausdauer.zukauf       - this.ausdauer.verlust;
        this.computed.astralenergie.max  = this.computed.astralenergie.basiswert  + this.astralenergie.modifikator  + this.astralenergie.zukauf  - this.astralenergie.verlust;
        this.computed.magieresistenz.max = this.computed.magieresistenz.basiswert + this.magieresistenz.modifikator + this.magieresistenz.zukauf;
        
        this.computed.lebenspunkte.prozent   = this.lebenspunkte.aktuell   / this.computed.lebenspunkte.max   * 100;
        this.computed.ausdauer.prozent       = this.ausdauer.aktuell       / this.computed.ausdauer.max       * 100;
        this.computed.astralenergie.prozent  = this.astralenergie.aktuell  / this.computed.astralenergie.max  * 100;
        this.computed.magieresistenz.prozent = this.magieresistenz.aktuell / this.computed.magieresistenz.max * 100;

        this.computed.initiative     = {};
        this.computed.attacke        = {};
        this.computed.parade         = {};
        this.computed.fernkampf      = {};

        this.computed.initiative.basiswert = Math.round((this.computed.attributes_without_modifiers.courage   + this.computed.attributes_without_modifiers.courage   + this.computed.attributes_without_modifiers.intuition + this.computed.attributes_without_modifiers.agility) / 5);
        this.computed.attacke.basiswert    = Math.round((this.computed.attributes_without_modifiers.courage   + this.computed.attributes_without_modifiers.agility   + this.computed.attributes_without_modifiers.strength) / 5);
        this.computed.parade.basiswert     = Math.round((this.computed.attributes_without_modifiers.intuition + this.computed.attributes_without_modifiers.agility   + this.computed.attributes_without_modifiers.strength) / 5);
        this.computed.fernkampf.basiswert  = Math.round((this.computed.attributes_without_modifiers.intuition + this.computed.attributes_without_modifiers.dexterity + this.computed.attributes_without_modifiers.strength) / 5);


        const equipped_ruestungen = this.parent.items.filter((x) => x.type === "Ruestung" && x.system.angelegt === true);
        for (const item of equipped_ruestungen) {
            this.computed.kampf.ruestungen[item._id] = { item: item };

            this.computed.kampf.ruestungen_gesamt.kopf                   += item.system.kopf;
            this.computed.kampf.ruestungen_gesamt.brust                  += item.system.brust;
            this.computed.kampf.ruestungen_gesamt.ruecken                += item.system.ruecken;
            this.computed.kampf.ruestungen_gesamt.bauch                  += item.system.bauch;
            this.computed.kampf.ruestungen_gesamt.linker_arm             += item.system.linker_arm;
            this.computed.kampf.ruestungen_gesamt.rechter_arm            += item.system.rechter_arm;
            this.computed.kampf.ruestungen_gesamt.linkes_bein            += item.system.linkes_bein;
            this.computed.kampf.ruestungen_gesamt.rechtes_bein           += item.system.rechtes_bein;
            this.computed.kampf.ruestungen_gesamt.gesamt_ruestungsschutz += item.system.gesamt_ruestungsschutz;
            this.computed.kampf.ruestungen_gesamt.gesamt_behinderung     += item.system.gesamt_behinderung;
        }

        for (let [key, value] of Object.entries(this.computed.kampf.ruestungen_gesamt)) {
            this.computed.kampf.ruestungen_gesamt[key] = Math.round(value);
        }

        this.computed.initiative.wert = this.computed.initiative.basiswert + this.modifikator_initiative - this.computed.kampf.ruestungen_gesamt.gesamt_behinderung + this.computed.wunden_modifiers.initiative_basis;
        this.computed.attacke.wert    = this.computed.attacke.basiswert    + this.modifikator_attacke + this.computed.wunden_modifiers.attacke;
        this.computed.parade.wert     = this.computed.parade.basiswert     + this.modifikator_parade  + this.computed.wunden_modifiers.parade;
        this.computed.fernkampf.wert  = this.computed.fernkampf.basiswert  + this.modifikator_fernkampf;

        this.kampftalente = this.parent.items.filter((x) => x.type === "Kampftalent").sort((a, b) => string_compare(a.name, b.name));
        for(const talent of this.kampftalente) {
            this.computed.kampf.talente[talent.name] = {};
            this.computed.kampf.talente[talent.name].attacke = (talent.system.kategorie === "fernkampf" ? this.computed.fernkampf.wert : this.computed.attacke.wert) + talent.system.attacke;
            this.computed.kampf.talente[talent.name].parade  = this.computed.parade.wert  + talent.system.parade;

            this.computed.kampf.talente[talent.name].talent_attacke = talent.system.attacke;
            this.computed.kampf.talente[talent.name].talent_parade  = talent.system.parade;
        }

        const equipped_bewaffnung      = this.parent.items.filter((x) => x.type === "Bewaffnung" && x.system.angelegt === true);
        const equipped_nahkampfwaffen  = equipped_bewaffnung.filter((x) => x.system.nahkampfwaffe.aktiv);
        const equipped_parierwaffen    = equipped_bewaffnung.filter((x) => x.system.parierwaffe.aktiv);
        const equipped_schilde         = equipped_bewaffnung.filter((x) => x.system.schild.aktiv);
        const equipped_fernkampfwaffen = equipped_bewaffnung.filter((x) => x.system.fernkampfwaffe.aktiv);

        for(const item of equipped_nahkampfwaffen) {
            if (item.system.nahkampfwaffe.aktiv) {
                this.computed.num_waffen += 1;
                let computed = this.computed.kampf.waffen[item._id] = { 
                    item: item,

                    attacke:     0,
                    parade:      0,
                    parade_crit: 0,

                    trefferpunkte:         "",
                    trefferpunkte_display: "",

                    basis_attacke: 0,
                    basis_parade:  0,
    
                    talent_attacke: 0,
                    talent_parade:  0,

                    modifikator_attacke: 0,
                    modifikator_parade:  0,

                    tp_kk: 0,
    
                    parierwaffe_attacke: 0,
                    parierwaffe_parade:  0,
    
                    schild_attacke:  0,
                    schild_parade:   0,
                };

                computed.basis_attacke = this.computed.attacke.wert;
                computed.basis_parade  = this.computed.parade.wert;

                const talent = item.system.nahkampfwaffe.kampftalente;

                computed.talent_attacke = this.computed.kampf.talente[talent]?.talent_attacke ?? 0;
                computed.talent_parade  = this.computed.kampf.talente[talent]?.talent_parade  ?? 0;

                computed.modifikator_attacke = item.system.nahkampfwaffe.modifikator_attacke;
                computed.modifikator_parade  = item.system.nahkampfwaffe.modifikator_parade;
                
                if (item.system.nahkampfwaffe.schadensschritte != 0) {
                    computed.tp_kk = Math.trunc((this.computed.attributes.strength - item.system.nahkampfwaffe.schwellenwert) / item.system.nahkampfwaffe.schadensschritte);
                }

                for (const parierwaffe of equipped_parierwaffen) {
                    if (parierwaffe._id === item._id) continue;

                    computed.parierwaffe_attacke += parierwaffe.system.parierwaffe.modifikator_attacke;
                    computed.parierwaffe_parade  += parierwaffe.system.parierwaffe.modifikator_parade;
                }

                for (const schild of equipped_schilde) {
                    if (schild._id === item._id) continue;

                    computed.schild_attacke += schild.system.schild.modifikator_attacke;
                    computed.schild_parade  += schild.system.schild.modifikator_parade;
                }

                computed.attacke      = computed.basis_attacke + computed.talent_attacke + computed.modifikator_attacke + computed.parierwaffe_attacke + computed.schild_attacke + Math.min(computed.tp_kk, 0);
                computed.parade       = computed.basis_parade  + computed.talent_parade  + computed.modifikator_parade  + computed.parierwaffe_parade  + computed.schild_parade  + Math.min(computed.tp_kk, 0);
                computed.parade_crit  = Math.round(computed.parade / 2);

                computed.trefferpunkte         = get_minified_formula(item.system.nahkampfwaffe.basis + (computed.tp_kk != 0 ? " + " + computed.tp_kk : ""));
                computed.trefferpunkte_display = computed.trefferpunkte.replace(/[\+\-]/, (op) => "<br>" + op);
            }
        }

        for (const item of equipped_fernkampfwaffen) {
            this.computed.num_fernkampf_waffen += 1;
            let computed = this.computed.kampf.fernkampf_waffen[item._id] = { 
                item: item,
                attacke: 0,
                trefferpunkte:         "",
                trefferpunkte_display: "",

                basis_attacke:  0,
                talent_attacke: 0,
            };

            computed.basis_attacke = this.computed.fernkampf.wert;

            const talent = item.system.nahkampfwaffe.kampftalente;
            computed.talent_attacke = this.computed.kampf.talente[talent]?.talent_attacke ?? 0;

            computed.attacke = computed.basis_attacke + computed.talent_attacke;

            computed.trefferpunkte         = get_minified_formula(item.system.fernkampfwaffe.basis);
            computed.trefferpunkte_display = computed.trefferpunkte.replace(/[\+\-]/, (op) => "<br>" + op);
        }
        
        const talente = this.parent.items.filter((x) => x.type === "Talent").sort((a, b) => string_compare(a.name, b.name));
        this.talente = {
            koerperliche:      talente.filter((x) => x.system.kategorie === "koerperliche"),
            gesellschaftliche: talente.filter((x) => x.system.kategorie === "gesellschaftliche"),
            natur:             talente.filter((x) => x.system.kategorie === "natur"),
            wissens:           talente.filter((x) => x.system.kategorie === "wissens"),
            handwerks:         talente.filter((x) => x.system.kategorie === "handwerks"),
        };

        this.computed.num_allgemeine_sonderfertigkeiten = this.parent.items.filter((x) => x.type === "Sonderfertigkeit" && x.system.kategorie === "allgemein").length;
        this.computed.num_kampf_sonderfertigkeiten      = this.parent.items.filter((x) => x.type === "Sonderfertigkeit" && x.system.kategorie === "kampf").length;
        this.computed.num_magische_sonderfertigkeiten   = this.parent.items.filter((x) => x.type === "Sonderfertigkeit" && x.system.kategorie === "magisch").length;
        this.computed.num_vorteile                      = this.parent.items.filter((x) => x.type === "VorNachteil" && x.system.kategorie === "vorteil").length;
        this.computed.num_nachteile                     = this.parent.items.filter((x) => x.type === "VorNachteil" && x.system.kategorie === "nachteil").length;
    }
}

class DSA41_GegenstandData extends TypeDataModel {
    static defineSchema() {
        return {
            gewicht: new GewichtField(),
            preis:   new PreisField(),
            anzahl:  new NumberField({ integer: true, initial: 1, min: 0 }),

            beschreibung: new StringField({ initial: "" }),
        };
    }
}

class DSA41_RuestungData extends TypeDataModel {
    static defineSchema() {
        return {
            angelegt: new BooleanField({ initial: false }),

            gewicht: new GewichtField(),
            preis:   new PreisField(),

            kopf:         new NumberField({ integer: true, initial: 0, min: 0 }),
            brust:        new NumberField({ integer: true, initial: 0, min: 0 }),
            ruecken:      new NumberField({ integer: true, initial: 0, min: 0 }),
            bauch:        new NumberField({ integer: true, initial: 0, min: 0 }),
            linker_arm:   new NumberField({ integer: true, initial: 0, min: 0 }),
            rechter_arm:  new NumberField({ integer: true, initial: 0, min: 0 }),
            linkes_bein:  new NumberField({ integer: true, initial: 0, min: 0 }),
            rechtes_bein: new NumberField({ integer: true, initial: 0, min: 0 }),

            gesamt_ruestungsschutz: new NumberField({ integer: false, initial: 0, min: 0 }),
            gesamt_behinderung:     new NumberField({ integer: false, initial: 0, min: 0 }),

            beschreibung: new StringField({ initial: "" }),
        };
    }
}

class DSA41_BewaffnungData extends TypeDataModel {
    static defineSchema() {
        return {
            angelegt: new BooleanField({ initial: false }),

            gewicht: new GewichtField(),
            preis:   new PreisField(),

            beschreibung: new StringField({ initial: "" }),

            nahkampfwaffe: new SchemaField({
                aktiv: new BooleanField({ initial: false }),

                basis:            new StringField({ initial: "1d4" }),
                schwellenwert:    new NumberField({ integer: true, initial: 0, min: 0 }),
                schadensschritte: new NumberField({ integer: true, initial: 0, min: 0 }),
    
                modifikator_attacke: new NumberField({ integer: true, initial: 0 }),
                modifikator_parade:  new NumberField({ integer: true, initial: 0 }),
    
                initiative:  new NumberField({ integer: true, initial: 0 }),
                bruchfaktor: new NumberField({ integer: true, initial: 0 }),
    
                distanzklasse: new StringField({ initial: "" }),
                kampftalente:  new StringField({ initial: "" }),

                laenge: new LaengeField(),
    
                zweihaendig:  new BooleanField({ initial: false }),
                werfbar:      new BooleanField({ initial: false }),
                improvisiert: new BooleanField({ initial: false }),
                priviligiert: new BooleanField({ initial: false }),
            }),
            
            parierwaffe: new SchemaField({
                aktiv: new BooleanField({ initial: false }),

                modifikator_attacke: new NumberField({ integer: true, initial: 0 }),
                modifikator_parade:  new NumberField({ integer: true, initial: 0 }),

                initiative:  new NumberField({ integer: true, initial: 0 }),
                bruchfaktor: new NumberField({ integer: true, initial: 0 }),
            }),

            schild: new SchemaField({
                aktiv: new BooleanField({ initial: false }),

                groesse: new StringField({
                    required: true,
                    choices: {
                        "klein":      "DSA41.bewaffnung.schild.groesse.klein",
                        "gross":      "DSA41.bewaffnung.schild.groesse.gross",
                        "sehr_gross": "DSA41.bewaffnung.schild.groesse.sehr_gross",
                    },
                    initial: "klein",
                }),
                
                modifikator_attacke: new NumberField({ integer: true, initial: 0 }),
                modifikator_parade:  new NumberField({ integer: true, initial: 0 }),

                initiative:  new NumberField({ integer: true, initial: 0 }),
                bruchfaktor: new NumberField({ integer: true, initial: 0 }),
            }),

            fernkampfwaffe: new SchemaField({
                aktiv: new BooleanField({ initial: false }),

                basis: new StringField({ initial: "1d6 + 1" }),
                laden: new NumberField({ integer: true, initial: 0 }),

                reichweite1: new NumberField({ integer: true, initial: 0 }),
                reichweite2: new NumberField({ integer: true, initial: 0 }),
                reichweite3: new NumberField({ integer: true, initial: 0 }),
                reichweite4: new NumberField({ integer: true, initial: 0 }),
                reichweite5: new NumberField({ integer: true, initial: 0 }),

                modifikator1: new NumberField({ integer: true, initial: 0, nullable: true }),
                modifikator2: new NumberField({ integer: true, initial: 0, nullable: true }),
                modifikator3: new NumberField({ integer: true, initial: 0, nullable: true }),
                modifikator4: new NumberField({ integer: true, initial: 0, nullable: true }),
                modifikator5: new NumberField({ integer: true, initial: 0, nullable: true }),

                munitionskosten:  new NumberField({ integer: true,  initial: 0 }),
                munitionsgewicht: new NumberField({ integer: true,  initial: 0 }),
            }),
        };
    }
}

class DSA41_TalentData extends TypeDataModel {
    static defineSchema() {
        return {
            kategorie:   new StringField({
                required: true,
                choices: {
                    "koerperliche":      "DSA41.talente.koerperliche.label",
                    "gesellschaftliche": "DSA41.talente.gesellschaftliche.label",
                    "natur":             "DSA41.talente.natur.label",
                    "wissens":           "DSA41.talente.wissens.label",
                    "handwerks":         "DSA41.talente.handwerks.label",
                },
                initial: "koerperliche"
            }),
            behinderung: new StringField({ initial: "" }),

            attribute1: new AttributeChoiceField(),
            attribute2: new AttributeChoiceField(),
            attribute3: new AttributeChoiceField(),

            talentwert: new NumberField({ integer: true, initial: 0 }),

            beschreibung: new StringField({ initial: "" }),
        };
    }
}

class DSA41_KampftalentData extends TypeDataModel {
    static defineSchema() {
        return {
            kategorie:   new StringField({
                required: true,
                choices: {
                    "waffenlos": "DSA41.kampftalent.kategorie.waffenlos",
                    "nahkampf":  "DSA41.kampftalent.kategorie.nahkampf",
                    "fernkampf": "DSA41.kampftalent.kategorie.fernkampf",
                },
                initial: "waffenlos"
            }),
            behinderung: new StringField({ initial: "" }),
            steigern:    new SteigerungsKategorieField(),

            beschreibung: new StringField({ initial: "" }),

            talentwert: new NumberField({ integer: true, initial: 0 }),
            attacke:    new NumberField({ integer: true, initial: 0 }),
            parade:     new NumberField({ integer: true, initial: 0 }),
        };
    }
}

class DSA41_SonderfertigkeitData extends TypeDataModel {
    static defineSchema() {
        return {
            kategorie:   new StringField({
                required: true,
                choices: {
                    "allgemein": "DSA41.sonderfertigkeiten.kategorie.allgemein",
                    "kampf":     "DSA41.sonderfertigkeiten.kategorie.kampf",
                    "magisch":   "DSA41.sonderfertigkeiten.kategorie.magisch",
                    "klerikal":  "DSA41.sonderfertigkeiten.kategorie.klerikal",
                },
                initial: "allgemein",
            }),
            kosten:      new NumberField({ integer: true, initial: 0 }),
            verbreitung: new NumberField({ integer: true, initial: 0 }),

            beschreibung: new StringField({ initial: "" }),
        };
    }
}

class DSA41_VorNachteilData extends TypeDataModel {
    static defineSchema() {
        return {
            kategorie: new StringField({
                required: true,
                choices: {
                    "vorteil":  "DSA41.vornachteil.kategorie.vorteil",
                    "nachteil": "DSA41.vornachteil.kategorie.nachteil",
                },
                initial: "vorteil",
            }),
            kosten: new NumberField({ integer: true, initial: 0 }),

            beschreibung: new StringField({ initial: "" }),
        };
    }
}

class DSA41_ZauberData extends TypeDataModel {
    static defineSchema() {
        return {
            attribute1: new AttributeChoiceField(),
            attribute2: new AttributeChoiceField(),
            attribute3: new AttributeChoiceField(),

            zauberdauer:   new StringField(),
            wirkungsdauer: new StringField(),

            kosten:       new StringField(),
            komplexitaet: new SteigerungsKategorieField(),

            repraesentation: new StringField({
                required: true,
                choices: {
                    "borbaradianisch":   "DSA41.zauber.repraesentation.borbaradianisch",
                    "druidisch":         "DSA41.zauber.repraesentation.druidisch",
                    "elfisch":           "DSA41.zauber.repraesentation.elfisch",
                    "geodisch":          "DSA41.zauber.repraesentation.geodisch",
                    "satuarisch":        "DSA41.zauber.repraesentation.satuarisch",
                    "kristallomantisch": "DSA41.zauber.repraesentation.kristallomantisch",
                    "gildenmagisch":     "DSA41.zauber.repraesentation.gildenmagisch",
                    "scharlatanisch":    "DSA41.zauber.repraesentation.scharlatanisch",
                    "schelmisch":        "DSA41.zauber.repraesentation.schelmisch",
                },
                initial: "borbaradianisch",
            }),

            merkmale: new SetField(new StringField({
                choices: {
                    "anitmagie":                        "DSA41.zauber.merkmale.anitmagie",
                    "beschwoerung":                     "DSA41.zauber.merkmale.beschwoerung",
                    "daemonisch_allgemein":             "DSA41.zauber.merkmale.daemonisch_allgemein",
                    "daemonisch_agrimoth_widharcal":    "DSA41.zauber.merkmale.daemonisch_agrimoth_widharcal",
                    "daemonisch_amazeroth_iribaar":     "DSA41.zauber.merkmale.daemonisch_amazeroth_iribaar",
                    "daemonisch_asfaloth_calijnaar":    "DSA41.zauber.merkmale.daemonisch_asfaloth_calijnaar",
                    "daemonisch_belhalhar_xarfai":      "DSA41.zauber.merkmale.daemonisch_belhalhar_xarfai",
                    "daemonisch_blakharaz_tyakraman":   "DSA41.zauber.merkmale.daemonisch_blakharaz_tyakraman",
                    "daemonisch_lolgramoth_thezzphai":  "DSA41.zauber.merkmale.daemonisch_lolgramoth_thezzphai",
                    "daemonisch_belzhorash_mishkara":   "DSA41.zauber.merkmale.daemonisch_belzhorash_mishkara",
                    "daemonisch_thargunitoth_tijakool": "DSA41.zauber.merkmale.daemonisch_thargunitoth_tijakool",
                    "eigenschaften":                    "DSA41.zauber.merkmale.eigenschaften",
                    "einfluss":                         "DSA41.zauber.merkmale.einfluss",
                    "elementar_allgemein":              "DSA41.zauber.merkmale.elementar_allgemein",
                    "elementar_eis":                    "DSA41.zauber.merkmale.elementar_eis",
                    "elementar_erz":                    "DSA41.zauber.merkmale.elementar_erz",
                    "elementar_feuer":                  "DSA41.zauber.merkmale.elementar_feuer",
                    "elementar_humus":                  "DSA41.zauber.merkmale.elementar_humus",
                    "elementar_luft":                   "DSA41.zauber.merkmale.elementar_luft",
                    "elementar_wasser":                 "DSA41.zauber.merkmale.elementar_wasser",
                    "form":                             "DSA41.zauber.merkmale.form",
                    "geisterwesen":                     "DSA41.zauber.merkmale.geisterwesen",
                    "heilung":                          "DSA41.zauber.merkmale.heilung",
                    "hellsicht":                        "DSA41.zauber.merkmale.hellsicht",
                    "herbeirufung":                     "DSA41.zauber.merkmale.herbeirufung",
                    "herrschaft":                       "DSA41.zauber.merkmale.herrschaft",
                    "illusion":                         "DSA41.zauber.merkmale.illusion",
                    "kraft":                            "DSA41.zauber.merkmale.kraft",
                    "limbus":                           "DSA41.zauber.merkmale.limbus",
                    "metamagie":                        "DSA41.zauber.merkmale.metamagie",
                    "objekt":                           "DSA41.zauber.merkmale.objekt",
                    "schaden":                          "DSA41.zauber.merkmale.schaden",
                    "telekinese":                       "DSA41.zauber.merkmale.telekinese",
                    "temporal":                         "DSA41.zauber.merkmale.temporal",
                    "umwelt":                           "DSA41.zauber.merkmale.umwelt",
                    "verständigung":                    "DSA41.zauber.merkmale.verständigung",
                },
            })),

            modifikationen: new SetField(new StringField({
                choices: {
                    "zauberdauer":              "DSA41.zauber.modifikationen.zauberdauer",
                    "erzwingen":                "DSA41.zauber.modifikationen.erzwingen",
                    "kosten":                   "DSA41.zauber.modifikationen.kosten",
                    "mehrere_ziele":            "DSA41.zauber.modifikationen.mehrere_ziele",
                    "mehrere_ziele_freiwillig": "DSA41.zauber.modifikationen.mehrere_ziele_freiwillig",
                    "reichweite":               "DSA41.zauber.modifikationen.reichweite",
                    "reichweite_beruehrung":    "DSA41.zauber.modifikationen.reichweite_beruehrung",
                    "reichweite_selbst":        "DSA41.zauber.modifikationen.reichweite_selbst",
                    "wirkungsdauer":            "DSA41.zauber.modifikationen.wirkungsdauer",
                    "ziel_objekt":              "DSA41.zauber.modifikationen.ziel_objekt",
                },
            })),

            magieresistenz: new BooleanField({ initial: false }),

            haus: new BooleanField({ initial: false }),
            zauberfertigkeitswert: new NumberField({ integer: true, initial: 0 }),

            beschreibung: new StringField({ initial: "" }),
        };
    }
}

function DSA41_ApplicationMixin(BaseApplication) {
    class DSA41_Application extends HandlebarsApplicationMixin(BaseApplication) {
        static DEFAULT_OPTIONS= {
            classes: [ "DSA41" ],
            window: { resizable: true },
            form: { submitOnChange: true },
        };

        async _prepareContext(options) {
            return this;
        }
    }

    return DSA41_Application;
}

class DSA41_Dialog extends DSA41_ApplicationMixin(ApplicationV2) {
    static PARTS = {
        Eigenschaft: { template: "systems/dsa-4th-edition/src/Dialogs/Attribute.hbs" },
        Talent:      { template: "systems/dsa-4th-edition/src/Dialogs/Talent.hbs" },
        Zauber:      { template: "systems/dsa-4th-edition/src/Dialogs/Zauber.hbs" },

        Attacke:       { template: "systems/dsa-4th-edition/src/Dialogs/Attacke.hbs" },
        Parade:        { template: "systems/dsa-4th-edition/src/Dialogs/Parade.hbs" },
        Trefferpunkte: { template: "systems/dsa-4th-edition/src/Dialogs/Trefferpunkte.hbs" },

        FernkampfAttacke:       { template: "systems/dsa-4th-edition/src/Dialogs/FernkampfAttacke.hbs" },
        FernkampfTrefferpunkte: { template: "systems/dsa-4th-edition/src/Dialogs/FernkampfTrefferpunkte.hbs" },

        Trefferzone: { template: "systems/dsa-4th-edition/src/Dialogs/Trefferzone.hbs" },

        footer: { template: "templates/generic/form-footer.hbs" },
    };

    static DEFAULT_OPTIONS = {
        classes: [ "DSA41", "Dialog" ],
        window: {
            title: "Dialog",
            minimizable: false,
            resizable: false
        },
        tag: "form",
        form: {
            closeOnSubmit:  false,
            submitOnChange: true,
        }
    };

    get formData() {
        const inputs = this.element.querySelector("[data-application-part]")?.querySelectorAll("input") ?? [];
        const types  = Object.fromEntries(Array.from(inputs, x => [x.name, x.type]));
        const data = Object.fromEntries(
            new FormData(this.element).entries().map(([key, value])=>{
                if (types[key] == "number") return [key, Number(value)];
                return [key, value];
            })
        );

        return data;
    }

    buttons = [{
        type: "submit",
        label: "Confirm"
    }];

    static async wait(dialog_type, options) {
        return new Promise((resolve, reject) => {
            const dialog = new this({
                dialog_type: dialog_type,
                form: {
                    handler: (event, form, formData) => {
                        if (event.type != "submit") {
                            dialog.render({ force: false });
                            return;
                        }

                        dialog.close();
                        resolve(dialog.formData);
                    }
                },
                ...options,
             });
            dialog.render({ force: true });
        });
    }

    _configureRenderOptions(options) {
        super._configureRenderOptions(options);
        options.parts = [ this.options.dialog_type, "footer" ];
    }

    _onFirstRender(context, options) {
        this.render(options)
    }
}

class DSA41_ActorSheet extends DSA41_ApplicationMixin(ActorSheetV2) {
    static PARTS = {
        ActorSheet: { template: "systems/dsa-4th-edition/src/ActorSheet.hbs", scrollable: [".scroll-container"] },
    };

    static DEFAULT_OPTIONS = {
        classes: [ "DSA41", "ActorSheet" ],
        position: { width: "800", height: "650" },
        actions: {
            "roll": async function(event, target) {
                var   roll_formula  = event.target.closest("[data-roll]")?.dataset.roll;
                const roll_type     = event.target.closest("[data-roll-type]")?.dataset.rollType;
                const success_value = event.target.closest("[data-success-value]")?.dataset.successValue;
                const item_id = event.target.closest("[data-item-id]")?.dataset.itemId;
                const item = this.document.items.get(item_id);

                const hp_roll_modifier = this.document.get_hp_roll_modifier();

                let flavor = game.i18n.localize("DSA41.roll_types." + roll_type);
                if (typeof success_value !== 'undefined') {
                    flavor += " <= " + success_value;
                }

                if (roll_type == "courage"   || roll_type == "cleverness" || roll_type == "intuition"    || roll_type == "charisma" || 
                    roll_type == "dexterity" || roll_type == "agility"    || roll_type == "constitution" || roll_type == "strength") {
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + this.document.name;
                    const data = await DSA41_Dialog.wait("Eigenschaft", { window: { title: title }, attribute: this.document.system.attributes[roll_type] });

                    let flavor = game.i18n.localize("DSA41.roll_types." + roll_type);
                    if (typeof success_value !== 'undefined') {
                        flavor += " <= " + (Number(success_value) + data.modifikator);
                    }

                    if (hp_roll_modifier !== 0)
                        roll_formula = roll_formula + " + " + hp_roll_modifier;

                    let roll = new Roll(roll_formula, this.document.system);
                    roll.toMessage({
                        speaker: ChatMessage.getSpeaker({ actor: this.document }),
                        flavor: flavor,
                        flags: {
                            dsa41: {
                                type: roll_type,
                                targets: get_targeted_actors(),
                            } 
                        },
                    });

                    return;
                }

                if (roll_type == "talent") {
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + item.name;
                    const data  = await DSA41_Dialog.wait("Talent", { window: {title: title}, item: item });

                    const eBE = (await new Roll(item.system.behinderung || "0", { BE: this.document.system.computed.kampf.ruestungen_gesamt.gesamt_behinderung }).evaluate()).total;
                    data.modifikator -= eBE;

                    const talentwert    = item.system.talentwert + data.modifikator;
                    const roll_modifier = talentwert < 0 ? -talentwert: 0;
                    
                    if (hp_roll_modifier !== 0)
                        roll_modifier += hp_roll_modifier;

                    const roll1 = (await new Roll("1d20").evaluate()).total + roll_modifier;
                    const roll2 = (await new Roll("1d20").evaluate()).total + roll_modifier;
                    const roll3 = (await new Roll("1d20").evaluate()).total + roll_modifier;

                    const attribute1 = this.document.system.computed.attributes[item.system.attribute1];
                    const attribute2 = this.document.system.computed.attributes[item.system.attribute2];
                    const attribute3 = this.document.system.computed.attributes[item.system.attribute3];

                    const needed_taw_roll1 = Math.max(roll1 - attribute1, 0);
                    const needed_taw_roll2 = Math.max(roll2 - attribute2, 0);
                    const needed_taw_roll3 = Math.max(roll3 - attribute3, 0);

                    const leftover_taw = Math.max(talentwert, 0) - needed_taw_roll1 - needed_taw_roll2 - needed_taw_roll3;

                    const context = {
                        talent: item,
                        modifikator: data.modifikator,

                        attribute1: { type: item.system.attribute1, value: attribute1 },
                        attribute2: { type: item.system.attribute2, value: attribute2 },
                        attribute3: { type: item.system.attribute3, value: attribute3 },

                        roll1: roll1,
                        roll2: roll2,
                        roll3: roll3,

                        needed_taw_roll1: -needed_taw_roll1,
                        needed_taw_roll2: -needed_taw_roll2,
                        needed_taw_roll3: -needed_taw_roll3,

                        leftover_taw: Math.min(leftover_taw, item.system.talentwert),
                    };

                    const message = await ChatMessage.create(
                        {
                            content: await renderTemplate("talent_chat", context),
                            speaker: { actor: this.actor },
                            sound:   CONFIG.sounds.dice,
                        },
                    );

                    return;
                }

                if (roll_type == "attacke") {
                    const item  = this.document.system.computed.kampf.waffen[item_id];
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + item.name;
                    const data  = await DSA41_Dialog.wait("Attacke", { window: { title: title }, item: item });
                    
                    let flavor = game.i18n.localize("DSA41.roll_types." + roll_type);
                    if (typeof success_value !== 'undefined') {
                        flavor += " <= " + (Number(success_value) + data.modifikator);
                    }

                    if (data.anmerkung) {
                        flavor += "<br>" + data.anmerkung; 
                    }

                    if (hp_roll_modifier !== 0)
                        roll_formula = roll_formula + " + " + hp_roll_modifier;

                    let roll = new Roll(roll_formula, this.document.system);
                    roll.toMessage({
                        speaker: ChatMessage.getSpeaker({ actor: this.document }),
                        flavor: flavor,
                        flags: {
                            dsa41: {
                                type: roll_type,
                                targets: get_targeted_actors(),
                            } 
                        },
                    });

                    return;
                }
                
                if (roll_type == "parade") {
                    const item = this.document.system.computed.kampf.waffen[item_id];
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + item.name;
                    const data = await DSA41_Dialog.wait("Parade", { window: { title: title }, item: item });

                    let flavor = game.i18n.localize("DSA41.roll_types." + roll_type);
                    flavor += " <= " + (Number((data.crit == "on") ? item.parade_crit : item.parade) + data.modifikator);

                    if (data.anmerkung) {
                        flavor += "<br>" + data.anmerkung; 
                    }

                    if (hp_roll_modifier !== 0)
                        roll_formula = roll_formula + " + " + hp_roll_modifier;

                    let roll = new Roll(roll_formula, this.document.system);
                    roll.toMessage({
                        speaker: ChatMessage.getSpeaker({ actor: this.document }),
                        flavor: flavor,
                        flags: {
                            dsa41: {
                                type: roll_type,
                                targets: get_targeted_actors(),
                            } 
                        },
                    });

                    return;
                }
                
                if (roll_type == "trefferpunkte") {
                    const item = this.document.system.computed.kampf.waffen[item_id];
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + item.name;
                    const data = await DSA41_Dialog.wait("Trefferpunkte", { window: { title: title }, item: item });
                    
                    if (data.crit == "on") {
                        roll_formula = "2 * (" + item.item.system.nahkampfwaffe.basis + ")" + " + " + item.tp_kk;
                    }

                    let roll = new Roll(roll_formula + " + " + data.modifikator, this.document.system);
                    roll.toMessage({
                        speaker: ChatMessage.getSpeaker({ actor: this.document }),
                        flavor: flavor,
                        flags: {
                            dsa41: {
                                type: roll_type,
                                targets: get_targeted_actors(),
                            } 
                        },
                    });

                    return;
                }
    
                if (roll_type == "fernkampf-attacke") {
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + item.name;
                    const data = await DSA41_Dialog.wait("FernkampfAttacke", { window: { title: title }, item: this.document.system.computed.kampf.fernkampf_waffen[item_id] });

                    const groessen_modifikator = Math.max(data.ziel_groesse + data.deckung + data.ziel_bewegung, -2);
                    const andere_modifikator   = data.entfernung + data.wind + data.modifikator;

                    const total_modifikator = groessen_modifikator + andere_modifikator + hp_roll_modifier;

                    let roll = new Roll(roll_formula + " + " + total_modifikator, this.document.system);
                    roll.toMessage({
                        speaker: ChatMessage.getSpeaker({ actor: this.document }),
                        flavor: game.i18n.localize("DSA41.roll_types." + roll_type),
                        flags: {
                            dsa41: {
                                type: roll_type,
                                targets: get_targeted_actors(),
                            } 
                        },
                    });

                    return;
                }

                if (roll_type == "fernkampf-trefferpunkte") {
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + item.name;
                    const data = await DSA41_Dialog.wait("FernkampfTrefferpunkte", { window: { title: title }, item: this.document.system.computed.kampf.fernkampf_waffen[item_id] });
                    const entfernung = item.system.fernkampfwaffe[data.entfernung];

                    if (data.crit == "on") {
                        roll_formula = "2 * (" + roll_formula + ")";
                    }

                    let roll = new Roll(roll_formula + " + " + (entfernung + data.modifikator), this.document.system);
                    roll.toMessage({
                        speaker: ChatMessage.getSpeaker({ actor: this.document }),
                        flavor: game.i18n.localize("DSA41.roll_types." + roll_type),
                        flags: {
                            dsa41: {
                                type: roll_type,
                                targets: get_targeted_actors(),
                            } 
                        },
                    });

                    return;
                }

                if (roll_type == "zauber") {
                    const title = game.i18n.localize("DSA41.roll_types." + roll_type) + ": " + item.name;
                    const data  = await DSA41_Dialog.wait("Zauber", { window: {title: title}, item: item });

                    const zauberfertigkeitswert = item.system.zauberfertigkeitswert - data.modifikator - (data.magieresistenz ?? null);
                    const roll_modifier         = zauberfertigkeitswert < 0 ? -zauberfertigkeitswert: 0;

                    if (hp_roll_modifier !== 0)
                        roll_modifier += hp_roll_modifier;

                    const roll1 = (await new Roll("1d20").evaluate()).total + roll_modifier;
                    const roll2 = (await new Roll("1d20").evaluate()).total + roll_modifier;
                    const roll3 = (await new Roll("1d20").evaluate()).total + roll_modifier;

                    const attribute1 = this.document.system.computed.attributes[item.system.attribute1];
                    const attribute2 = this.document.system.computed.attributes[item.system.attribute2];
                    const attribute3 = this.document.system.computed.attributes[item.system.attribute3];

                    const needed_zfw_roll1 = Math.max(roll1 - attribute1, 0);
                    const needed_zfw_roll2 = Math.max(roll2 - attribute2, 0);
                    const needed_zfw_roll3 = Math.max(roll3 - attribute3, 0);

                    const leftover_zfw = Math.max(zauberfertigkeitswert, 0) - needed_zfw_roll1 - needed_zfw_roll2 - needed_zfw_roll3;

                    const context = {
                        zauber: item,

                        modifikator:    -data.modifikator,
                        magieresistenz: -(data.magieresistenz ?? 0),

                        attribute1: { type: item.system.attribute1, value: attribute1 },
                        attribute2: { type: item.system.attribute2, value: attribute2 },
                        attribute3: { type: item.system.attribute3, value: attribute3 },

                        roll1: roll1,
                        roll2: roll2,
                        roll3: roll3,

                        needed_zfw_roll1: -needed_zfw_roll1,
                        needed_zfw_roll2: -needed_zfw_roll2,
                        needed_zfw_roll3: -needed_zfw_roll3,

                        leftover_zfw: Math.min(leftover_zfw, item.system.zauberfertigkeitswert),
                    };

                    const message = await ChatMessage.create(
                        {
                            content: await renderTemplate("zauber_chat", context),
                            speaker: { actor: this.actor },
                            sound:   CONFIG.sounds.dice,
                        },
                    );

                    return;
                }

                let roll = new Roll(roll_formula, this.document.system);
                roll.toMessage({
                    speaker: ChatMessage.getSpeaker({ actor: this.document }),
                    flavor: flavor,
                    flags: {
                        dsa41: {
                            type: roll_type,
                            targets: get_targeted_actors(),
                        } 
                    },
                });
            },

            "item-open": async function(event, target) {
                const item_id = event.target.closest("[data-item-id]").dataset.itemId;
                const item = this.document.items.get(item_id);
                item.sheet.render(true)
            },

            "item-delete": async function(event, target) {
                const item_id = event.target.closest("[data-item-id]").dataset.itemId;
                const item = this.document.items.get(item_id);
                item.delete();
            },

            "toggle_equipped": async function(event, target) {
                const item_id = event.target.closest("[data-item-id]").dataset.itemId;
                const item = this.document.items.get(item_id);
                item.update({ "system.angelegt": !item.system.angelegt });
            },

            "post-zauber": async function(event, target) {
                const item_id = event.target.closest("[data-item-id]").dataset.itemId;
                const item = this.document.items.get(item_id);
                
                ChatMessage.create({
                    speaker: ChatMessage.getSpeaker({ actor: this.document }),
                    author: game.user.id,
                    sound: CONFIG.sounds.dice,
                    content: item.system.beschreibung,
                });
            },

            "toggle-wound": async function(event, target) {
                const location      = event.target.closest("[data-location]").dataset.location;
                const current_count = this.document.system.wunden[location];
                const toggled_count = Array.prototype.indexOf.call(event.target.parentNode.children, event.target) + 1;
                this.document.update({ ["system.wunden." + location]: toggled_count > current_count ? toggled_count : toggled_count - 1 });
            }
        },
    };

    // allow changing embedded item fields
    async _onChangeForm(formConfig, event) {
        const item_id   = event.target.closest("[data-item-id]")?.dataset.itemId;
        const data_name = event.target.dataset.name;
        if (!item_id || !data_name) return super._onChangeForm(formConfig, event);

        event.stopImmediatePropagation();
        const item  = await this.actor.items.get(item_id);
        const value = event.target.value;
        item.update({ [data_name]: value });
    }

    tabGroups = { primary: "eigenschaften" };
}

class DSA41_ItemSheetV2 extends DSA41_ApplicationMixin(ItemSheetV2) {
    static PARTS = {
        Bewaffnung:       { template: "systems/dsa-4th-edition/src/ItemSheets/Bewaffnung.hbs" },
        Gegenstand:       { template: "systems/dsa-4th-edition/src/ItemSheets/Gegenstand.hbs" },
        Ruestung:         { template: "systems/dsa-4th-edition/src/ItemSheets/Ruestung.hbs" },
        Talent:           { template: "systems/dsa-4th-edition/src/ItemSheets/Talent.hbs" },
        Kampftalent:      { template: "systems/dsa-4th-edition/src/ItemSheets/Kampftalent.hbs" },
        Sonderfertigkeit: { template: "systems/dsa-4th-edition/src/ItemSheets/Sonderfertigkeit.hbs" },
        VorNachteil:      { template: "systems/dsa-4th-edition/src/ItemSheets/VorNachteil.hbs" },
        Zauber:           { template: "systems/dsa-4th-edition/src/ItemSheets/Zauber.hbs" },
    };

    static DEFAULT_OPTIONS = {
        position: { width: "600", height: "auto" },
    };

    tabGroups = { primary: "tab1" };

    _configureRenderOptions(options) {
        super._configureRenderOptions(options);
        options.parts = [ this.options.document.type ];
    }
}