'use strict';

var crypto = require('crypto');
var path = require('path');
var os = require('os');
var obsidian = require('obsidian');
var fs = require('fs');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var path__default = /*#__PURE__*/_interopDefaultLegacy(path);

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

const FIELD_DEFAULTS = {
    width: 600,
    height: 400,
    boundary_left: -10,
    boundary_right: 10,
    boundary_bottom: -7,
    boundary_top: 7,
};
class Dsl {
    constructor(equations, fields) {
        this.equations = equations;
        this.fields = Object.assign(Object.assign({}, FIELD_DEFAULTS), fields);
        Dsl.assert_sanity(this.fields);
        this.hash = crypto.createHash("sha256")
            .update(JSON.stringify(this))
            .digest("hex");
    }
    /** Check if the fields are sane, throws a `SyntaxError` if they aren't */
    static assert_sanity(fields) {
        // Ensure boundaries are complete and in order
        if (fields.boundary_left >= fields.boundary_right) {
            throw new SyntaxError(`Right boundary (${fields.boundary_right}) must be greater than left boundary (${fields.boundary_left})`);
        }
        if (fields.boundary_bottom >= fields.boundary_top) {
            throw new SyntaxError(`
                Top boundary (${fields.boundary_top}) must be greater than bottom boundary (${fields.boundary_bottom})
            `);
        }
    }
    static parse(source) {
        const split = source.split("---");
        let equations;
        let fields;
        switch (split.length) {
            case 0: {
                equations = [];
                break;
            }
            case 1: {
                equations = split[0].split("\n").filter(Boolean);
                break;
            }
            case 2: {
                // If there are two segments then we know the first one must contain the settings
                fields = split[0]
                    // Allow either a newline or semicolon as a delimiter
                    .split(/[;\n]+/)
                    .map((setting) => setting.trim())
                    // Remove any empty elements
                    .filter(Boolean)
                    // Split each field on the first equals sign to create the key=value pair
                    .map((setting) => {
                    const [key, ...value] = setting.split("=");
                    return [key, value.join("=")];
                })
                    .reduce((settings, [key, value]) => {
                    if (FIELD_DEFAULTS.hasOwnProperty(key)) {
                        if (!value) {
                            throw new SyntaxError(`Field '${key}' must have a value`);
                        }
                        // We can use the defaults to determine the type of each field
                        const field_v = FIELD_DEFAULTS[key];
                        const field_t = typeof field_v;
                        switch (field_t) {
                            case "number": {
                                const s = parseInt(value);
                                if (Number.isNaN(s)) {
                                    throw new SyntaxError(`Field '${key}' must have an integer value`);
                                }
                                settings[key] = s;
                                break;
                            }
                            case "string": {
                                settings[key] = value;
                                break;
                            }
                            case "object": {
                                const val = JSON.parse(value);
                                if (val.constructor === field_v.constructor) {
                                    settings[key] = val;
                                }
                                break;
                            }
                        }
                    }
                    else {
                        throw new SyntaxError(`Unrecognised field: ${key}`);
                    }
                    return settings;
                }, {});
                equations = split[1].split("\n").filter(Boolean);
                break;
            }
            default: {
                fields = {};
            }
        }
        if (!equations) {
            throw new SyntaxError("Too many segments");
        }
        return new Dsl(equations, fields);
    }
}

function renderError(err, el) {
    el.innerHTML = `
    <div style="padding: 20px; background-color: #f44336; color: white;">
        <strong>Desmos Graph Error:</strong> ${err}
    </div>`;
}

class Renderer {
    static render(args, settings, el, plugin) {
        const { fields, equations, hash } = args;
        // Calculate cache info for filesystem caching
        const vault_root = plugin.app.vault.adapter.basePath;
        const cache_dir = settings.cache_directory
            ? path__default['default'].isAbsolute(settings.cache_directory)
                ? settings.cache_directory
                : path__default['default'].join(vault_root, settings.cache_directory)
            : os.tmpdir();
        const cache_target = path__default['default'].join(cache_dir, `desmos-graph-${hash}.png`);
        // If this graph is in the cache then fetch it
        if (settings.cache) {
            if (settings.cache_location == "memory" &&
                hash in plugin.graph_cache) {
                const data = plugin.graph_cache[hash];
                const img = document.createElement("img");
                img.src = data;
                el.appendChild(img);
                return;
            }
            else if (settings.cache_location == "filesystem" &&
                fs.existsSync(cache_target)) {
                fs.promises.readFile(cache_target).then((data) => {
                    const b64 = "data:image/png;base64," +
                        Buffer.from(data).toString("base64");
                    const img = document.createElement("img");
                    img.src = b64;
                    el.appendChild(img);
                });
                return;
            }
        }
        const expressions = equations.map((equation) => {
            var _a;
            return `calculator.setExpression({
                    latex: "${equation.split("|")[0].replace("\\", "\\\\")}${((_a = equation.split("|")[1]) !== null && _a !== void 0 ? _a : "")
                .replace("{", "\\\\{")
                .replace("}", "\\\\}")
                .replace("<=", "\\\\leq ")
                .replace(">=", "\\\\geq ")
                .replace("<", "\\\\le ")
                .replace(">", "\\\\ge ")}",
                    
                    ${(() => {
                const mode = equation.split("|")[2];
                if (mode) {
                    if (["solid", "dashed", "dotted"].contains(mode.toLowerCase())) {
                        return `lineStyle: Desmos.Styles.${mode.toUpperCase()}`;
                    }
                    else if (["point", "open", "cross"].contains(mode.toLowerCase())) {
                        return `pointStyle: Desmos.Styles.${mode.toUpperCase()}`;
                    }
                }
                return "";
            })()}
                });`;
        });
        // Because of the electron sandboxing we have to do this inside an iframe,
        // otherwise we can't include the desmos API (although it would be nice if they had a REST API of some sort)
        const html_src_head = `<script src="https://www.desmos.com/api/v1.6/calculator.js?apiKey=dcb31709b452b1cf9dc26972add0fda6"></script>`;
        const html_src_body = `
            <div id="calculator" style="width: ${fields.width}px; height: ${fields.height}px;"></div>
            <script>
                const options = {
                    settingsMenu: false,
                    expressions: false,
                    lockViewPort: true,
                    zoomButtons: false,
                    trace: false,
                };

                const calculator = Desmos.GraphingCalculator(document.getElementById("calculator"), options);
                calculator.setMathBounds({
                    left: ${fields.boundary_left},
                    right: ${fields.boundary_right},
                    top: ${fields.boundary_top},
                    bottom: ${fields.boundary_bottom},
                });

                ${expressions.join("")}

                calculator.observe("expressionAnalysis", () => {
                    for (const id in calculator.expressionAnalysis) {
                        const analysis = calculator.expressionAnalysis[id];
                        if (analysis.isError) {
                            parent.postMessage({ t: "desmos-graph", d: "error", data: analysis.errorMessage, hash: "${hash}" });
                        }
                    }
                });

                calculator.asyncScreenshot({ showLabels: true, format: "png" }, (data) => {
                    document.body.innerHTML = "";
                    parent.postMessage({ t: "desmos-graph", d: "render", data, hash: "${hash}" }, "app://obsidian.md");
                });
            </script>
        `;
        const html_src = `<html><head>${html_src_head}</head><body>${html_src_body}</body>`;
        const iframe = document.createElement("iframe");
        iframe.width = fields.width.toString();
        iframe.height = fields.height.toString();
        iframe.style.border = "none";
        iframe.scrolling = "no"; // fixme use a non-depreciated function
        iframe.srcdoc = html_src;
        // iframe.style.display = "none"; //fixme hiding the iframe breaks the positioning
        el.appendChild(iframe);
        const handler = (message) => {
            if (message.origin === "app://obsidian.md" &&
                message.data.t === "desmos-graph" &&
                message.data.hash === hash) {
                el.empty();
                if (message.data.d === "error") {
                    renderError(message.data.data, el);
                }
                if (message.data.d === "render") {
                    const { data } = message.data;
                    window.removeEventListener("message", handler);
                    const img = document.createElement("img");
                    img.src = data;
                    el.appendChild(img);
                    if (settings.cache) {
                        if (settings.cache_location == "memory") {
                            plugin.graph_cache[hash] = data;
                        }
                        else if (settings.cache_location == "filesystem") {
                            if (fs.existsSync(cache_dir)) {
                                fs.promises.writeFile(cache_target, data.replace(/^data:image\/png;base64,/, ""), "base64").catch((err) => new obsidian.Notice(`desmos-graph: unexpected error when trying to cache graph: ${err}`, 10000));
                            }
                            else {
                                new obsidian.Notice(`desmos-graph: cache directory not found: '${cache_dir}'`, 10000);
                            }
                        }
                    }
                }
            }
        };
        window.addEventListener("message", handler);
    }
}

const DEFAULT_SETTINGS = {
    debounce: 500,
    cache: true,
    cache_location: "memory",
    cache_directory: null,
};
class SettingsTab extends obsidian.PluginSettingTab {
    constructor(app, plugin) {
        super(app, plugin);
        this.plugin = plugin;
    }
    display() {
        let { containerEl } = this;
        containerEl.empty();
        new obsidian.Setting(containerEl)
            .setName("Debounce Time (ms)")
            .setDesc("How long to wait after a keypress to render the graph (requires restart to take effect)")
            .addText((text) => text
            .setValue(this.plugin.settings.debounce.toString())
            .onChange((value) => __awaiter(this, void 0, void 0, function* () {
            const val = parseInt(value);
            this.plugin.settings.debounce =
                val === NaN ? DEFAULT_SETTINGS.debounce : val;
            yield this.plugin.saveSettings();
        })));
        new obsidian.Setting(containerEl)
            .setName("Cache")
            .setDesc("Whether to cache the rendered graphs")
            .addToggle((toggle) => toggle
            .setValue(this.plugin.settings.cache)
            .onChange((value) => __awaiter(this, void 0, void 0, function* () {
            this.plugin.settings.cache = value;
            yield this.plugin.saveSettings();
            // Reset the display so the new state can render
            this.display();
        })));
        if (this.plugin.settings.cache) {
            new obsidian.Setting(containerEl)
                .setName("Cache in memory (alternate: filesystem)")
                .setDesc("Cache rendered graphs in memory or on the filesystem (note that memory caching is not persistent).")
                .addToggle((toggle) => toggle
                .setValue(this.plugin.settings.cache_location === "memory"
                ? true
                : false)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.cache_location = value
                    ? "memory"
                    : "filesystem";
                yield this.plugin.saveSettings();
                // Reset the display so the new state can render
                this.display();
            })));
            if (this.plugin.settings.cache_location == "filesystem") {
                new obsidian.Setting(containerEl)
                    .setName("Cache Directory")
                    .setDesc("The directory to save cached graphs in (technical note: the graphs will be saved as `desmos-graph-<hash>.png` where the name is a SHA-256 hash of the graph source). The default directory is the system tempdir for your current operating system, and this value may be either a path relative to the root of your vault or an absolute path. Also note that a lot of junk will be saved to this folder, you have been warned.")
                    .addText((text) => text
                    .setPlaceholder(os.tmpdir())
                    .setValue(this.plugin.settings.cache_directory)
                    .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                    this.plugin.settings.cache_directory = value;
                    yield this.plugin.saveSettings();
                })));
            }
        }
    }
}

class Desmos extends obsidian.Plugin {
    onload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.graph_cache = {};
            yield this.loadSettings();
            this.addSettingTab(new SettingsTab(this.app, this));
            // Keep track of the total number of graphs in each file
            // This allows us to skip the debounce on recently opened files to make it feel snappier to use
            let total = 0;
            this.app.workspace.on("file-open", (file) => __awaiter(this, void 0, void 0, function* () {
                const contents = yield this.app.vault.cachedRead(file);
                // Attempt to figure out the number of graphs there are in this file
                // In this case it is fine if we overestimate because we only need a general idea since this just makes it skip the debounce
                total = (contents.match(/```desmos-graph/g) || []).length;
            }));
            const render = (source, el) => {
                try {
                    Renderer.render(Dsl.parse(source), this.settings, el, this);
                }
                catch (err) {
                    renderError(err.message, el);
                }
            };
            const debounce_render = obsidian.debounce((source, el) => render(source, el), this.settings.debounce);
            this.registerMarkdownCodeBlockProcessor("desmos-graph", (source, el) => {
                if (total > 0) {
                    total--;
                    // Skip the debounce on initial render
                    render(source, el);
                }
                else {
                    debounce_render(source, el);
                }
            });
        });
    }
    loadSettings() {
        return __awaiter(this, void 0, void 0, function* () {
            this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData());
        });
    }
    saveSettings() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.saveData(this.settings);
        });
    }
}

module.exports = Desmos;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/dsl.ts","src/error.ts","src/renderer.ts","src/settings.ts","src/main.ts"],"sourcesContent":null,"names":["createHash","path","tmpdir","existsSync","fs","Notice","PluginSettingTab","Setting","Plugin","debounce"],"mappings":"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"}