//One universal basic required here to get things going once loaded
window.onload = function () {
    //restoreDefaultValues(); //Un-comment this if you want to start with defaults
    Main();
};

//Main() is hard wired as THE place to start calculating when inputs change
//It does no calculations itself, it merely sets them up, sends off variables, gets results and, if necessary, plots them.
function Main() {
    //Save settings every time you calculate, so they're always ready on a reload
    saveSettings();

    //Send all the inputs as a structured object
    //If you need to convert to, say, SI units, do it here!
    const inputs = {
        mus: sliders.SlidemuStatic.value,
        muk: sliders.SlidemuKinetic.value,
        N: sliders.SlideLoad.value,
        tmax: sliders.Slidet.value,
        c: sliders.Slidec.value,
        eta: sliders.Slideeta.value,
        v0: sliders.Slidev0.value,
        va: sliders.Slideva.value,
        vb: sliders.Slidevb.value,
        tau: sliders.Slidetau.value,
        D: sliders.SlideD.value
    };

    //Send inputs off to CalcIt where the names are instantly available
    //Get all the resonses as an object, result
    console.time("time")

    const result = CalcIt(inputs);

    //Set all the text box outputs
    document.getElementById('Frequency').value = result.freq;
    // document.getElementById('Solid').value = result.sInfo;
    //Do all relevant plots by calling plotIt - if there's no plot, nothing happens
    //plotIt is part of the app infrastructure in app.new.js
    if (result.plots) {
        for (let i = 0; i < result.plots.length; i++) {
            plotIt(result.plots[i], result.canvas[i]);
        }
    }

    console.timeEnd("time")
    //You might have some other stuff to do here, but for most apps that's it for Main!
}

//Here's the app calculation
//The inputs are just the names provided - their order in the curly brackets is unimportant!
//By convention the input values are provided with the correct units within Main
function CalcIt({ mus, muk, N, tmax, c, eta, v0, va, vb, tau, D }) {

    let FPts = [], TPts = [], FkPts = [], x = 0, v = 0, accel = 0, theta = 1, Fvt = 0, Fkv = 0
    let pNext = 0
    const Fk = N * muk, Fs = N * mus
    const tStep = 0.001
    const pStep = Math.max(tStep, tmax / 200)
    const resFrequency = Math.sqrt(c / N)
    for (let t = 0; t <= tmax; t += tStep) {
        theta += (1 - theta) / tau - v / D
        theta = Math.min(1, Math.max(theta, 0))
        Fkv = Math.max(0, Fk * (1 + va * Math.abs(v) + vb * Math.pow(v - v0, 2)))
        Fvt = Fkv + (Fs - Fkv) * theta
        accel = (c * v0 * t + eta * v0 - Fvt - eta * v - c * x) / N
        v += accel * tStep
        x += v * tStep
        if (v < 0) v = 0
        if (t >= pNext) {
            FPts.push({ x: t, y: v / v0 })
            TPts.push({ x: t, y: theta })
            FkPts.push({ x: t, y: Fkv / Fk })
            pNext += pStep
        }
    }
    //Now we return everything - text boxes, plot and the name of the canvas, which is 'canvas' for a single plot
    const prmap = {
        plotData: [FPts, TPts, FkPts], //An array of 1 or more datasets
        lineLabels: ["v/v0", "θ", "Fk/Fk0"], //An array of labels for each dataset
        xLabel: 't&s', //Label for the x axis, with an & to separate the units
        yLabel: 'Relative values& ', //Label for the y axis, with an & to separate the units
        y2Label: null, //Label for the y2 axis, null if not needed
        yAxisL1R2: [], //Array to say which axis each dataset goes on. Blank=Left=1
        logX: false, //Is the x-axis in log form?
        xTicks: undefined, //We can define a tick function if we're being fancy
        logY: false, //Is the y-axis in log form?
        yTicks: undefined, //We can define a tick function if we're being fancy
        legendPosition: 'top', //Where we want the legend - top, bottom, left, right
        xMinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
        yMinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
        y2MinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
        xSigFigs: 'P3', //These are the sig figs for the Tooltip readout. A wide choice!
        ySigFigs: 'P3', //F for Fixed, P for Precision, E for exponential

    }
    return {
        freq: (resFrequency / (2 * Math.PI)).toFixed(2) + "Hz, " + resFrequency.toFixed(2) + "rad/s",
        plots: [prmap],
        canvas: ['canvas'],
    };
}