/**
 * @readonly
 *
 * @enum {string}
 */
export const FrameType = {

    /**
     * ╔════════════╗
     * ║ Hello, TUI ║
     * ╚════════════╝
     *
     * @type {string} Double-lined frame
     */
    Double: "Double",

    /**
     * ┌────────────┐
     * │ Hello, TUI │
     * └────────────┘
     *
     * @type {string} Single-lined frame
     */
    Single: "Single",


    /**
     *
     *   Hello, TUI
     *
     *
     * @type {string} Double-lined frame
     */
    Invisible: "Invisible",


    /**
     * (            )
     * ( Hello, TUI )
     * (            )
     *
     * @type {string} Double-lined frame
     */
    Parentheses: "Parentheses",

    /**
     * +------------+
     * | Hello, TUI |
     * +------------+
     *
     * @type {string} Double-lined frame
     */
    Basic: "Basic",


    /**
     * @protected
     * Default values for the common frame types.
     *
     * [north, south, east, west, northwest, northeast, southwest, southeast]
     */
    values: {
        Basic: "--||++++",
        Double: "══║║╔╗╚╝",
        Invisible: "        ",
        Parentheses: "  ()    ",
        Single: "──││┌┐└┘",
    }
}

export class FramingOptions {
    /** @type {number=0} Vertical Padding; number of vertical whitespace (newlines) between the text and the frame. */
    vPadding = 0;

    /** @type {number=0} Margin ; number of newlines to to insert before and after the framed text */
    vMargin = 0;

    /** @type {number=0} Horizontal Padding; number of whitespace characters to insert between the text and the sides of the frame. */
    hPadding = 0;

    /** @type {number=0} Margin ; number of newlines to to insert before and after the text, but inside the frame */
    hMargin = 0;

    /** @type {FrameType=FrameType.Double} Type of frame to put around the text */
    frameType = FrameType.Double;

    /** @type {number=0} Pad each line to become at least this long */
    minLineWidth = 0;

    // Light block: ░ (U+2591)
    // Medium block: ▒ (U+2592)
    // Dark block: ▓ (U+2593)
    // Solid block: █ (U+2588)
    /** @type {string} Single character to use as filler inside the frame. */
    paddingChar = " "; // character used for padding inside the frame.

    /** @type {string} Single character to use as filler outside the frame. */
    marginChar = " ";

    /** @type {string} The 8 characters that make up the frame elements */
    frameChars = FrameType.values.Double;

    /**
     * @param {object} o
     * @returns {FramingOptions}
     */
    static fromObject(o) {
        const result = new FramingOptions();

        result.vPadding = Math.max(0, Number.parseInt(o.vPadding) || 0);
        result.hPadding = Math.max(0, Number.parseInt(o.hPadding) || 0);
        result.vMargin = Math.max(0, Number.parseInt(o.vMargin) || 0);
        result.hMargin = Math.max(0, Number.parseInt(o.hMargin) || 0);
        result.minLineWidth = Math.max(0, Number.parseInt(o.hMargin) || 0);

        result.paddingChar = String(o.paddingChar || " ")[0] || " ";
        result.marginChar = String(o.marginChar || " ")[0] || " ";

        //
        // Do we have custom and valid frame chars?
        if (typeof o.frameChars === "string" && o.frameChars.length === FrameType.values.Double.length) {
            result.frameChars = o.frameChars;

            //
            // do we have document frame type instead ?
        } else if (o.frameType && FrameType.hasOwnProperty(o.frameType)) {
            result.frameChars = FrameType.values[o.frameType];

            // Fall back to using "Double" frame
        } else {
            result.frameChars = FrameType.values.Double;
        }


        return result;
    }
}

/**
 * @param {string|string[]} text the text to be framed. If array, each element will be treated as one line, and they are joined so the whole is to be framed.
 * @param {FramingOptions} options
 */
export function frameText(text, options) {

    if (!options) {
        options = new FramingOptions();
    }

    if (!(options instanceof FramingOptions)) {
        options = FramingOptions.fromObject(options);
    }

    // There is a point to this; each element in the array may contain newlines,
    // so we have to combine everything into a long text and then split into
    // individual lines afterwards.
    if (Array.isArray(text)) {
        text = text.join("\n");
    }

    if (typeof text !== "string") {
        console.debug(text);
        throw new Error(`text argument was neither an array or a string, it was a  ${typeof text}`);
    }

    /** @type {string[]} */
    const lines = text.split("\n");

    const innerLineLength = Math.max(
        lines.reduce((accumulator, currentLine) => {
            if (currentLine.length > accumulator) {
                return currentLine.length;
            }
            return accumulator;
        }, 0), options.minLineWidth);

    const frameThickness = 1; // always 1 for now.

    const outerLineLength = 0
        + innerLineLength
        + frameThickness * 2
        + options.hPadding * 2
        + options.hMargin * 2;

    // get the frame characters from the frameType.
    let [
        fNorth,             // horizontal frame top lines
        fSouth,             // horizontal frame bottom lines
        fWest,              // vertical frame lines on the left side
        fEast,              // vertical frame lines on the right side
        fNorthWest,         // upper left frame corner
        fNorthEast,         // upper right frame corner
        fSouthWest,         // lower left frame corner
        fSouthEast,         // lower right frame corner
    ] = options.frameChars.split("");
    if (fNorth === "§") { fNorth  = ""; }
    if (fSouth === "§") { fSouth  = ""; }
    if (fEast === "§") { fEast  = ""; }
    if (fWest === "§") { fWest  = ""; }
    if (fNorthEast === "§") { fNorthEast  = ""; }
    if (fSouthEast === "§") { fSouthEast  = ""; }
    if (fNorthWest === "§") { fNorthWest  = ""; }
    if (fSouthWest === "§") { fSouthWest  = ""; }

    let output = "";

    //
    // GENERATE THE MARGIN SPACE ABOVE THE FRAMED TEXT
    //
    //  ( we insert space characters even though  )
    //  ( they wouldn't normally be visible. But  )
    //  ( Some fonts might allow us to see blank  )
    //  ( space, and what if we want to nest many )
    //  ( frames inside each other?               )
    //
    output += (options.marginChar.repeat(outerLineLength) + "\n").repeat(options.vMargin);


    //
    // GENERATE THE TOP PART OF THE FRAME
    //      ╔════════════╗
    //
    //
    output += "" // Make sure JS knows we're adding a string.
        + options.marginChar.repeat(options.hMargin)               // the margin before the frame starts
        + fNorthWest                                               // northwest frame corner
        + fNorth.repeat(innerLineLength + options.hPadding * 2)  // the long horizontal frame top bar
        + fNorthEast                                               // northeast frame corner
        + options.marginChar.repeat(options.hMargin)               // the margin after the frame ends
        + "\n";
    //
    // GENERATE UPPER PADDING
    //
    //    ║           ║
    //
    //  (the blank lines within the frame and above the text)
    output += (
        options.marginChar.repeat(options.hMargin)
        + fWest
        + options.paddingChar.repeat(innerLineLength + options.hPadding * 2)
        + fEast
        + options.marginChar.repeat(options.hMargin)
        + "\n"
    ).repeat(options.vPadding);

    //
    // GENERATE FRAMED TEXT SEGMENT
    //
    //    ║ My pretty ║
    //    ║ text here ║
    //
    // ( this could be done with a reduce() )
    //
    for (const line of lines) {
        output += "" // Make sure JS knows we're adding a string.
            + options.marginChar.repeat(options.hMargin)     // margin before frame
            + fWest                                          // vertical frame char
            + options.paddingChar.repeat(options.hPadding)   // padding before text
            + line.padEnd(innerLineLength, " ")              // The actual text. Pad it with normal space character, NOT custom space.
            + options.paddingChar.repeat(options.hPadding)   // padding after text
            + fEast                                          // vertical frame bar
            + options.marginChar.repeat(options.hMargin)     // margin after frame
            + "\n";
    }

    //
    // GENERATE LOWER PADDING
    //
    //    ║           ║
    //
    //  ( the blank lines within the )
    //  ( frame and below the text   )
    //
    //  ( this code is a direct      )
    //  ( repeat of the code that    )
    //  ( generates top padding      )
    output += (
        options.marginChar.repeat(options.hMargin)
        + fWest
        + options.paddingChar.repeat(innerLineLength + options.hPadding * 2)
        + fEast
        + options.marginChar.repeat(options.hMargin)
        + "\n"
    ).repeat(options.vPadding);


    //
    // GENERATE THE BOTTOM PART OF THE FRAME
    //
    //      ╚════════════╝
    //
    output += "" // Make sure JS knows we're adding a string.
        + options.marginChar.repeat(options.hMargin)               // the margin before the frame starts
        + fSouthWest                                               // northwest frame corner
        + fSouth.repeat(innerLineLength + options.hPadding * 2)  // the long horizontal frame top bar
        + fSouthEast                                               // northeast frame corner
        + options.marginChar.repeat(options.hMargin)               // the margin after the frame starts
        + "\n";

    //
    // GENERATE THE MARGIN SPACE BELOW THE FRAMED TEXT
    //
    //  ( we insert space characters even though  )
    //  ( they wouldn't normally be visible. But  )
    //  ( Some fonts might allow us to see blank  )
    //  ( space, and what if we want to nest many )
    //  ( frames inside each other?               )
    //
    output += (options.marginChar.repeat(outerLineLength) + "\n").repeat(options.vMargin);

    return output;
}

// Allow this script to be run directly from node as well as being included!
// https://stackoverflow.com/a/66309132/5622463