//One universal basic required here to get things going once loaded
let DoIt = true
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 = {
        RI1: sliders.SlideRI1.value,
        T1: sliders.SlideT1.value,
        RI2: sliders.SlideRI2.value,
        T2: sliders.SlideT2.value,
        RI3: sliders.SlideRI3.value,
        T3: sliders.SlideT3.value,
        RI4: sliders.SlideRI4.value,
        T4: sliders.SlideT4.value,
        RI5: sliders.SlideRI5.value,
        T5: sliders.SlideT5.value,
        RI6: sliders.SlideRI6.value,
        T6: sliders.SlideT6.value,
    };

    //Send inputs off to CalcIt where the names are instantly available
    //Get all the resonses as an object, result
    const result = CalcIt(inputs);

    //Set all the text box outputs
    document.getElementById('RI').value = result.RI;

    if (result.plots) {
        for (let i = 0; i < result.plots.length; i++) {
            plotIt(result.plots[i], result.canvas[i]);
        }
    }

    //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({ RI1, T1, RI2, T2, RI3, T3, RI4, T4, RI5, T5, RI6, T6 }) {
    let Texp = [], Tcalc = [], RI="Not calculated"
    let x = [], y = [], i = 0
    if (T1>0) {x.push(parseFloat(RI1));y.push(parseFloat(T1))}
    if (T2>0) {x.push(parseFloat(RI2));y.push(parseFloat(T2))}
    if (T3>0) {x.push(parseFloat(RI3));y.push(parseFloat(T3))}
    if (T4>0) {x.push(parseFloat(RI4));y.push(parseFloat(T4))}
    if (T5>0) {x.push(parseFloat(RI5));y.push(parseFloat(T5))}
    if (T6>0) {x.push(parseFloat(RI6));y.push(parseFloat(T6))}
    for (i = 0; i < x.length; i++) {
         Texp.push({ x: x[i], y: y[i] })
    }
    if (x.length>3) {
    //A=P[0],w=P[1],xc=P[2]
    PFunc = function (x, P) {
        return x.map(function (xi) {
            return P[0] * P[1] / (4 * Math.pow(xi - P[2], 2) + P[1] * P[1])
        })
    }
    var Parms = fminsearch(PFunc, [10, 0.2, 1.4], x, y, { maxIter: 1000 })
    for (i = 1.3; i <= 1.7; i += 0.01) {
        Tcalc.push({ x: i, y: Parms[0] * Parms[1] / (4 * Math.pow(i - Parms[2], 2) + Parms[1] * Parms[1]) })
    }
    RI = Parms[2].toFixed(3)
}
    //Now set up all the graphing data.
    //We use the amazing Open Source Chart.js, https://www.chartjs.org/
    //A lot of the sophistication is addressed directly here
    //But if you need something more, read the Chart.js documentation or search Stack Overflow
    const plotData = [Texp, Tcalc]
    const lineLabels = ["%Texp", "%Tcalc"]
    const myColors = ["blue", "orange"]
    const showLines = [false, true]; showPoints = [2, 0]
    //Now set up all the graphing data detail by detail.
    const prmap = {
        plotData: plotData, //An array of 1 or more datasets
        lineLabels: lineLabels, //An array of labels for each dataset
        colors: myColors, //An array of colors for each dataset
        hideLegend: false,
        showLines: showLines,
        showPoints: showPoints,
        borderWidth: [2],
        xLabel: 'RI&', //Label for the x axis, with an & to separate the units
        yLabel: '%T&', //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,
        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
    };

    //Now we return everything - text boxes, plot and the name of the canvas, which is 'canvas' for a single plot
    return {
        plots: [prmap],
        canvas: ['canvas'],
        RI: RI,
    };
}
function clearOldName() { //This is needed because otherwise you can't re-load the same file name!
    document.getElementById('Load').value = ""
}
function handleFileSelect(evt) {
    var f = evt.target.files[0];

    if (f) {
        var r = new FileReader();
        r.onload = function (e) {
            var data = e.target.result;
            LoadData(data)
        }
        r.readAsText(f);
    } else {
        return;
    }
}

//Load data from a chosen file
function LoadData(S) {
    Papa.parse(S, {
        download: false,
        header: true,
        skipEmptyLines: true,
        complete: papaCompleteFn,
        error: papaErrorFn
    })
}
function papaErrorFn(error, file) {
    console.log("Error:", error, file)
}
function papaCompleteFn() {
    var pData = arguments[0]
    fitData = []; scaleData = []; logData = []; lastFit = "", newFit = true
    if (pData.data.length < 3) return //Not a valid data file
    let maxY = 0, lastx = -1, xval = 0
    theData = []
    for (i = 0; i < pData.data.length; i++) {
        theRow = pData.data[i]
        if (theRow.t && theRow.Temp) {
            xval = parseFloat(theRow.t)
            yval = parseFloat(theRow.Temp)
            theData.push([xval, yval])
        }
    }
    if (theData.length < 5) {
        alert("There was something wrong with the data file")
        return //Invalid data
    }
    Main()
}
//The fitting routine
fminsearch = function (fun, Parm0, x, y, Opt) {
    if (!Opt) {
        Opt = {}
    };
    if (!Opt.maxIter) {
        Opt.maxIter = 1000
    };
    if (!Opt.step) { // initial step is 1/100 of initial value (remember not to use zero in Parm0)
        Opt.step = Parm0.map(function (p) {
            return p / 100
        });
        Opt.step = Opt.step.map(function (si) {
            if (si == 0) {
                return 1
            } else {
                return si
            }
        }); // convert null steps into 1's
    };
    if (!Opt.objFun) {
        Opt.objFun = function (y, yp) {
            return y.map(function (yi, i) {
                return Math.pow((yi - yp[i]), 2)
            }).reduce(function (a, b) {
                return a + b
            })
        }
    } //SSD

    var cloneVector = function (V) {
        return V.map(function (v) {
            return v
        })
    };
    var P0 = cloneVector(Parm0),
        P1 = cloneVector(Parm0);
    var n = P0.length;
    var step = Opt.step;
    var funParm = function (P) {
        return Opt.objFun(y, fun(x, P))
    } //function (of Parameters) to minimize multi-univariate screening
    let lastfP = 1e-19, newfP = 0
    for (var i = 0; i < Opt.maxIter; i++) {
        for (var j = 0; j < n; j++) { // take a step for each parameter
            P1 = cloneVector(P0);
            P1[j] += step[j];
            if (funParm(P1) < funParm(P0)) { // if parm value going in the righ direction
                step[j] = 1.2 * step[j]; // then go a little faster
                P0 = cloneVector(P1);
            } else {
                step[j] = -(0.5 * step[j]); // otherwiese reverse and go slower
            }
        }
        //Stop trying too hard
        newfP = funParm(P0)
        if (i > 1000 && newfP < lastfP && Math.abs((newfP - lastfP) / lastfP) < 1e-10) break
        lastfP = newfP
    }
    return P0
};