/**
 * A type of Roll specific to a damage (or healing) roll in the 5e system.
 * @param {string} formula                       The string formula to parse
 * @param {object} data                          The data object against which to parse attributes within the formula
 * @param {object} [options={}]                  Extra optional arguments which describe or modify the DamageRoll
 * @param {number} [options.criticalBonusDice=0]      A number of bonus damage dice that are added for critical hits
 * @param {number} [options.criticalMultiplier=2]     A critical hit multiplier which is applied to critical hits
 * @param {boolean} [options.multiplyNumeric=false]   Multiply numeric terms by the critical multiplier
 * @param {boolean} [options.powerfulCritical=false]  Apply the "powerful criticals" house rule to critical hits
 *
 */
export default class DamageRoll extends Roll {
    constructor(formula, data, options) {
        super(formula, data, options);
        // For backwards compatibility, skip rolls which do not have the "critical" option defined
        if (this.options.critical !== undefined) this.configureDamage();
    }

    /**
     * The HTML template path used to configure evaluation of this Roll
     * @type {string}
     */
    static EVALUATION_TEMPLATE = "systems/sw5e/templates/chat/roll-dialog.html";

    /* -------------------------------------------- */

    /**
     * A convenience reference for whether this DamageRoll is a critical hit
     * @type {boolean}
     */
    get isCritical() {
        return this.options.critical;
    }

    /* -------------------------------------------- */
    /*  Damage Roll Methods                         */
    /* -------------------------------------------- */

    /**
     * Apply optional modifiers which customize the behavior of the d20term
     * @private
     */
    configureDamage() {
        let flatBonus = 0;
        for (let [i, term] of this.terms.entries()) {
            // Multiply dice terms
            if (term instanceof DiceTerm) {
                term.options.baseNumber = term.options.baseNumber ?? term.number; // Reset back
                term.number = term.options.baseNumber;
                if (this.isCritical) {
                    let cm = this.options.criticalMultiplier ?? 2;

                    // Powerful critical - maximize damage and reduce the multiplier by 1
                    if (this.options.powerfulCritical) {
                        flatBonus += term.number * term.faces;
                        cm = Math.max(1, cm - 1);
                    }

                    // Alter the damage term
                    let cb = this.options.criticalBonusDice && i === 0 ? this.options.criticalBonusDice : 0;
                    term.alter(cm, cb);
                    term.options.critical = true;
                }
            }

            // Multiply numeric terms
            else if (this.options.multiplyNumeric && term instanceof NumericTerm) {
                term.options.baseNumber = term.options.baseNumber ?? term.number; // Reset back
                term.number = term.options.baseNumber;
                if (this.isCritical) {
                    term.number *= this.options.criticalMultiplier ?? 2;
                    term.options.critical = true;
                }
            }
        }

        // Add powerful critical bonus
        if (this.options.powerfulCritical && flatBonus > 0) {
            this.terms.push(new OperatorTerm({operator: "+"}));
            this.terms.push(
                new NumericTerm({number: flatBonus}, {flavor: game.i18n.localize("SW5E.PowerfulCritical")})
            );
        }

        // Re-compile the underlying formula
        this._formula = this.constructor.getFormula(this.terms);
    }

    /* -------------------------------------------- */

    /** @inheritdoc */
    toMessage(messageData = {}, options = {}) {
        messageData.flavor = messageData.flavor || this.options.flavor;
        if (this.isCritical) {
            const label = game.i18n.localize("SW5E.CriticalHit");
            messageData.flavor = messageData.flavor ? `${messageData.flavor} (${label})` : label;
        }
        options.rollMode = options.rollMode ?? this.options.rollMode;
        return super.toMessage(messageData, options);
    }

    /* -------------------------------------------- */
    /*  Configuration Dialog                        */
    /* -------------------------------------------- */

    /**
     * Create a Dialog prompt used to configure evaluation of an existing D20Roll instance.
     * @param {object} data                     Dialog configuration data
     * @param {string} [data.title]               The title of the shown dialog window
     * @param {number} [data.defaultRollMode]     The roll mode that the roll mode select element should default to
     * @param {string} [data.defaultCritical]     Should critical be selected as default
     * @param {string} [data.template]            A custom path to an HTML template to use instead of the default
     * @param {boolean} [data.allowCritical=true] Allow critical hit to be chosen as a possible damage mode
     * @param {object} options                  Additional Dialog customization options
     * @returns {Promise<D20Roll|null>}         A resulting D20Roll object constructed with the dialog, or null if the dialog was closed
     */
    async configureDialog(
        {title, defaultRollMode, defaultCritical = false, template, allowCritical = true} = {},
        options = {}
    ) {
        // Render the Dialog inner HTML
        const content = await renderTemplate(template ?? this.constructor.EVALUATION_TEMPLATE, {
            formula: `${this.formula} + @bonus`,
            defaultRollMode,
            rollModes: CONFIG.Dice.rollModes
        });

        // Create the Dialog window and await submission of the form
        return new Promise((resolve) => {
            new Dialog(
                {
                    title,
                    content,
                    buttons: {
                        critical: {
                            condition: allowCritical,
                            label: game.i18n.localize("SW5E.CriticalHit"),
                            callback: (html) => resolve(this._onDialogSubmit(html, true))
                        },
                        normal: {
                            label: game.i18n.localize(allowCritical ? "SW5E.Normal" : "SW5E.Roll"),
                            callback: (html) => resolve(this._onDialogSubmit(html, false))
                        }
                    },
                    default: defaultCritical ? "critical" : "normal",
                    close: () => resolve(null)
                },
                options
            ).render(true);
        });
    }

    /* -------------------------------------------- */

    /**
     * Handle submission of the Roll evaluation configuration Dialog
     * @param {jQuery} html             The submitted dialog content
     * @param {boolean} isCritical      Is the damage a critical hit?
     * @private
     */
    _onDialogSubmit(html, isCritical) {
        const form = html[0].querySelector("form");

        // Append a situational bonus term
        if (form.bonus.value) {
            const bonus = new Roll(form.bonus.value, this.data);
            if (!(bonus.terms[0] instanceof OperatorTerm)) this.terms.push(new OperatorTerm({operator: "+"}));
            this.terms = this.terms.concat(bonus.terms);
        }

        // Apply advantage or disadvantage
        this.options.critical = isCritical;
        this.options.rollMode = form.rollMode.value;
        this.configureDamage();
        return this;
    }

    /* -------------------------------------------- */

    /** @inheritdoc */
    static fromData(data) {
        const roll = super.fromData(data);
        roll._formula = this.getFormula(roll.terms);
        return roll;
    }
}