/**
 * @module tinfoboxHelperData
 * Helper structures for infoboxJournal.js, storing info about parameter choices, messages, etc.
 */
import * as util from '/w/index.php?title=User:Tokenzero/tinfoboxUtil.js&action=raw&ctype=text%2Fjavascript';
import { TemplateData, TemplateDataParam } from '/w/index.php?title=User:Tokenzero/tinfoboxTemplateData.js&action=raw&ctype=text%2Fjavascript';

/** Structure for parameter values and choices. */
export class ParamChoice {
    /**
     * @param {object} templateData
     */
    constructor(templateData) {
        /**
         * @constant
         * @type {TemplateDataParam}
         * Note this is also included in TemplateChoice.templateData (possibly as a deep copy).
         */
        this.templateData = templateData;
        /** @type {?string} */
        this.originalKey = null;
        /** @type {?string} */
        this.originalValue = null;
        /** @type {?string} */
        this.proposedValue = null;
        /** @type {boolean} */
        this.preferOriginal = true;
        /** @type {Array<{type: string, message: string}>} */
        this.messages = [];
    }

    /**
     * Serialize to simple object to be passed do JSON.stringify.
     *
     * @returns {object}
     */
    toJSON() {
        return {
            templateData: this.templateData, // Recursively toJSON'ed by JSON.stringify.
            originalKey: this.originalKey,
            originalValue: this.originalValue,
            proposedValue: this.proposedValue,
            preferOriginal: this.preferOriginal,
            messages: this.messages
        };
    }

    /**
     * Deserialize from simple object returned by JSON.parse.
     *
     * @param {object} jsonObject
     * @returns {ParamChoice}
     */
    static fromJSON(jsonObject) {
        const templateData = TemplateDataParam.fromJSON(jsonObject.templateData);
        delete jsonObject.templateData;
        return Object.assign(new ParamChoice(templateData), jsonObject);
    }

    /**
     * Return whether proposed value is empty or equal to original, default or autovalue.
     *
     * @returns {boolean}
     */
    isProposedValueTrivial() {
        return (
            (!this.proposedValue) ||
            (this.proposedValue === this.originalValue) ||
            (this.proposedValue === this.templateData.default) ||
            (this.proposedValue === this.templateData.autovalue) ||
            (!this.proposedValue && !this.templateData.autovalue)
        );
    }
}


/** Data to preserve after redirecting: ParamChoice-s and messages. */
export class TemplateChoice {
    /** @param {TemplateData} templateData */
    constructor(templateData) {
        /**
         * @constant
         * @type {TemplateData}
         * Note that templateData for params are also included in ParamChoices,
         * possibly as a deep copy.
         */
        this.templateData = templateData;
        /** @type {Map<string, ParamChoice>} from canonicalKey to its ParamChoice. */
        this.paramChoices = new Map();
        /** @type {Array<{type: string, message: string}>} messages about this template instance. */
        this.messages = [];
    }

    /**
     * Get or create ParamChoice for given canonicalKey.
     *
     * @param {string} canonicalKey
     * @returns {ParamChoice}
     */
    param(canonicalKey) {
        if (!this.paramChoices.has(canonicalKey)) {
            const paramChoice = new ParamChoice(this.templateData.param(canonicalKey));
            this.paramChoices.set(canonicalKey, paramChoice);
        }
        return this.paramChoices.get(canonicalKey);
    }


    /**
     * Serialize to object to be passed do JSON.stringify.
     *
     * @returns {object}
     */
    toJSON() {
        // JSON.stringify will recursively call .toJSON() in each entry.
        return {
            templateData: this.templateData,
            paramChoices: util.objectFromEntries(this.paramChoices.entries()),
            messages: this.messages
        };
    }

    /**
     * Deserialize from object returned by JSON.parse.
     *
     * @param {object} jsonObject
     * @returns {TemplateChoice}
     */
    static fromJSON(jsonObject) {
        const templateData = TemplateData.fromJSON(jsonObject.templateData);
        const result = new TemplateChoice(templateData);
        result.paramChoices = new Map(Object.entries(jsonObject.paramChoices).map(
            ([key, value]) => [key, ParamChoice.fromJSON(value)]
        ));
        result.messages = jsonObject.messages;
        return result;
    }

    /**
     * Build table listing parameters with their choices and messages.
     *
     * @returns {JQuery<HTMLElement>|''}
     */
    buildParamTable() {
        const changedList = [];
        const proposedList = [];
        const weaklySuggestedList = [];
        const otherList = [];
        const choices = this.templateData.reorder(this.paramChoices).entries();
        for (const [canonicalKey, pc] of choices) {
            if (pc.proposedValue === pc.originalValue && !pc.messages.length) {
                if (pc.proposedValue && pc.proposedValue.replace(/<!--[^>]*-->/g, '')) {
                    console.log(
                        `Param ${canonicalKey} guessed correctly as "${pc.proposedValue}".`);
                }
                continue;
            }
            if (pc.originalValue === pc.proposedValue)
                pc.preferOriginal = true;

            const row = $('<tr>');
            row.append($(`<td>${pc.originalKey || canonicalKey}=</td>`));
            if (typeof pc.originalValue === 'string')
                row.append($(`<td>${util.escapeHTML(pc.originalValue)}</td>`));
            else
                row.append($('<td>(absent)</td>').addClass('absent'));
            if (pc.preferOriginal)
                row.children().last().addClass('selected');
            if (typeof pc.proposedValue === 'string')
                row.append($(`<td>${util.escapeHTML(pc.proposedValue)}</td>`));
            else if (!pc.preferOriginal)
                row.append($('<td>(deleted)</td>').addClass('absent'));
            else
                row.append($('<td></td>').addClass('absent'));
            if (!pc.preferOriginal)
                row.children().last().addClass('selected');
            if (!pc.isProposedValueTrivial())
                row.children().last().addClass('nontrivial');
            const messageTd = $('<td>');
            const tooltip = $(`<span
                class="ext-tinfobox-tooltip"
                title="${util.escapeHTML(pc.templateData.description)}"
            />`);
            if (pc.templateData.description)
                messageTd.append(tooltip);
            const messageWidget = HelperData.buildMessagesWidget(pc.messages);
            if (messageWidget !== '')
                messageTd.append(messageWidget);
            else
                messageTd.addClass('empty');
            row.append(messageTd);

            if (!pc.preferOriginal)
                changedList.push(row);
            else if (!pc.isProposedValueTrivial())
                proposedList.push(row);
            else if ((pc.templateData.suggested || pc.templateData.weaklySuggested) &&
                     pc.originalValue === null)
                weaklySuggestedList.push(row);
            else if (pc.messages.length)
                otherList.push(row);
            // Else: we prefer original, proposed value is trivial and not suggested as addition,
            // and there are no messages, so we just don't show the param.
        }
        let rows = [];
        rows.push($(`<tr>
            <th></th><th>current value</th><th>new value/suggested</th><th></th>
        </tr>`));
        const makeHeadRow = (t) => $('<tr><th colspan="3">' + t + '</th></tr>');
        if (changedList.length) {
            rows.push(makeHeadRow('<strong>Changed parameters</strong> (please fill empty ones)'));
            rows = rows.concat(changedList);
        } else {
            rows.push(makeHeadRow('No parameters were changed.'));
        }
        if (proposedList.length) {
            rows.push(makeHeadRow('<strong>Suggested changes</strong> (currently unchanged)'));
            rows = rows.concat(proposedList);
        }
        if (weaklySuggestedList.length) {
            rows.push(makeHeadRow('<strong>Additional parameters</strong>' +
                ' (situational, omit by default)'));
            rows = rows.concat(weaklySuggestedList);
        }
        if (otherList.length) {
            rows.push(makeHeadRow('Other warnings'));
            rows = rows.concat(otherList);
        }
        return $('<table>').append(rows);
    }
}

/**
 * Data to pass after redirect, including TemplateChoice-s.
 */
export class HelperData {
    /** Constructor. */
    constructor() {
        /** @type {Array<TemplateChoice>} */
        this.templateChoices = [];
        /** @type {Array<{type: string, message: string}>} global messages. */
        this.messages = [];
    }

    /**
     * Serialize to JSON string.
     *
     * @returns {string}
     */
    toJSONString() {
        return JSON.stringify({
            templateChoices: this.templateChoices,
            messages: this.messages
        });
    }

    /**
     * Deserialize from JSON string to new HelperData object.
     *
     * @param {string} json
     * @returns {HelperData}
     */
    static fromJSONString(json) {
        const result = Object.assign(new HelperData(), JSON.parse(json));
        result.templateChoices = result.templateChoices.map(
            (x) => TemplateChoice.fromJSON(x)
        );
        return result;
    }

    /**
     * Create jQuery object showing a list of messages.
     *
     * @param {Array<{type: string, message: string}>} messages
     * @returns {JQuery|''}
     */
    static buildMessagesWidget(messages) {
        if (!messages || !messages.length)
            return '';
        const result = $('<ul></ul>');
        for (const m of messages) {
            const entry = $('<li>');
            entry.text(m.message);
            entry.prepend(`<b>${m.type}</b>: `);
            result.append(entry);
        }
        return result;
    }

    /**
     * Build a box describing helperData (prefilled parameters and such).
     *
     * @returns {JQuery<HTMLElement>}
     */
    buildWidget() {
        const widget = $(`
            <div class="ext-tinfobox-helper">
                <h2>infoboxJournal.js</h2>
            </div>
        `);
        let globalMessages = this.messages;
        if (this.templateChoices.length === 1)
            globalMessages = globalMessages.concat(this.templateChoices[0].messages);
        widget.append(HelperData.buildMessagesWidget(globalMessages));

        const many = (this.templateChoices.length > 1);
        for (const [tcIndex, tc] of this.templateChoices.entries()) {
            if (many) {
                widget.append($(`<h3>Template #${tcIndex + 1}</h3>`));
                widget.append(HelperData.buildMessagesWidget(tc.messages));
            }
            widget.append(tc.buildParamTable());
        }

        return widget;
    }
}