/**
 *  LogarithmPlotter - 2D plotter software to make BODE plots, sequences and distribution functions.
 *  Copyright (C) 2021-2024  Ad5001
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

import { Module } from "./common.mjs"
import { CanvasInterface, DialogInterface } from "./interface.mjs"
import { textsup } from "../utils.mjs"
import { Expression } from "../math/index.mjs"
import Latex from "./latex.mjs"
import Objects from "./objects.mjs"
import History from "./history.mjs"
import Settings from "./settings.mjs"

class CanvasAPI extends Module {
    /** @type {CanvasInterface} */
    #canvas = null
    /** @type {CanvasRenderingContext2D} */
    #ctx = null
    /** @type {{show(string, string, string)}} */
    #drawingErrorDialog = null
    
    
    constructor() {
        super("Canvas", {
            canvas: CanvasInterface,
            drawingErrorDialog: DialogInterface
        })
        
        /**
         *
         * @type {Object.<string, {expression: Expression, value: number, maxDraw: number}>}
         */
        this.axesSteps = {
            x: {
                expression: null,
                value: -1,
                maxDraw: -1
            },
            y: {
                expression: null,
                value: -1,
                maxDraw: -1
            }
        }
    }

    /**
     * Initialize the module.
     * @param {CanvasInterface} canvas
     * @param {{show(string, string, string)}} drawingErrorDialog
     */
    initialize({ canvas, drawingErrorDialog }) {
        super.initialize({ canvas, drawingErrorDialog })
        this.#canvas = canvas
        this.#drawingErrorDialog = drawingErrorDialog
    }

    get width() {
        if(!this.initialized) throw new Error("Attempting width before initialize!")
        return this.#canvas.width
    }

    get height() {
        if(!this.initialized) throw new Error("Attempting height before initialize!")
        return this.#canvas.height
    }

    /**
     * Minimum x of the diagram, provided from settings.
     * @returns {number}
     */
    get xmin() {
        if(!this.initialized) throw new Error("Attempting xmin before initialize!")
        return Settings.xmin
    }

    /**
     * Zoom on the x-axis of the diagram, provided from settings.
     * @returns {number}
     */
    get xzoom() {
        if(!this.initialized) throw new Error("Attempting xzoom before initialize!")
        return Settings.xzoom
    }

    /**
     * Maximum y of the diagram, provided from settings.
     * @returns {number}
     */
    get ymax() {
        if(!this.initialized) throw new Error("Attempting ymax before initialize!")
        return Settings.ymax
    }

    /**
     * Zoom on the y-axis of the diagram, provided from settings.
     * @returns {number}
     */
    get yzoom() {
        if(!this.initialized) throw new Error("Attempting yzoom before initialize!")
        return Settings.yzoom
    }

    /**
     * Label used on the x-axis, provided from settings.
     * @returns {string}
     */
    get xlabel() {
        if(!this.initialized) throw new Error("Attempting xlabel before initialize!")
        return Settings.xlabel
    }

    /**
     * Label used on the y-axis, provided from settings.
     * @returns {string}
     */
    get ylabel() {
        if(!this.initialized) throw new Error("Attempting ylabel before initialize!")
        return Settings.ylabel
    }

    /**
     * Width of lines that will be drawn into the canvas, provided from settings.
     * @returns {number}
     */
    get linewidth() {
        if(!this.initialized) throw new Error("Attempting linewidth before initialize!")
        return Settings.linewidth
    }

    /**
     * Font size of the text that will be drawn into the canvas, provided from settings.
     * @returns {number}
     */
    get textsize() {
        if(!this.initialized) throw new Error("Attempting textsize before initialize!")
        return Settings.textsize
    }

    /**
     * True if the canvas should be in logarithmic mode, false otherwise.
     * @returns {boolean}
     */
    get logscalex() {
        if(!this.initialized) throw new Error("Attempting logscalex before initialize!")
        return Settings.logscalex
    }

    /**
     * True if the x graduation should be shown, false otherwise.
     *  @returns {boolean}
     */
    get showxgrad() {
        if(!this.initialized) throw new Error("Attempting showxgrad before initialize!")
        return Settings.showxgrad
    }

    /**
     * True if the y graduation should be shown, false otherwise.
     * @returns {boolean}
     */
    get showygrad() {
        if(!this.initialized) throw new Error("Attempting showygrad before initialize!")
        return Settings.showygrad
    }

    /**
     * Max power of the logarithmic scaled on the x axis in logarithmic mode.
     * @returns {number}
     */
    get maxgradx() {
        if(!this.initialized) throw new Error("Attempting maxgradx before initialize!")
        return Math.min(
            309, // 10e309 = Infinity (beyond this land be dragons)
            Math.max(
                Math.ceil(Math.abs(Math.log10(this.xmin))),
                Math.ceil(Math.abs(Math.log10(this.px2x(this.width))))
            )
        )
    }

    //
    // Methods to draw the canvas
    //

    requestPaint() {
        if(!this.initialized) throw new Error("Attempting requestPaint before initialize!")
        this.#canvas.requestPaint()
    }

    /**
     * Redraws the entire canvas
     */
    redraw() {
        if(!this.initialized) throw new Error("Attempting redraw before initialize!")
        this.#ctx = this.#canvas.getContext("2d")
        this._computeAxes()
        this._reset()
        this._drawGrid()
        this._drawAxes()
        this._drawLabels()
        this.#ctx.lineWidth = this.linewidth
        for(let objType in Objects.currentObjects) {
            for(let obj of Objects.currentObjects[objType]) {
                this.#ctx.strokeStyle = obj.color
                this.#ctx.fillStyle = obj.color
                if(obj.visible)
                    try {
                        obj.draw(this)
                    } catch(e) {
                        // Drawing throws an error. Generally, it's due to a new modification (or the opening of a file)
                        console.error(e)
                        console.log(e.stack)
                        this.#drawingErrorDialog.show(objType, obj.name, e.message)
                        History.undo()
                    }
            }
        }
        this.#ctx.lineWidth = 1
    }

    /**
     * Calculates information for drawing gradations for axes.
     * @private
     */
    _computeAxes() {
        let exprY = new Expression(`x*(${Settings.yaxisstep})`)
        let y1 = exprY.execute(1)
        let exprX = new Expression(`x*(${Settings.xaxisstep})`)
        let x1 = exprX.execute(1)
        this.axesSteps = {
            x: {
                expression: exprX,
                value: x1,
                maxDraw: Math.ceil(Math.max(Math.abs(this.xmin), Math.abs(this.px2x(this.width))) / x1)
            },
            y: {
                expression: exprY,
                value: y1,
                maxDraw: Math.ceil(Math.max(Math.abs(this.ymax), Math.abs(this.px2y(this.height))) / y1)
            }
        }
    }

    /**
     * Resets the canvas to a blank one with default setting.
     * @private
     */
    _reset() {
        // Reset
        this.#ctx.fillStyle = "#FFFFFF"
        this.#ctx.strokeStyle = "#000000"
        this.#ctx.font = `${this.textsize}px sans-serif`
        this.#ctx.fillRect(0, 0, this.width, this.height)
    }

    /**
     * Draws the grid.
     * @private
     */
    _drawGrid() {
        this.#ctx.strokeStyle = "#C0C0C0"
        if(this.logscalex) {
            for(let xpow = -this.maxgradx; xpow <= this.maxgradx; xpow++) {
                for(let xmulti = 1; xmulti < 10; xmulti++) {
                    this.drawXLine(Math.pow(10, xpow) * xmulti)
                }
            }
        } else {
            for(let x = 0; x < this.axesSteps.x.maxDraw; x += 1) {
                this.drawXLine(x * this.axesSteps.x.value)
                this.drawXLine(-x * this.axesSteps.x.value)
            }
        }
        for(let y = 0; y < this.axesSteps.y.maxDraw; y += 1) {
            this.drawYLine(y * this.axesSteps.y.value)
            this.drawYLine(-y * this.axesSteps.y.value)
        }
    }

    /**
     * Draws the graph axes.
     * @private
     */
    _drawAxes() {
        this.#ctx.strokeStyle = "#000000"
        let axisypos = this.logscalex ? 1 : 0
        this.drawXLine(axisypos)
        this.drawYLine(0)
        let axisypx = this.x2px(axisypos) // X coordinate of Y axis
        let axisxpx = this.y2px(0) // Y coordinate of X axis
        // Drawing arrows
        this.drawLine(axisypx, 0, axisypx - 10, 10)
        this.drawLine(axisypx, 0, axisypx + 10, 10)
        this.drawLine(this.width, axisxpx, this.width - 10, axisxpx - 10)
        this.drawLine(this.width, axisxpx, this.width - 10, axisxpx + 10)
    }

    /**
     * Resets the canvas to a blank one with default setting.
     * @private
     */
    _drawLabels() {
        let axisypx = this.x2px(this.logscalex ? 1 : 0) // X coordinate of Y axis
        let axisxpx = this.y2px(0) // Y coordinate of X axis
        // Labels
        this.#ctx.fillStyle = "#000000"
        this.#ctx.font = `${this.textsize}px sans-serif`
        this.#ctx.fillText(this.ylabel, axisypx + 10, 24)
        let textWidth = this.#ctx.measureText(this.xlabel).width
        this.#ctx.fillText(this.xlabel, this.width - 14 - textWidth, axisxpx - 5)
        // Axis graduation labels
        this.#ctx.font = `${this.textsize - 4}px sans-serif`

        let txtMinus = this.#ctx.measureText("-").width
        if(this.showxgrad) {
            if(this.logscalex) {
                for(let xpow = -this.maxgradx; xpow <= this.maxgradx; xpow += 1) {
                    textWidth = this.#ctx.measureText("10" + textsup(xpow)).width
                    if(xpow !== 0)
                        this.drawVisibleText("10" + textsup(xpow), this.x2px(Math.pow(10, xpow)) - textWidth / 2, axisxpx + 16 + (6 * (xpow === 1)))
                }
            } else {
                for(let x = 1; x < this.axesSteps.x.maxDraw; x += 1) {
                    let drawX = x * this.axesSteps.x.value
                    let txtX = this.axesSteps.x.expression.simplify(x).toString().replace(/^\((.+)\)$/, "$1")
                    let textHeight = this.measureText(txtX).height
                    this.drawVisibleText(txtX, this.x2px(drawX) - 4, axisxpx + this.textsize / 2 + textHeight)
                    this.drawVisibleText("-" + txtX, this.x2px(-drawX) - 4, axisxpx + this.textsize / 2 + textHeight)
                }
            }
        }
        if(this.showygrad) {
            for(let y = 0; y < this.axesSteps.y.maxDraw; y += 1) {
                let drawY = y * this.axesSteps.y.value
                let txtY = this.axesSteps.y.expression.simplify(y).toString().replace(/^\((.+)\)$/, "$1")
                textWidth = this.#ctx.measureText(txtY).width
                this.drawVisibleText(txtY, axisypx - 6 - textWidth, this.y2px(drawY) + 4 + (10 * (y === 0)))
                if(y !== 0)
                    this.drawVisibleText("-" + txtY, axisypx - 6 - textWidth - txtMinus, this.y2px(-drawY) + 4)
            }
        }
        this.#ctx.fillStyle = "#FFFFFF"
    }

    //
    // Public functions
    //

    /**
     * Draws an horizontal line at x plot coordinate.
     * @param {number} x
     */
    drawXLine(x) {
        if(this.isVisible(x, this.ymax)) {
            this.drawLine(this.x2px(x), 0, this.x2px(x), this.height)
        }
    }

    /**
     * Draws an vertical line at y plot coordinate
     * @param {number} y
     * @private
     */
    drawYLine(y) {
        if(this.isVisible(this.xmin, y)) {
            this.drawLine(0, this.y2px(y), this.width, this.y2px(y))
        }
    }

    /**
     * Writes multiline text onto the canvas.
     * NOTE: The x and y properties here are relative to the canvas, not the plot.
     * @param {string} text
     * @param {number} x
     * @param {number} y
     */
    drawVisibleText(text, x, y) {
        if(x > 0 && x < this.width && y > 0 && y < this.height) {
            text.toString().split("\n").forEach((txt, i) => {
                this.#ctx.fillText(txt, x, y + (this.textsize * i))
            })
        }
    }

    /**
     * Draws an image onto the canvas.
     * NOTE: The x, y width and height properties here are relative to the canvas, not the plot.
     * @param {CanvasImageSource} image
     * @param {number} x
     * @param {number} y
     * @param {number} width
     * @param {number} height
     */
    drawVisibleImage(image, x, y, width, height) {
        this.#canvas.markDirty(Qt.rect(x, y, width, height))
        this.#ctx.drawImage(image, x, y, width, height)
    }

    /**
     * Measures the width and height of a multiline text that would be drawn onto the canvas.
     * @param {string} text
     * @returns {{width: number, height: number}}
     */
    measureText(text) {
        let theight = 0
        let twidth = 0
        let defaultHeight = this.textsize * 1.2 // Approximate but good enough!
        for(let txt of text.split("\n")) {
            theight += defaultHeight
            if(this.#ctx.measureText(txt).width > twidth) twidth = this.#ctx.measureText(txt).width
        }
        return { "width": twidth, "height": theight }
    }

    /**
     * Converts an x coordinate to its relative position on the canvas.
     * It supports both logarithmic and non-logarithmic scale depending on the currently selected mode.
     * @param {number} x
     * @returns {number}
     */
    x2px(x) {
        if(this.logscalex) {
            const logxmin = Math.log(this.xmin)
            return (Math.log(x) - logxmin) * this.xzoom
        } else
            return (x - this.xmin) * this.xzoom
    }

    /**
     * Converts an y coordinate to it's relative position on the canvas.
     * The y-axis not supporting logarithmic scale, it only supports linear conversion.
     * @param {number} y
     * @returns {number}
     */
    y2px(y) {
        return (this.ymax - y) * this.yzoom
    }

    /**
     * Converts an x px position on the canvas to it's corresponding coordinate on the plot.
     * It supports both logarithmic and non-logarithmic scale depending on the currently selected mode.
     * @param {number} px
     * @returns {number}
     */
    px2x(px) {
        if(this.logscalex) {
            return Math.exp(px / this.xzoom + Math.log(this.xmin))
        } else
            return (px / this.xzoom + this.xmin)
    }

    /**
     * Converts an x px position on the canvas to it's corresponding coordinate on the plot.
     * It supports both logarithmic and non logarithmic scale depending on the currently selected mode.
     * @param {number} px
     * @returns {number}
     */
    px2y(px) {
        return -(px / this.yzoom - this.ymax)
    }

    /**
     * Checks whether a plot point (x, y) is visible or not on the canvas.
     * @param {number} x
     * @param {number} y
     * @returns {boolean}
     */
    isVisible(x, y) {
        return (this.x2px(x) >= 0 && this.x2px(x) <= this.width) && (this.y2px(y) >= 0 && this.y2px(y) <= this.height)
    }

    /**
     * Draws a line from plot point (x1, y1) to plot point (x2, y2).
     * @param {number} x1
     * @param {number} y1
     * @param {number} x2
     * @param {number} y2
     */
    drawLine(x1, y1, x2, y2) {
        this.#ctx.beginPath()
        this.#ctx.moveTo(x1, y1)
        this.#ctx.lineTo(x2, y2)
        this.#ctx.stroke()
    }

    /**
     * Draws a dashed line from plot point (x1, y1) to plot point (x2, y2).
     * @param {number} x1
     * @param {number} y1
     * @param {number} x2
     * @param {number} y2
     * @param {number} dashPxSize
     */
    drawDashedLine(x1, y1, x2, y2, dashPxSize = 6) {
        this.#ctx.setLineDash([dashPxSize / 2, dashPxSize])
        this.drawLine(x1, y1, x2, y2)
        this.#ctx.setLineDash([])
    }

    /**
     * Renders latex markup ltxText to an image and loads it. Returns a dictionary with three values: source, width and height.
     * @param {string} ltxText
     * @param {string} color
     * @param {function(LatexRenderResult|{width: number, height: number, source: string})} callback
     */
    renderLatexImage(ltxText, color, callback) {
        const onRendered = (imgData) => {
            if(!this.#canvas.isImageLoaded(imgData.source) && !this.#canvas.isImageLoading(imgData.source)) {
                // Wait until the image is loaded to callback.
                this.#canvas.loadImage(imgData.source)
                this.#canvas.imageLoaders[imgData.source] = [callback, imgData]
            } else {
                // Callback directly
                callback(imgData)
            }
        }
        const prerendered = Latex.findPrerendered(ltxText, this.textsize, color)
        if(prerendered !== null)
            onRendered(prerendered)
        else
            Latex.requestAsyncRender(ltxText, this.textsize, color).then(onRendered)
    }

    //
    // Context methods
    //

    get font() {
        return this.#ctx.font
    }

    set font(value) {
        return this.#ctx.font = value
    }

    /**
     * Draws an act on the canvas centered on a point.
     * @param {number} x
     * @param {number} y
     * @param {number} radius
     * @param {number} startAngle
     * @param {number} endAngle
     * @param {boolean} counterclockwise
     */
    arc(x, y, radius, startAngle, endAngle, counterclockwise = false) {
        this.#ctx.beginPath()
        this.#ctx.arc(x, y, radius, startAngle, endAngle, counterclockwise)
        this.#ctx.stroke()
    }

    /**
     * Draws a filled circle centered on a point.
     * @param {number} x
     * @param {number} y
     * @param {number} radius
     */
    disc(x, y, radius) {
        this.#ctx.beginPath()
        this.#ctx.arc(x, y, radius, 0, 2 * Math.PI)
        this.#ctx.fill()
    }

    /**
     * Draws a filled rectangle onto the canvas.
     * @param {number} x
     * @param {number} y
     * @param {number} w
     * @param {number} h
     */
    fillRect(x, y, w, h) {
        this.#ctx.fillRect(x, y, w, h)
    }
}

/** @type {CanvasAPI} */
Modules.Canvas = Modules.Canvas || new CanvasAPI()
export default Modules.Canvas