SedimentDataExplorer.js

    let testOne = {};
    let radarPlot = "None";
    let resuspensionSize = 0;
    let kmlLayers = {};
    let chosenStandard = 'Proposed Cefas Action Levels';
//    let chosenStandard = "Candian Quality Guidelines";
//		import {parse, stringify, toJSON, fromJSON} from 'flatted';
    const autocolors = window['chartjs-plugin-autocolors'];
    Chart.register(autocolors);
    const annotationPlugin = window['chartjs-plugin-annotation'];
    Chart.register(annotationPlugin);
    // Importing the necessary library for coordinate conversion
    window.dredgeVolumeData = null;
//    const osGridConverter = require('os-transform.js');
    const osGridConverter = window['os-transform.js'];

    // Define the colors for the circle markers. This array will be used by both the map and the file list.
    const markerColors = [
        '#FF5733', '#33CFFF', '#33FF57', '#FF33A1', '#A133FF',
        '#FFC300', '#33FFA1', '#C70039', '#900C3F'
    ];    

/*    markerPath = 'markers/';
    markerPngs = ['marker-icon-red.png', 'marker-icon-orange.png', 'marker-icon-yellow.png',
    'marker-icon-green.png', 'marker-icon-blue.png', 'marker-icon-violet.png',
    'marker-icon-grey.png', 'marker-icon-gold.png','marker-icon-black.png'];*/

// Define the projection for British National Grid (OSGB 1936)
    proj4.defs("EPSG:27700", "+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +towgs84=446.448,-125.157,542.060,0.1502,0.2470,0.8421,-20.4894 +units=m +no_defs");

    let lastInstanceNo = 0;
    let lastScatterInstanceNo = 0;
    let noInstances = 16;
    let exportLink = null;
    let chartInstance = [];
    let popupInstance = [];
    let instanceType = [];
    let instanceSheet = [];
    let highlighted = [];
    let legends = [];
    let ylinlog = [];
    let stacked = [];
    let largeSize = [];
    let xAxisSort = 'normal';
    let lookSetting = 'colour';
    let highlightMarkers = {};
    for (i = 1; i < noInstances; i++) {
        chartInstance[i] = null;
        instanceType[i] = null;
        instanceSheet[i] = null;
    }
    determinands = {};
    determinands.pah = {};
    determinands.pah.all = ['Acenapthene', 'Acenapthylene', 'Anthracene', 'Benz[a]anthracene', 'Benzo[a]pyrene', 'Benzo[b]fluoranthene',
                            'Benzo[g,h,i]perylene', 'Benzo[e]pyrene', 'Benzo[k]fluoranthene', 'C1-Napthalenes', 'C1-Phenanthrenes',
                            'C2-Napthalenes', 'C3-Napthalenes', 'Chrysene', 'Dibenz[a,h]anthracene', 'Fluoranthene',
                            'Fluorene', 'Indeno[123-c,d]pyrene', 'Napthalene', 'Perylene', 'Phenanthrene', 'Pyrene'];
    determinands.pah.lmw = ['Acenapthene', 'Acenapthylene', 'Anthracene', 'C1-Napthalenes',  'Fluorene','Napthalene', 'Phenanthrene'];
    determinands.pah.hmw = ['Benz[a]anthracene', 'Benzo[a]pyrene', 'Chrysene', 'Dibenz[a,h]anthracene', 'Fluoranthene', 'Pyrene'];
    determinands.pah.epa = ['Acenapthene', 'Acenapthylene', 'Anthracene', 'Benz[a]anthracene', 'Benzo[a]pyrene', 'Benzo[b]fluoranthene',
                            'Benzo[g,h,i]perylene', 'Benzo[k]fluoranthene', 'Chrysene', 'Dibenz[a,h]anthracene', 'Fluoranthene',
                            'Fluorene', 'Indeno[123-c,d]pyrene', 'Napthalene', 'Phenanthrene', 'Pyrene'];
    determinands.pah.smallpts = ['Acenapthene', 'Acenapthylene', 'Anthracene', 'Benz[a]anthracene', 'Benzo[a]pyrene', 'Benzo[b]fluoranthene',
                            'Benzo[g,h,i]perylene', 'Benzo[e]pyrene', 'Benzo[k]fluoranthene', 'Chrysene', 'Dibenz[a,h]anthracene',
                            'Fluoranthene', 'Fluorene', 'Indeno[123-c,d]pyrene', 'Pyrene'];
    determinands.pah.organicc = ['C1-Napthalenes', 'C1-Phenanthrenes', 'C2-Napthalenes', 'C3-Napthalenes', 'Napthalene', 'Phenanthrene'];
    determinands['PAH data'] = determinands.pah.all;
    determinands['PCB data'] = ["2,2',4,5,5'-Pentachlorobiphenyl", "2,3,3',4,4'-Pentachlorobiphenyl", "2,3,3',4',6-Pentachlorobiphenyl", 
        "2,3',4,4',5-Pentachlorobiphenyl", "2,2',3,3',4,4'-Hexachlorobiphenyl", "2,2',3,4,4',5'-Hexachlorobiphenyl", 
        "2,2',3,4,5,5'-Hexachlorobiphenyl", "2,2',3,4',5',6-Hexachlorobiphenyl", "2,2',3,5,5',6-Hexachlorobiphenyl", 
        "2,2',4,4',5,5'-Hexachlorobiphenyl", "2,3,3',4,4',5-Hexachlorobiphenyl", "2,3,3',4,4',6-Hexachlorobiphenyl", 
        "2,2',3,3',4,4',5-Heptachlorobiphenyl", "2,2',5-Trichlorobiphenyl", "2,2',3,4,4',5,5'-Heptachlorobiphenyl", 
        "2,2',3,4,4',5',6-Heptachlorobiphenyl", "2,2',3,4',5,5',6-Heptachlorobiphenyl", "2,2',3,3',4,4',5,5'-Octachlorobiphenyl", 
        "2,4,4'-Trichlorobiphenyl", "2,4',5-Trichlorobiphenyl", "2,2',3,5'-Tetrachlorobiphenyl", "2,2',4,4'-Tetrachlorobiphenyl", 
        "2,2',4,5'-Tetrachlorobiphenyl", "2,2',5,5'-Tetrachlorobiphenyl", "2,3',4,4'-Tetrachlorobiphenyl"]; 
    determinands['Organochlorine data'] = ['alpha-hexachlorocyclohexane (AHCH)', 'beta-hexachlorocyclohexane (BHCH)',
        'gamma-hexachlorocyclohexane (GHCH)', 'Dieldrin', 'Hexachlorobenzene (HCB)', 
        '1,1-Dichloro-2,2-bis(p-chlorophenyl) ethylene (PPDDE)', 'Dichlorodiphenyltrichloroethane (PPDDT)', 
        '1,1-dichloro-2,2-bis(p-chlorophenyl)ethane (PPTDE)'];
    determinands['Trace metal data'] = ['Arsenic (As)', 'Cadmium (Cd)', 'Chromium (Cr)', 'Copper (Cu)', 'Mercury (Hg)',
         'Nickel (Ni)', 'Lead (Pb)', 'Zinc (Zn)'];
    determinands['Organotins data'] = ['Dibutyltine (DBT)', 'Tributyltin (TBT)'];
    determinands['BDE data'] = ['2,2′,4,4′,6-penta-bromodiphenyl ether (BDE100)', 'Hexabromodiphenyl ether (BDE138)', 
        '2,2′,4,4′,5,5′-hexa-bromodiphenyl ether (BDE153)', '2,2′,4,4′,5,6′-hexa-bromodiphenyl ether (BDE154)', 
        '2,2´,4-tri-bromodiphenylether (BDE17)', '2,2′,3,4,4′,5′,6-heptabromodiphenyl ether (BDE183)', 
        "2,2',3,3',4,4',5,5',6,6'-decabrominated diphenyl ether (BDE 209)", "2,4,4'-tribromodiphenyl ether (BDE28)", 
        '2,2′,4,4′-Tetrabromodiphenyl ether (BDE47)', "2,3',4,4'-Tetrabromodiphenyl ether (BDE66)", 
        "2,2',3,4,4'-Pentabromodiphenyl ether (BDE85)", "2,2',4,4',5-pentabromodiphenyl ether (BDE99)"];
    dataSheetNames = ['Physical Data','Trace metal data','PAH data','PCB data','BDE data','Organotins data','Organochlorine data'];
    dataSheetAbr = {'Physical Data': 'Phys','Trace metal data': 'TM','PAH data': 'PAH','PCB data': 'PCB','BDE data': 'BDE','Organotins data': 'OT',
        'Organochlorine data': 'OC'};
    dataSheetNamesCheckboxes = [];
    calcSheetNames = ['Physical Stats','PSA Charts','Metals calcs','PAH calcs','PCB calcs','BDE calcs','Organotin calcs','Organochlorine calcs'];
    let sortButtonGroups = {};
    for (let i = 0; i < dataSheetNames.length; i++) {
        dataSheetNamesCheckboxes[i] = dataSheetNames[i].replace(/\s/g, '').toLowerCase();
        sortButtonGroups[dataSheetNames[i]] = [];
    }
//    disableRadioButtons(dataSheetNamesCheckboxes,true);
    sheetsToDisplay = {};
    completeSheet = {};
    for (i = 0; i < dataSheetNames.length; i++) {
        sheetName = dataSheetNames[i];
        sheetsToDisplay[sheetName] = false;
        completeSheet[sheetName] = false;
    }
/*    dataSheetNames.forEach(sheetName => {
        disableRadioButtons(sortButtonGroups[sheetName], false);
        completeSheet[sheetName] = true;
    })*/
    subChartNames = ['samplegroup','chemicalgroup','correlationplots','pcaanalysis','gorhamtest','totalhc','pahratios',
                    'ringfractions','eparatios','simpleratios','congenertest', 'pcanormalise','pcalmw','pcahmw',
                    'pcaepa','pcasmallpts','pcaorganiccarbon','relationareadensity','relationhc',
                    'relationtotalsolids','relationorganiccarbon','splitbyweight','splitbyarea',
                    'totalsolidsandtotalcarbon','cumulative','mapgrid'];
//    relationNames = ['relationareadensity','relationhc','relationtotalsolids'];
        subsToDisplay = {};
    for (i = 0; i < subChartNames.length; i++) {
        subName = subChartNames[i];
        subsToDisplay[subName] = false;
    }
    const sortingOptions = [
        'Unsorted', 'Date of Sampling', 'Latitude', 'Longitude', 'Total Area', 
        'Total Solids', 'Organic Matter', 'Silt', 'Silt and Sand', 'Sand', 'Gravel',
        'Total Hydrocarbon', 'Gorham LMW Sum', 'Gorham HMW Sum', 'ICES7 PCB Sum'
    ];

    const primarySortingOptions = [
        'None', 'Date of Sampling', 'Sample Name', 'Date & Sample Name', 'Sample Name & Date',
        'Dataset Name', 'Dataset Name & Sample Name ', 'Sample Name & Dataset Name'];
    const secondarySortingOptions = [
        'Latitude', 'Longitude', 'Min Depth', 'Max Depth', 'Mean Depth',
        'Total Area', 'Total Solids', 'Organic Matter', 
        'Silt', 'Silt and Sand', 'Sand', 'Gravel', 'Total Hydrocarbon', 
        'Gorham LMW Sum', 'Gorham HMW Sum', 'ICES7 PCB Sum', 'All PCBs Sum'
    ];


    const sortOptionDependencies = {
        'totalsolids': 'Physical Data',
        'organicmatter': 'Physical Data',
        'silt': 'Physical Data',
        'siltsand': 'Physical Data',
        'sand': 'Physical Data',
        'gravel': 'Physical Data',
        'totalhydrocarbon': 'PAH data',
        'gorhamlmwsum': 'PAH data',
        'gorhamhmwsum': 'PAH data',
        'ices7pcbsum': 'PCB data',
        'allpcbssum': 'PCB data'
        // Add any other dependencies here.
        // Options like 'Latitude', 'Longitude', etc., don't need to be listed
        // as they are always available.
    };

//    sortingOptions = ['unsorted', 'normal', 'datelatitude', 'datelongitude', 'datetotalarea', 'latitude', 'longitude', 'totalarea', 'totalsolids', 'organicmatter', 'silt', 'siltsand', 'sand', 'gravel',
//        'totalhcsort', 'lmw', 'hmw', 'ices7', 'allpcbs', 'datelmw', 'datehmw', 'dateices7', 'dateallpcbs'];
    lookOptions = ['colour', 'blackandwhite'];
    sortButtonGroups['area'] = [...sortingOptions.filter(option => option.includes('area')), ...subChartNames.filter(option => option.includes('area'))];
    sortButtonGroups['PCB data'] = [...sortingOptions.filter(option => option.includes('pcb') || option.includes('ices7'))];/*,
                ...subChartNames.filter(option => option.includes('congener'))];*/
    sortButtonGroups['PAH data'] = [...sortingOptions.filter(option => option.includes('hc') || option.includes('mw') || option.includes('pah')),
                ...subChartNames.filter(option => option.includes('pah') || option.includes('hc') || option.includes('gorham') || option.includes('ratios')
                 || option.includes('ring') || option.includes('totalhc'))];
    sortButtonGroups['Physical Data'] = [...sortingOptions.filter(option => option.includes('silt') || option.includes('sand') || option.includes('area') || option.includes('gravel')),
                ...subChartNames.filter(option => option.includes('area') || option.includes('solid') || option.includes('organic'))];
//                ...relationNames.filter(option => option.includes('area') || option.includes('solid'))];
populateSortDropdowns();
    for (group in sortButtonGroups) {
//console.log(group);
        disableRadioButtons(sortButtonGroups[group], false);
    }
    let map; // Declare map as a global variable
    let fred ='waiting';
    let sampleMeasurements = {};
    let selectedSampleMeasurements = {};
    let sampleInfo = {};
    let selectedSampleInfo = {};
    let blankMeasurements = {};
    let namedLocations = {};
    let chemInfo = {};
    //All actions level mg/kg
    const actionLevels = {};
    actionLevels['Trace metal data'] = {
        'Arsenic (As)':[20,100],
        'Cadmium (Cd)': [0.4,5],
        'Chromium (Cr)': [40,400],
        'Copper (Cu)': [40,400],
        'Mercury (Hg)': [0.3,3],
        'Nickel (Ni)': [20,200],
        'Lead (Pb)': [50,500],
        'Zinc (Zn)': [130,800]
    };
    actionLevels['Organotins data'] = {
        'Dibutyltine (DBT)': [0.1,1],
        'Tributyltin (TBT)': [0.1,1]
    };
    actionLevels['PAH data'] = {
        'Acenapthene': [0.1,0],
        'Acenapthylene': [0.1,0],
        'Anthracene': [0.1,0],
        'Benz[a]anthracene': [0.1,0],
        'Benzo[a]pyrene': [0.1,0],
        'Benzo[b]fluoranthene': [0.1,0],
        'Benzo[g,h,i]perylene': [0.1,0],
        'Benzo[e]pyrene': [0.1,0],
        'Benzo[k]fluoranthene': [0.1,0],
        'C1-Napthalenes': [0.1,0],
        'C1-Phenanthrenes': [0.1,0],
        'C2-Napthalenes': [0.1,0],
        'C3-Napthalenes': [0.1,0],
        'Chrysene': [0.1,0],
        'Dibenz[a,h]anthracene': [0.01,0],
        'Fluoranthene': [0.1,0],
        'Fluorene': [0.1,0],
        'Indeno[123-c,d]pyrene': [0.1,0],
        'Napthalene': [0.1,0],
        'Perylene': [0.1,0],
        'Phenanthrene': [0.1,0],
        'Pyrene': [0.1,0]
    };
    actionLevels['Organochlorine data'] = {
        'Dieldrin': [0.005,0],
        'Dichlorodiphenyltrichloroethane (PPDDT)': [0.001,0.2]
    };
    let actionLevelColors = ['rgba(255, 255, 0, 1)','rgba(255, 0, 0, 0.5)'];
    let actionLevelDashes = [[3,3],[5,5]];

    firstTime = true;
    
    const ccontainer = document.getElementById('radarPlots');
    radarPlotTypes = [];
//    radarPlotTypes[0] = "None";;
//    radarPlotTypes = join(radarPlotTypes,dataSheetNames);
//let radarPlotTypes = dataSheetNames;
radarPlotTypes[0] = "None";
for (i = 1; i < dataSheetNames.length; i++) {
    radarPlotTypes[i] = dataSheetNames[i];
}
    radarPlotTypes.forEach((name, index) => {
        const radio = document.createElement('input');
        radio.type = 'radio';
        radio.id = `radio${index}`;
        radio.name = 'dataSheet';
        radio.value = name;
        if (name === "None") {
            radio.checked = true;
        } /*else {
            radio.checked = false;
        }*/
        const label = document.createElement('label');
        label.htmlFor = `radio${index}`;
        label.appendChild(document.createTextNode(name));

        // Attach event listener to each radio button
        radio.addEventListener('change', function() {
            if (this.checked) {
                radarPlot = this.value; // Set radarPlot to the selected value
                console.log('Selected radar plot:', radarPlot);
            }
        });

        ccontainer.appendChild(radio);
        ccontainer.appendChild(label);
    });

/*standards = {};

        document.addEventListener('DOMContentLoaded', async () => {
            const dataUrl = 'https://northeastfc.uk/Supporting/quality_standards.sdes';
            const parsedData = await readQualityStandards(dataUrl);
            const outputElement = document.getElementById('output');
            standards = parsedData;
        });*/

    completeStandards();

    importData();

    function parseDates(dateString) {
        //console.log('dateString pd', dateString);
                    // Check if the date field is empty
                    if (!dateString) {
                        return ['Missing'];
                    }
        
                    const dates = [];
        
                    // Split the input by commas or hyphens
                    const dateParts = dateString.split('/,|-/');
                    dateParts.forEach(part => {
                        // Trim leading/trailing spaces
                        const trimmedPart = part.trim();
        
                        // Check if it's a range (contains a hyphen)
                        if (trimmedPart.includes('/')) {
                            const ukDate = convertToUKFormat(trimmedPart);
                            if (ukDate) {
                                dates.push(ukDate);
                            }
                        } else {
                            // Single date
                            const ukDate = convertToUKFormat(trimmedPart);
                            if (ukDate) {
                                dates.push(ukDate);
                            }
                        }
                    });
        
                    return dates.length > 0 ? dates : ['Missing'];
                }
        
            function convertToUKFormat(dateString) {
        //console.log('dateString cUKf',dateString);
            const parts = dateString.split('/');
        //console.log('parts cUKf',parts);
            if (parts.length === 3) {
                if (parts[2].length === 2) {
                    // Assuming the format is mm/dd/yy
                    const mm = parts[0].padStart(2, '0');
                    const dd = parts[1].padStart(2, '0');
                    const yy = parts[2].padStart(2, '0');
        
                    // Construct the UK format: dd/mm/yy
        //console.log('return',`20${yy}/${mm}/${dd}`);
                    return `20${yy}/${mm}/${dd}`;
                    } else {
                        if (parts[2].length === 4) {
                            // Assuming the format is mm/dd/yy
                            const dd = parts[0].padStart(2, '0');
                            const mm = parts[1].padStart(2, '0');
                            const yy = parts[2].padStart(2, '0');
        
                            // Construct the UK format: dd/mm/yy
        //console.log('return',`${yy}/${mm}/${dd}`);
                            return `${yy}/${mm}/${dd}`;
                        }
                    }
                }
            // Return null for invalid date formats
            return null;
            }
        
            function saveSnapShot() {
        const fileSave = document.getElementById('fileSave');
        const fileName = fileSave.value;
        saveStatus(fileName);
    }

function postLoadSnapShot() {
    for (dateSampled in sampleMeasurements) {
//        console.log('looking for labels');
        if (!(sampleInfo[dateSampled].hasOwnProperty('label'))) {
//console.log('sampleInfo',dateSampled, 'adding label');
            sampleInfo[dateSampled].label = dateSampled;
        }
        if ((sampleInfo[dateSampled].hasOwnProperty('Date Sampled'))) {
//console.log('sampleInfo',dateSampled, 'corrected missing Date sampled');
            sampleInfo[dateSampled]['Date sampled'] = sampleInfo[dateSampled]['Date Sampled'];
        }
        for (sample in sampleInfo[dateSampled].position) {
            if (!(sampleInfo[dateSampled].position[sample].hasOwnProperty('label'))) {
                sampleInfo[dateSampled].position[sample].label = sample;
            }
        }
        if ('Physical Data' in sampleMeasurements[dateSampled]) {
            for (sample in sampleMeasurements[dateSampled]['Physical Data'].samples) {
                if (!('totalArea' in sampleMeasurements[dateSampled]['Physical Data'].samples[sample])) {
                    currentPsd = sampleMeasurements[dateSampled]['Physical Data'].samples[sample].psd;
                    retData = psdPostProcess(currentPsd, sampleMeasurements[dateSampled]['Physical Data'].sizes);
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].psd = [...retData['currentPsd'],0];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].psdAreas = retData['areas'];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].psdRelaitveAreas = retData['realtiveAreas'];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].splitWeights = retData['splitWeights'];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].splitAreas = retData['splitAreas'];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].splitRelativeAreas = retData['splitRelativeAreas'];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].cumAreas = retData['cumAreas'];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].cumWeights = retData['cumWeights'];
                    sampleMeasurements[dateSampled]['Physical Data'].samples[sample].totalArea = retData['totalArea'];
                }
            }
            sampleMeasurements[dateSampled]['Physical Data'].sizes = [...standard_phiSizes, 0];
        }
    }
    for (dateSampled in selectedSampleMeasurements) {
        if (!(selectedSampleInfo[dateSampled].hasOwnProperty('label'))) {
            selectedSampleInfo[dateSampled].label = dateSampled;
        }
        if ((selectedSampleInfo[dateSampled].hasOwnProperty('Date Sampled'))) {
            selectedSampleInfo[dateSampled]['Date sampled'] = sampleInfo[dateSampled]['Date sampled'];
        }
        for (sample in selectedSampleInfo[dateSampled].position) {
            if (!(selectedSampleInfo[dateSampled].position[sample].hasOwnProperty('label'))) {
                selectedSampleInfo[dateSampled].position[sample].label = sample;
            }
        }
        if ('Physical Data' in selectedSampleMeasurements[dateSampled]) {
            for (sample in selectedSampleMeasurements[dateSampled]['Physical Data'].samples) {
                if (!('totalArea' in selectedSampleMeasurements[dateSampled]['Physical Data'].samples[sample])) {
                    selectedSampleMeasurements[dateSampled]['Physical Data'].samples[sample] = sampleMeasurements[dateSampled]['Physical Data'].samples[sample];
                }
            }
        }
    }
}

    function loadSnapShotURL() {
        const urlLoad = document.getElementById('urlLoad');
        const fileUrl = urlLoad.value;
        loadStatus(fileUrl);
        postLoadSnapShot();
    }
    
    function loadSnapShotFile() {
        const fileInput = document.getElementById('fileLoad');
        const file = fileInput.files[0];
        if (file) {
            const reader = new FileReader();
            reader.onload = function (e) {
                // Read file as text
                const textData = e.target.result;
                // Decode the base64 data (if it was encoded)
                const decodedData = decodeURIComponent(escape(atob(textData)));
                // Parse the JSON data
                const jsonData = JSON.parse(decodedData);
                // Use the loaded data
                // Now jsonData contains the loaded data
                sampleInfo = jsonData.sampleInfo;
                sampleMeasurements = jsonData.sampleMeasurements;
                selectedSampleInfo = jsonData.selectedSampleInfo;
                selectedSampleMeasurements = jsonData.selectedSampleMeasurements;
                postLoadSnapShot();
                updateChart();
            };
            reader.readAsText(file);
        }
    }
    
    function saveStatus(fileName) {
        // Save data to a file
        const dataBlob = new Blob([btoa(unescape(encodeURIComponent(JSON.stringify({ sampleInfo, sampleMeasurements, selectedSampleInfo, selectedSampleMeasurements }))))], { type: 'application/octet-stream' });
        const downloadLink = document.createElement('a');
        downloadLink.href = URL.createObjectURL(dataBlob);
        downloadLink.download = fileName;
        downloadLink.click();
    }
    
    // Function to load data from a file URL
    async function loadStatus(fileURL) {
        try {
            // Fetch the data from the URL
            const response = await fetch(fileURL);
    
            // Check if the fetch was successful (status code 200)
            if (!response.ok) {
                throw new Error(`Failed to fetch data. Status: ${response.status}`);
            }
    
            // Read the response as text
            const textData = await response.text();
    
            // Decode the base64 data (if it was encoded)
            const decodedData = decodeURIComponent(escape(atob(textData)));
    
            // Parse the JSON data
            const jsonData = JSON.parse(decodedData);
    
            // Now jsonData contains the loaded data
/*            sampleInfo = jsonData.sampleInfo;
            sampleMeasurements = jsonData.sampleMeasurements;
            selectedSampleInfo = jsonData.selectedSampleInfo;
            selectedSampleMeasurements = jsonData.selectedSampleMeasurements;*/
            Object.assign(sampleInfo, jsonData.sampleInfo);
            Object.assign(sampleMeasurements, jsonData.sampleMeasurements);
            Object.assign(selectedSampleInfo, jsonData.selectedSampleInfo);
            Object.assign(selectedSampleMeasurements, jsonData.selectedSampleMeasurements);
            postLoadSnapShot();
            updateChart();
            return jsonData;
        } catch (error) {
            console.error('Error loading data:', error.message);
        }
    }

    function clearData() {
/*        if (map) {
            map.remove();
        }*/
        sampleMeasurements = {};
        selectedSampleMeasurements = {};
        sampleInfo = {};
        selectedSampleInfo = {};
        for (group in sortButtonGroups) {
            disableRadioButtons(sortButtonGroups[group], false);
        }
    /*			if (map) {
            map.remove();
        }*/
        const canvas = [];
        for (i = 1; i < noInstances; i++) {
            canvas[i] = document.getElementById('chart' + i);
            clearCanvasAndChart(canvas[i], i);
        }
    }

    function importChemInfo() {
        urls = {};
//console.log('importChemInfo');
        if (firstTime) {
            firstTime = false;
            files = {};
            // Get the current URL
            const currentURL = window.location.href;
            
            // Parse the URL to get the search parameters
            const suppliedParams = new URLSearchParams(window.location.search);

            // Get the value of the 'cheminfo' parameter
            const cheminfoParam = suppliedParams.get('cheminfo');
            if (!cheminfoParam) {
                return;
            } else {
                    urls = cheminfoParam.split(',').map(url => url.trim()); // Split comma-separated URLs
            }
        } else {
            const fileInput = document.getElementById('fileChemInfo');
            const urlInput = document.getElementById('urlChemInfo');
            const files = fileInput.files; // Files is now a FileList object containing multiple files
            const urls = urlInput.value.trim().split(',').map(url => url.trim()); // Split comma-separated URLs

            if (files.length === 0 && urls.length === 0) {
                alert('Please select files or enter URLs.');
                return;
            }
            // Process files
            for (let i = 0; i < files.length; i++) {
                filename = files[i].name;
                const reader = new FileReader();
                reader.onload = function (e) {
                    const data = new Uint8Array(e.target.result);
                    processExcelChemInfo(data,filename);
                };
                reader.readAsArrayBuffer(files[i]);
            }
        }
        // Process URLs only if URLs are supplied
        if (urls.length > 0) {
            urls.forEach(url => {
            // Check if the URL is a valid URL before fetching
                 if  (!/^https?:\/\//i.test(url)) {
                     console.error('Invalid URL:', url);
                     return;
                 }

                 fetch(url)
                    .then(response => response.arrayBuffer())
                    .then(data => {
                        processExcelChemInfo(new Uint8Array(data),url);
                    })
                    .catch(error => {
                        console.error('Error fetching the chemInfo file:', error);
                    });
                });
        }
        // Clear the input field after reading locations
        fileInput.value = '';
        urlInput.value = '';
    }
    
    function processExcelChemInfo(data,url) {
        // Based on simple Excel data in first sheet
        // row 1 column titles
        // column 1 compound name
        // column 2 - n property
        const workbook = XLSX.read(data, { type: 'array' });
//console.log(workbook);
        sheetData = workbook.Sheets['Sheet1'];
//console.log(sheetData);
        const df = XLSX.utils.sheet_to_json(sheetData, { header: 1 });
        for (let r = 1; r < df.length; r++) {
            const chemical = df[r][0];
            chemInfo[chemical] = {};
            for (let c = 1; c < df[r].length; c++) {
                const property = df[0][c];
                chemInfo[chemical][property] = df[r][c];
            }
//console.log(chemInfo[chemical]);
        }
//console.log('End of processChemInfo');
    }

    function importLocations() {
        urls = {};
        if (firstTime) {
            firstTime = false;
            files = {};
            // Get the current URL
            const currentURL = window.location.href;
            
            // Parse the URL to get the search parameters
            const suppliedParams = new URLSearchParams(window.location.search);

            // Get the value of the 'locations' parameter
            const locationsParam = suppliedParams.get('locations');
            if (!locationsParam) {
                return;
            } else {
                    urls = locationsParam.split(',').map(url => url.trim()); // Split comma-separated URLs
            }
        } else {
            const fileInput = document.getElementById('fileLocations');
            const urlInput = document.getElementById('urlLocations');
            const files = fileInput.files; // Files is now a FileList object containing multiple files
            urls = urlInput.value.trim().split(',').map(url => url.trim()); // Split comma-separated URLs

            if (files.length === 0 && urls.length === 0) {
                alert('Please select files or enter URLs.');
                return;
            }
            // Process files
            for (let i = 0; i < files.length; i++) {
                filename = files[i].name;
                const reader = new FileReader();
                reader.onload = function (e) {
                    const data = new Uint8Array(e.target.result);
                    processExcelLocations(data,filename);
                };
                reader.readAsArrayBuffer(files[i]);
            }
        }
        // Process URLs only if URLs are supplied
        if (urls.length > 0) {
            urls.forEach(url => {
            // Check if the URL is a valid URL before fetching
                 if  (!/^https?:\/\//i.test(url)) {
                     console.error('Invalid URL:', url);
                     return;
                 }

                 fetch(url)
                    .then(response => response.arrayBuffer())
                    .then(data => {
                        processExcelLocations(new Uint8Array(data),url);
                    })
                    .catch(error => {
                        console.error('Error fetching the locations file:', error);
                    });
                });
        }
        // Clear the input field after reading locations
        fileInput.value = '';
        urlInput.value = '';
    }
    
    function importShapes() {
        let urls = [];
        if (firstTime) {
            // Get the current URL
            const currentURL = window.location.href;
            
            // Parse the URL to get the search parameters
            const suppliedParams = new URLSearchParams(window.location.search);

            // Get the value of the 'locations' parameter
            const shapesParam = suppliedParams.get('shapes');
            if (shapesParam) {
                    urls = shapesParam.split(',').map(url => url.trim()); // Split comma-separated URLs
            }
        } else {
            const fileInput = document.getElementById('fileShapes');
            const urlInput = document.getElementById('urlShapes');
            const files = fileInput.files; // Files is now a FileList object containing multiple files
            const urlVal = urlInput.value.trim();
            if (urlVal) {
                urls = urlVal.split(',').map(url => url.trim()); // Split comma-separated URLs
            }

            if (files.length === 0 && urls.length === 0) {
                alert('Please select files or enter URLs.');
                return;
            }
            // Process files
            for (let i = 0; i < files.length; i++) {
                const filename = files[i].name;
                const reader = new FileReader();
                reader.onload = function (e) {
                    const content = e.target.result;
                    const blob = new Blob([content], {type: 'application/vnd.google-earth.kml+xml'});
                    const url = URL.createObjectURL(blob);
                    kmlLayers[filename] = url;
                };
                reader.readAsText(files[i]);
            }
            // Clear the input field after reading locations
            fileInput.value = '';
            urlInput.value = '';
        }
        // Process URLs only if URLs are supplied
        if (urls.length > 0) {
            urls.forEach(url => {
            // Check if the URL is a valid URL before fetching
                 if  (!/^https?:\/\//i.test(url)) {
                     console.error('Invalid URL:', url);
                     return;
                 }
                 const filename = url.split('/').pop();
console.log(filename);  // Output: MLA_2015_00088-LOCATIONS.kml
//"https://northeastfc.uk/RiverTees/Planning/MLA_2015_00088/MLA_2015_00088-LOCATIONS.kml"
//                 kmlLayers[filename] = new L.KML(url, {async: true});
                 kmlLayers[filename] = url;

/*                 fetch(url)
                    .then(response => response.arrayBuffer())
                    .then(data => {
                        processExcelLocations(new Uint8Array(data),url);
                    })
                    .catch(error => {
                        console.error('Error fetching the locations file:', error);
                    });*/
                });
        }
    }
   
    function processExcelLocations(data,url) {
        // Based on simple Excel data in first sheet
        // row 1 column titles
        // column 1 location as per name used as sample in MMO templates
        // column 2 latitude in decimal degrees
        // column 3 longitude in decimal degrees
// console.log('processexcellocations',url);
//console.log('prcoessing ',url);
        const workbook = XLSX.read(data, { type: 'array' });
//console.log(workbook);
        sheetData = workbook.Sheets['Sheet1'];
//console.log(sheetData);
        const df = XLSX.utils.sheet_to_json(sheetData, { header: 1 });
        for (let r = 1; r < df.length; r++) {
            const sample = df[r][0];
//console.log('|',sample,'|',sample.trim(),'|');
            cleanSample = sample.replace(/\s+/g, '').toLowerCase();
            namedLocations[cleanSample] = {};
            namedLocations[cleanSample].label = sample;
            namedLocations[cleanSample].latitude = parseFloat(df[r][1]);
            namedLocations[cleanSample].longitude = parseFloat(df[r][2]);
//console.log(sample,namedLocations[sample]);
        }
//console.log('End of processExcelLocations');
    }

    function checkboxParameters(suppliedParams, paramName, checkboxNames) {
        const param = suppliedParams.get(paramName);
        if (param) {
            sels = param.split(',').map(sel => sel.trim()); // Split comma-separated URLs
            if (sels) {
                // Blank all the checkboxes
                for (let i = 0; i < checkboxNames.length; i++) {
                    const checkbox = document.getElementById(checkboxNames[i]);
                    checkbox.checked = false;
                }
                // Check all the boxes set in url
                for (let i = 0; i < sels.length; i++) {
//console.log(i);
//console.log(sels[i]);
                    const checkbox = document.getElementById(sels[i].toLowerCase());
                    checkbox.checked = true;
                }
            }
        }
    }

    function cleanChemicalString(chemical) {
        return chemical
            .replace(/[\r]/g, '')                 // Remove \r
            .replace(/[\n]/g, '')                 // Remove \n
            .replace(/\s*-\s*/g, '-')               // Remove spaces around dashes
            .replace(/\s+/g, ' ')                   // Replace multiple spaces with a single space
            .trim();                                // Remove spaces at the beginning and end of the string
    }

// --- Sidebar Toggle ---
function toggleSidebar() {
    const sidebar = document.getElementById('controls-sidebar');
    const toggleBtn = document.getElementById('sidebar-toggle');
    sidebar.classList.toggle('collapsed');
    toggleBtn.innerHTML = sidebar.classList.contains('collapsed') ? '&#9654;' : '&#9664;';
}

function generateURL() {
    const params = new URLSearchParams();

    // 1. Data URLs
    const dataUrls = new Set();
    if (typeof sampleInfo !== 'undefined') {
        Object.values(sampleInfo).forEach(info => {
            if (info.fileURL && /^https?:\/\//i.test(info.fileURL)) {
                dataUrls.add(info.fileURL);
            }
        });
    }
    if (dataUrls.size > 0) {
        params.set('urls', Array.from(dataUrls).join(','));
    }

    // 2. Shapes
    const shapeUrls = new Set();
    if (typeof kmlLayers !== 'undefined') {
        Object.values(kmlLayers).forEach(url => {
            if (typeof url === 'string' && /^https?:\/\//i.test(url)) {
                shapeUrls.add(url);
            }
        });
    }
    if (shapeUrls.size > 0) {
        params.set('shapes', Array.from(shapeUrls).join(','));
    }

    // 3. Selected Charts
    const selCharts = [];
    if (typeof dataSheetNamesCheckboxes !== 'undefined') {
        dataSheetNamesCheckboxes.forEach(id => {
            const checkbox = document.getElementById(id);
            if (checkbox && checkbox.checked) {
                selCharts.push(id);
            }
        });
    }
    if (selCharts.length > 0) {
        params.set('selcharts', selCharts.join(','));
    }

    // 4. Sub Charts
    const subCharts = [];
    if (typeof subChartNames !== 'undefined') {
        subChartNames.forEach(id => {
            const checkbox = document.getElementById(id);
            if (checkbox && checkbox.checked) {
                subCharts.push(id);
            }
        });
    }
    if (subCharts.length > 0) {
        params.set('subcharts', subCharts.join(','));
    }

    // 5. Sort
    if (typeof xAxisSort !== 'undefined' && xAxisSort !== 'normal') {
        params.set('sort', xAxisSort);
    }

    // 6. Look
    if (typeof lookSetting !== 'undefined' && lookSetting !== 'colour') {
        params.set('look', lookSetting);
    }

    // 7. Dredge Data
    if (typeof CEFASfilename !== 'undefined' && CEFASfilename && /^https?:\/\//i.test(CEFASfilename)) {
        params.set('durl', CEFASfilename);
        
        const lat = document.getElementById('centreLatitude')?.value;
        if (lat) params.set('dlat', lat);
        
        const lon = document.getElementById('centreLongitude')?.value;
        if (lon) params.set('dlon', lon);
        
        const rad = document.getElementById('radius')?.value;
        if (rad) params.set('drad', rad);
        
        const start = document.getElementById('startDate')?.value;
        if (start) params.set('dstart', start);
        
        const finish = document.getElementById('finishDate')?.value;
        if (finish) params.set('dfinish', finish);
        
        const lics = document.getElementById('mlApplications')?.value;
        if (lics) params.set('dlics', lics);
    }

    // 8. Dredge Volume Data URL
    if (window.dredgeVolumeData && window.dredgeVolumeData.sourceUrl) {
        params.set('dredgevol', window.dredgeVolumeData.sourceUrl);
    }

    // 9. Dredge Volume Year Range
    const dStart = document.getElementById('dredgeStartYear')?.value;
    if (dStart) params.set('dvolstart', dStart);
    
    const dEnd = document.getElementById('dredgeEndYear')?.value;
    if (dEnd) params.set('dvolend', dEnd);

    const baseUrl = window.location.origin + window.location.pathname;
    // Decode URI component to show spaces instead of %20 or +
    const newUrl = decodeURIComponent(baseUrl + '?' + params.toString().replace(/\+/g, ' '));

    navigator.clipboard.writeText(newUrl).then(() => {
        alert('URL copied to clipboard:\n' + newUrl);
    }, (err) => {
        console.error('Could not copy text: ', err);
        prompt("Copy this URL:", newUrl);
    });
}

function createControlButtons() {
    const sidebar = document.getElementById('controls-sidebar');
    if (sidebar) {
        const button = document.createElement('button');
        button.textContent = 'Export Data to CSV';
        button.style.marginTop = '10px';
        button.style.marginBottom = '10px';
        button.style.width = '95%';
        button.style.padding = '5px';
        button.style.cursor = 'pointer';
        button.onclick = exportToCSV;
        sidebar.insertBefore(button, sidebar.firstChild);

        const buttonFiltered = document.createElement('button');
        buttonFiltered.textContent = 'Export Filtered Data to CSV';
        buttonFiltered.style.marginTop = '10px';
        buttonFiltered.style.marginBottom = '10px';
        buttonFiltered.style.width = '95%';
        buttonFiltered.style.padding = '5px';
        buttonFiltered.style.cursor = 'pointer';
        buttonFiltered.onclick = exportFilteredToCSV;
        sidebar.insertBefore(buttonFiltered, sidebar.firstChild);

        const buttonCopy = document.createElement('button');
        buttonCopy.textContent = 'Copy Settings URL';
        buttonCopy.style.marginTop = '10px';
        buttonCopy.style.marginBottom = '10px';
        buttonCopy.style.width = '95%';
        buttonCopy.style.padding = '5px';
        buttonCopy.style.cursor = 'pointer';
        buttonCopy.onclick = generateURL;
        sidebar.insertBefore(buttonCopy, sidebar.firstChild);

        const buttonFD = document.createElement('button');
        buttonFD.textContent = 'Toggle File Display';
        buttonFD.style.marginTop = '10px';
        buttonFD.style.marginBottom = '10px';
        buttonFD.style.width = '95%';
        buttonFD.style.padding = '5px';
        buttonFD.style.cursor = 'pointer';
        buttonFD.onclick = toggleFileDisplay;
        sidebar.insertBefore(buttonFD, sidebar.firstChild);

        const buttonSS = document.createElement('button');
        buttonSS.id = 'toggleStaticShapesBtn';
        buttonSS.textContent = 'Static Maps Shapes: Off';
        buttonSS.style.marginTop = '10px';
        buttonSS.style.marginBottom = '10px';
        buttonSS.style.width = '95%';
        buttonSS.style.padding = '5px';
        buttonSS.style.cursor = 'pointer';
        buttonSS.onclick = function() {
            if (window.toggleStaticShapes) window.toggleStaticShapes();
        };
        sidebar.insertBefore(buttonSS, sidebar.firstChild);

        // --- Dredge Data Input Section ---
        const dredgeContainer = document.createElement('div');
        dredgeContainer.style.marginTop = '10px';
        dredgeContainer.style.padding = '5px';
        dredgeContainer.style.borderTop = '1px solid #ccc';
        dredgeContainer.style.borderBottom = '1px solid #ccc';
        
        const dredgeLabel = document.createElement('div');
        dredgeLabel.innerHTML = '<b>Dredge Volumes (xlsx/ods)</b>';
        dredgeContainer.appendChild(dredgeLabel);
        
        const fileInput = document.createElement('input');
        fileInput.type = 'file';
        fileInput.accept = '.xlsx, .ods';
        fileInput.style.width = '95%';
        fileInput.style.marginTop = '5px';
        fileInput.addEventListener('change', handleDredgeVolumeUpload);
        dredgeContainer.appendChild(fileInput);
        
        // URL Input
        const urlContainer = document.createElement('div');
        urlContainer.style.marginTop = '5px';
        const urlInput = document.createElement('input');
        urlInput.type = 'text';
        urlInput.id = 'dredgeVolUrl';
        urlInput.placeholder = 'URL to Dredge Data';
        urlInput.style.width = '70%';
        urlContainer.appendChild(urlInput);

        const loadBtn = document.createElement('button');
        loadBtn.textContent = 'Load';
        loadBtn.style.width = '25%';
        loadBtn.onclick = function() {
            const url = document.getElementById('dredgeVolUrl').value;
            if (url) loadDredgeVolumeFromUrl(url);
        };
        urlContainer.appendChild(loadBtn);
        dredgeContainer.appendChild(urlContainer);

        const densityContainer = document.createElement('div');
        densityContainer.style.marginTop = '5px';
        densityContainer.innerHTML = 'Density (T/m³): ';
        
        const densityInput = document.createElement('input');
        densityInput.type = 'number';
        densityInput.id = 'dredgeDensity';
        densityInput.value = '1.5';
        densityInput.step = '0.1';
        densityInput.style.width = '60px';
        densityInput.addEventListener('change', function() {
            if (window.updateSummaryChart) window.updateSummaryChart();
        });
        densityContainer.appendChild(densityInput);
        dredgeContainer.appendChild(densityContainer);

        const yearContainer = document.createElement('div');
        yearContainer.style.marginTop = '5px';
        yearContainer.innerHTML = 'Years: ';
        
        const startYearInput = document.createElement('input');
        startYearInput.type = 'number';
        startYearInput.id = 'dredgeStartYear';
        startYearInput.placeholder = 'Start';
        startYearInput.style.width = '60px';
        startYearInput.style.marginRight = '5px';
        startYearInput.addEventListener('change', function() {
            if (window.updateSummaryChart) window.updateSummaryChart();
        });
        yearContainer.appendChild(startYearInput);

        const endYearInput = document.createElement('input');
        endYearInput.type = 'number';
        endYearInput.id = 'dredgeEndYear';
        endYearInput.placeholder = 'End';
        endYearInput.style.width = '60px';
        endYearInput.addEventListener('change', function() {
            if (window.updateSummaryChart) window.updateSummaryChart();
        });
        yearContainer.appendChild(endYearInput);
        dredgeContainer.appendChild(yearContainer);
        
        sidebar.insertBefore(dredgeContainer, sidebar.firstChild);

        // --- Standards Selection ---
        const stdContainer = document.createElement('div');
        stdContainer.style.marginTop = '10px';
        stdContainer.style.marginBottom = '10px';
        stdContainer.style.width = '95%';
        stdContainer.style.padding = '5px';
        stdContainer.style.borderTop = '1px solid #ccc';
        stdContainer.style.borderBottom = '1px solid #ccc';
        
        const stdLabel = document.createElement('div');
        stdLabel.innerHTML = '<b>Quality Standard</b>';
        stdContainer.appendChild(stdLabel);

        const stdSelect = document.createElement('select');
        stdSelect.id = 'standardDropdown';
        stdSelect.style.width = '100%';
        stdSelect.style.marginTop = '5px';
        
        if (typeof standards !== 'undefined') {
            for (const key in standards) {
                const opt = document.createElement('option');
                opt.value = key;
                opt.textContent = key;
                if (key === chosenStandard) opt.selected = true;
                stdSelect.appendChild(opt);
            }
        }

        stdSelect.addEventListener('change', function() {
            chosenStandard = this.value;
            if (window.updateChart) window.updateChart();
            if (typeof createStandardFilterUI === 'function') createStandardFilterUI();
        });

        stdContainer.appendChild(stdSelect);
        sidebar.insertBefore(stdContainer, sidebar.firstChild);

/*        // Create the Area Tooltips button
        const buttonArea = document.createElement('button');
        buttonArea.id = 'toggleAreaTooltipsBtn';
        buttonArea.textContent = 'Show All Area Names';
        buttonArea.style.marginTop = '10px';
        buttonArea.style.marginBottom = '10px';
        buttonArea.style.width = '95%';
        buttonArea.style.padding = '5px';
        buttonArea.style.cursor = 'pointer';
//        buttonArea.onclick = toggleAllAreaTooltips;

        // Try to place it next to the "Show All Sample Names" button if it exists
        const sampleBtn = document.getElementById('toggleTooltipsBtn');
        if (sampleBtn && sampleBtn.parentNode) {
            // Insert after the sample button
            sampleBtn.parentNode.insertBefore(buttonArea, sampleBtn.nextSibling);
        } else {
            // Fallback to inserting at the top of the sidebar
            sidebar.insertBefore(buttonArea, sidebar.firstChild);
        }*/
    }
}

function handleDredgeVolumeUpload(e) {
    const file = e.target.files[0];
    if (!file) return;
    
    const reader = new FileReader();
    reader.onload = function(e) {
        const data = new Uint8Array(e.target.result);
        processDredgeVolumeData(data);
    };
    reader.readAsArrayBuffer(file);
}

function loadDredgeVolumeFromUrl(url) {
    fetch(url)
        .then(response => response.arrayBuffer())
        .then(data => {
            processDredgeVolumeData(new Uint8Array(data), url);
        })
        .catch(err => console.error("Error loading dredge volume data:", err));
}

    function exportToCSV() {
        const rows = [];
        rows.push(['Sampling Date', 'Sampling Qualifier', 'Latitude', 'Longitude', 'Depth', 'Chemical Name', 'Chemical Shortname', 'Concentration', 'Units', 'Marine Licence', 'Sample Name', 'File url']);

        for (const dateSampled in sampleMeasurements) {
            const info = sampleInfo[dateSampled];
            if (!info) continue;

            const fullDate = info['Date sampled'] || '';
            const dateOnly = fullDate.slice(0, 10);
            const qualifier = fullDate.slice(10).trim();
            const licence = info['Application number'] || '';
            const url = info['fileURL'] || '';
            
            for (const sheetName in sampleMeasurements[dateSampled]) {
                const sheet = sampleMeasurements[dateSampled][sheetName];
                if (!sheet.chemicals) continue;

                const units = sheet['Unit of measurement'] || '';

                for (const chemical in sheet.chemicals) {
                    const shortName = (typeof ddLookup !== 'undefined' && ddLookup.reverseChemical && ddLookup.reverseChemical[chemical]) ? ddLookup.reverseChemical[chemical] : '';

                    const samples = sheet.chemicals[chemical].samples;
                    for (const sampleName in samples) {
                        const concentration = samples[sampleName];
                        
                        let lat = '', lon = '', depth = '';
                        if (info.position && info.position[sampleName]) {
                            const pos = info.position[sampleName];
                            lat = pos['Position latitude'];
                            lon = pos['Position longitude'];
                            const d = pos['Sampling depth (m)'];
                            if (d) {
                                if (d.minDepth === d.maxDepth) {
                                    depth = d.minDepth;
                                } else {
                                    depth = `${d.minDepth}-${d.maxDepth}`;
                                }
                            }
                        }

                        rows.push([dateOnly, qualifier, lat, lon, depth, chemical, shortName, concentration, units, licence, sampleName, url]);
                    }
                }
            }
        }

        const csvContent = rows.map(row => 
            row.map(field => {
                const str = String(field === null || field === undefined ? '' : field);
                if (str.includes(',') || str.includes('"') || str.includes('\n')) {
                    return `"${str.replace(/"/g, '""')}"`;
                }
                return str;
            }).join(',')
        ).join('\n');

        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
        const link = document.createElement("a");
        if (link.download !== undefined) {
            const url = URL.createObjectURL(blob);
            link.setAttribute("href", url);
            link.setAttribute("download", "sediment_data_export.csv");
            link.style.visibility = 'hidden';
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }
    }

    function exportFilteredToCSV() {
        const rows = [];
        rows.push(['Sampling Date', 'Sampling Qualifier', 'Latitude', 'Longitude', 'Depth', 'Chemical Name', 'Chemical Shortname', 'Concentration', 'Units', 'Marine Licence', 'Sample Name', 'File url']);

        for (const dateSampled in selectedSampleMeasurements) {
            const info = selectedSampleInfo[dateSampled];
            if (!info) continue;

            const fullDate = info['Date sampled'] || '';
            const dateOnly = fullDate.slice(0, 10);
            const qualifier = fullDate.slice(10).trim();
            const licence = info['Application number'] || '';
            const url = info['fileURL'] || '';
            
            for (const sheetName in selectedSampleMeasurements[dateSampled]) {
                const sheet = selectedSampleMeasurements[dateSampled][sheetName];
                if (!sheet.chemicals) continue;

                const units = sheet['Unit of measurement'] || '';

                for (const chemical in sheet.chemicals) {
                    const shortName = (typeof ddLookup !== 'undefined' && ddLookup.reverseChemical && ddLookup.reverseChemical[chemical]) ? ddLookup.reverseChemical[chemical] : '';

                    const samples = sheet.chemicals[chemical].samples;
                    for (const sampleName in samples) {
                        const concentration = samples[sampleName];
                        
                        let lat = '', lon = '', depth = '';
                        if (info.position && info.position[sampleName]) {
                            const pos = info.position[sampleName];
                            lat = pos['Position latitude'];
                            lon = pos['Position longitude'];
                            const d = pos['Sampling depth (m)'];
                            if (d) {
                                if (d.minDepth === d.maxDepth) {
                                    depth = d.minDepth;
                                } else {
                                    depth = `${d.minDepth}-${d.maxDepth}`;
                                }
                            }
                        }

                        rows.push([dateOnly, qualifier, lat, lon, depth, chemical, shortName, concentration, units, licence, sampleName, url]);
                    }
                }
            }
        }

        const csvContent = rows.map(row => 
            row.map(field => {
                const str = String(field === null || field === undefined ? '' : field);
                if (str.includes(',') || str.includes('"') || str.includes('\n')) {
                    return `"${str.replace(/"/g, '""')}"`;
                }
                return str;
            }).join(',')
        ).join('\n');

        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
        const link = document.createElement("a");
        if (link.download !== undefined) {
            const url = URL.createObjectURL(blob);
            link.setAttribute("href", url);
            link.setAttribute("download", "sediment_data_filtered_export.csv");
            link.style.visibility = 'hidden';
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }
    }
    


function processDredgeVolumeData(data, sourceUrl = null) {
    const workbook = XLSX.read(data, {type: 'array'});
    const sheetName = workbook.SheetNames[0];
    const sheet = workbook.Sheets[sheetName];
    const json = XLSX.utils.sheet_to_json(sheet, {header: 1});
    
    if (json.length < 2) return;
    
    const years = [];
    const yearIndices = [];
    const processedYears = new Set();
    // Assume row 0 is headers. Start from column 1 (Reach is col 0)
    for (let i = 1; i < json[0].length; i++) {
        const val = parseInt(json[0][i]);
        if (!isNaN(val) && val >= 2001 && val <= 2024) {
            if (!processedYears.has(val)) {
                years.push(val);
                yearIndices.push(i);
                processedYears.add(val);
            }
        }
    }

    function exportToCSV() {
        const rows = [];
        rows.push(['Sampling Date', 'Sampling Qualifier', 'Latitude', 'Longitude', 'Depth', 'Chemical Name', 'Chemical Shortname', 'Concentration', 'Units', 'Marine Licence', 'Sample Name', 'File url']);

        for (const dateSampled in sampleMeasurements) {
            const info = sampleInfo[dateSampled];
            if (!info) continue;

            const fullDate = info['Date sampled'] || '';
            const dateOnly = fullDate.slice(0, 10);
            const qualifier = fullDate.slice(10).trim();

            const licence = info['Application number'] || '';
            const url = info['fileURL'] || '';
            
            for (const sheetName in sampleMeasurements[dateSampled]) {
                const sheet = sampleMeasurements[dateSampled][sheetName];
                if (!sheet.chemicals) continue;

                const units = sheet['Unit of measurement'] || '';

                for (const chemical in sheet.chemicals) {
                    const shortName = (typeof ddLookup !== 'undefined' && ddLookup.reverseChemical && ddLookup.reverseChemical[chemical]) ? ddLookup.reverseChemical[chemical] : '';

                    const samples = sheet.chemicals[chemical].samples;
                    for (const sampleName in samples) {
                        const concentration = samples[sampleName];
                        
                        let lat = '', lon = '', depth = '';
                        if (info.position && info.position[sampleName]) {
                            const pos = info.position[sampleName];
                            lat = pos['Position latitude'];
                            lon = pos['Position longitude'];
                            const d = pos['Sampling depth (m)'];
                            if (d) {
                                if (d.minDepth === d.maxDepth) {
                                    depth = d.minDepth;
                                } else {
                                    depth = `${d.minDepth}-${d.maxDepth}`;
                                }
                            }
                        }

                        rows.push([dateOnly, qualifier, lat, lon, depth, chemical, shortName, concentration, units, licence, sampleName, url]);
                    }
                }
            }
        }

        const csvContent = rows.map(row => 
            row.map(field => {
                const str = String(field === null || field === undefined ? '' : field);
                if (str.includes(',') || str.includes('"') || str.includes('\n')) {
                    return `"${str.replace(/"/g, '""')}"`;
                }
                return str;
            }).join(',')
        ).join('\n');

        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
        const link = document.createElement("a");
        if (link.download !== undefined) {
            const url = URL.createObjectURL(blob);
            link.setAttribute("href", url);
            link.setAttribute("download", "sediment_data_export.csv");
            link.style.visibility = 'hidden';
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }
    }

    function exportFilteredToCSV() {
        const rows = [];
        rows.push(['Sampling Date', 'Sampling Qualifier', 'Latitude', 'Longitude', 'Depth', 'Chemical Name', 'Chemical Shortname', 'Concentration', 'Units', 'Marine Licence', 'Sample Name', 'File url']);

        for (const dateSampled in selectedSampleMeasurements) {
            const info = selectedSampleInfo[dateSampled];
            if (!info) continue;

            const fullDate = info['Date sampled'] || '';
            const dateOnly = fullDate.slice(0, 10);
            const qualifier = fullDate.slice(10).trim();

            const licence = info['Application number'] || '';
            const url = info['fileURL'] || '';
            
            for (const sheetName in selectedSampleMeasurements[dateSampled]) {
                const sheet = selectedSampleMeasurements[dateSampled][sheetName];
                if (!sheet.chemicals) continue;

                const units = sheet['Unit of measurement'] || '';

                for (const chemical in sheet.chemicals) {
                    const shortName = (typeof ddLookup !== 'undefined' && ddLookup.reverseChemical && ddLookup.reverseChemical[chemical]) ? ddLookup.reverseChemical[chemical] : '';

                    const samples = sheet.chemicals[chemical].samples;
                    for (const sampleName in samples) {
                        const concentration = samples[sampleName];
                        
                        let lat = '', lon = '', depth = '';
                        if (info.position && info.position[sampleName]) {
                            const pos = info.position[sampleName];
                            lat = pos['Position latitude'];
                            lon = pos['Position longitude'];
                            const d = pos['Sampling depth (m)'];
                            if (d) {
                                if (d.minDepth === d.maxDepth) {
                                    depth = d.minDepth;
                                } else {
                                    depth = `${d.minDepth}-${d.maxDepth}`;
                                }
                            }
                        }

                        rows.push([dateOnly, qualifier, lat, lon, depth, chemical, shortName, concentration, units, licence, sampleName, url]);
                    }
                }
            }
        }

        const csvContent = rows.map(row => 
            row.map(field => {
                const str = String(field === null || field === undefined ? '' : field);
                if (str.includes(',') || str.includes('"') || str.includes('\n')) {
                    return `"${str.replace(/"/g, '""')}"`;
                }
                return str;
            }).join(',')
        ).join('\n');

        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
        const link = document.createElement("a");
        if (link.download !== undefined) {
            const url = URL.createObjectURL(blob);
            link.setAttribute("href", url);
            link.setAttribute("download", "sediment_data_filtered_export.csv");
            link.style.visibility = 'hidden';
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }
    }

    const areas = {};
    for (let i = 1; i < json.length; i++) {
        const row = json[i];
        let areaName = row[0];
        if (areaName !== undefined && areaName !== null) {
            // Check if areaName is just a number
            if (!isNaN(areaName) && !isNaN(parseFloat(areaName))) {
                areaName = "Chart " + areaName;
            } else {
                areaName = String(areaName);
            }

            areas[areaName] = {};
            for (let k = 0; k < yearIndices.length; k++) {
                const colIdx = yearIndices[k];
                const year = years[k];
                let vol = parseFloat(row[colIdx]);
                if (isNaN(vol)) vol = 0;
                areas[areaName][year] = vol;
            }
        }
    }
    
    window.dredgeVolumeData = { years, areas, sourceUrl };
    if (window.updateSummaryChart) window.updateSummaryChart();
}

function importData() {
    var urls = {};
    if (firstTime) {
        createControlButtons();
        importShapes();
        importLocations();
        firstTime = false;
        files = {};
        // Get the current URL
        const currentURL = window.location.href;
        // Parse the URL to get the search parameters
        const suppliedParams = new URLSearchParams(window.location.search);
        // Get the value of the 'status' parameter
        const statusParam = suppliedParams.get('status');
        if (statusParam) {
            loadStatus(statusParam);
        }// else {
            const urlParam = suppliedParams.get('urls');
            if (urlParam) {
                urls = urlParam.split(',').map(url => url.trim()); // Split comma-separated URLs
            }
//        }
        checkboxParameters(suppliedParams, 'selcharts', dataSheetNamesCheckboxes);
        checkboxParameters(suppliedParams, 'subcharts', subChartNames);
        const featuresParams = suppliedParams.get('features');
        if (featuresParams) {
            features = featuresParams.split(',').map(feature => feature.trim()); // Split comma-separated features
            if(!features.includes('nomap')) {
                const everythingMaps = document.getElementById('everything-maps');
                everythingMaps.style.display = 'inline';
            }
            if(!features.includes('noninter')) {
//                const everything = document.getElementById('controls-sidebar');
//                everything.style.display = 'inline';
//            sidebar.classList.toggle('collapsed');
                toggleSidebar();
            }
        } else {
            const everythingMaps = document.getElementById('everything-maps');
            everythingMaps.style.display = 'inline';
            toggleSidebar();
//            const everything = document.getElementById('controls-sidebar');
//            everything.style.display = 'inline';
        }
//console.log(suppliedParams);
        const durlParam = suppliedParams.get('durl');
//console.log(durlParam);
        if (durlParam) {
/*            var urlInputDD = document.getElementById('urlInputDD');
            urlInputDD.value = durlParam;
            importDredgeData(durlParam);*/
            dlat = suppliedParams.get('dlat');
            dlon = suppliedParams.get('dlon');
            drad = suppliedParams.get('drad');
            dstart = suppliedParams.get('dstart');
            dfinish = suppliedParams.get('dfinish');
            dlicences = suppliedParams.get('dlics')
/*            if (dlat && dlon && drad) {
                centreLat = document.getElementById('centreLatitude');
                centreLon = document.getElementById('centreLongitude');
                radius = document.getElementById('radius');
                centreLat.value = dlat;
                centreLon.value = dlon;
                radius.value = drad;
//                closeCEFASSearch();
            }*/
            importDredgeData(durlParam,dlat,dlon,drad,dstart,dfinish,dlicences);
        }
        const dredgeVolParam = suppliedParams.get('dredgevol');
        if (dredgeVolParam) {
            loadDredgeVolumeFromUrl(dredgeVolParam);
            const urlInput = document.getElementById('dredgeVolUrl');
            if (urlInput) urlInput.value = dredgeVolParam;
        }

        const dVolStartParam = suppliedParams.get('dvolstart');
        if (dVolStartParam) {
            const startInput = document.getElementById('dredgeStartYear');
            if (startInput) startInput.value = dVolStartParam;
        }

        const dVolEndParam = suppliedParams.get('dvolend');
        if (dVolEndParam) {
            const endInput = document.getElementById('dredgeEndYear');
            if (endInput) endInput.value = dVolEndParam;
        }

        const sortParam = suppliedParams.get('sort');
//console.log(durlParam);
        if (sortParam) {
            xAxisSort = sortParam;
//            xAxisSortRadio = document.querySelector('input[name="sorting"][xAxisSort]');
//            xAxisSortRadio = document.querySelector('input[name="sorting"]');
            xAxisSortRadio = document.getElementById(xAxisSort);
            if (xAxisSortRadio) {
                xAxisSortRadio.checked = true;
            }
/*            switch (sortParam) {
                case 'normal': xAxisSort = 'normal'; break
                case 'latitude': xAxisSort = 'latitude'; break
                case 'longitude': xAxisSort = 'longitude'; break
                case 'datelatitude': xAxisSort = 'latitude'; break
                case 'datelongitude': xAxisSort = 'longitude'; break
                case 'totalarea': xAxisSort = 'totalarea'; break
            }*/
        }
        const lookParam = suppliedParams.get('look');
//console.log(durlParam);
        if (lookParam) {
            lookSetting = lookParam;
            lookRadio = document.getElementById(look);
            lookRadio.checked = true;
        }
    } else {
        const fileInput = document.getElementById('fileInput');
        const urlInput = document.getElementById('urlInput');
        files = fileInput.files; // Files is now a FileList object containing multiple files
        //console.log(files);
        urls = urlInput.value.trim().split(',').map(url => url.trim()); // Split comma-separated URLs
    }
    if (files.length === 0 && urls.length === 0) {
        alert('Please select files or enter URLs.');
        return;
    }
    // Process files
    if (files.length > 0) {
        let filesProcessed = 0; // counter to track the number of files processed
        let fL = files.length;
        //console.log(files.length);
        for (let i = 0; i < files.length; i++) {
            const filename = files[i].name;
            //console.log(filename);
            const reader = new FileReader();

            reader.onload = function (e) {
                const data = new Uint8Array(e.target.result);
                processExcelData(data, filename, filesProcessed);
                filesProcessed++; // Increment the counter after processing each file
                // Check if all files have been processed
                //console.log(files.length,fL, filesProcessed);
                if (filesProcessed === fL) {
                    //console.log('calling updateChart');
                    updateChart(); // Call updateChart once all files have been processed
                //    3
                }
            };
            reader.readAsArrayBuffer(files[i]);
        }
        //            updateChart();
    }

// Process URLs only if URLs are supplied
/*        if (urls.length > 0) {
            urls.forEach(url => {
                // Check if the URL is a valid URL before fetching
                if (!/^https?:\/\//i.test(url)) {
                    console.error('Invalid URL:', url);
                    return;
                }

                fetch(url)
                    .then(response => response.arrayBuffer())
                    .then(data => {
                        processExcelData(new Uint8Array(data), url);
//                        updateChart();
                        console.log('processexceldata again');
                    })
                    .catch(error => {
                        console.error('Error fetching the file:', error);
                    });
                console.log('here again');
            });
            console.log('there again');
        }*/
        if (urls.length > 0) {
            // Array to store all fetch promises
            const fetchPromises = [];
            let i = 0; // Initialize i to keep track of the file number
            // Loop through each URL and create a fetch promise
            urls.forEach(url => {
                // Check if the URL is a valid URL before fetching
                if (!/^https?:\/\//i.test(url)) {
                    console.error('Invalid URL:', url);
                    return;
                }
        
                // Push each fetch promise into the array
                fetchPromises.push(
                    fetch(url)
                        .then(response => response.arrayBuffer())
                        .then(data => {
                            i += 1; // Increment i for each URL
                            processExcelData(new Uint8Array(data), url, i);
//console.log('processexceldata again');
                        })
                        .catch(error => {
                            console.error('Error fetching the file ',url,':', error);
                        })
                );
            });
        
            // Wait for all fetch promises to resolve
            Promise.all(fetchPromises)
                .then(() => {
                    updateChart();
//console.log('there again');
                });
        }
//console.log('Import Data out of fetch');
//        updateChart();
// Clear the input field after reading data
        fileInput.value = '';
        urlInput.value = '';
    }

function processExcelData(data, url, fileNumber) {
    // console.log('processexceldata',url);
    const workbook = XLSX.read(data, { type: 'array' });

    function extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber) {
        let missingTotalSolids = true;
        let missingVisualAppearance = true;
        let missingOrganicCarbon = true;
        if (sheetData === null || sheetData == undefined) {
            return null;
        }
        //console.log('ext data ',sheetData);
        const df = XLSX.utils.sheet_to_json(sheetData, { header: 1 });
        //                const df = XLSX.utils.sheet_to_json(sheetData, { header: 1, cellText: true });
        let startRow = -1;
        let startCol = -1;
        let measurementUnit = 'Not set';
        let totalSum = 0;
        meas = {};
        // Read in date of analysis
        //console.log('df ', df);
        if (df[18][1] === 'Date of analysis:') {
            row = 18;
            column = 2;
        } else {
            if (df[17][1] === 'Date of analysis:') {
                row = 17;
                column = 2;
            } else {
                if (df[18][2] === 'Date of analysis:') {
                    row = 18;
                    column = 3;
                } else {
                    if (df[17][2] === 'Date of analysis:') {
                        row = 17;
                        column = 3;
                    } else {
                        row = null;
                        dataAnalysed = 'AD: missing';
                        contractor = 'Not listed';
                    }
                }
            }
        }
        dateAnalysed = 'AD: missing';
        contractor = 'Not listed';
        for (let cc = 0; cc < 30; cc++) {
            for (let r = 0; r < 30; r++) {
                const cellValue = df[r][cc];
                //console.log(sheetName,r,cc);
                if (typeof cellValue === 'string' && cellValue.includes('Date of analysis')) {
                    dateAnalysed = parseDates(df[r][cc + 1])[0];
                    contractor = df[r - 1][cc + 1];
                    break;
                }
            }
        }

        for (let r = 0; r < df.length; r++) {
            for (let cc = 0; cc < df[r].length; cc++) {
                const cellValue = df[r][cc];
                if (typeof cellValue === 'string' && cellValue.includes('Dredge Area')) {
                    c = cc - 1;
                    measurementUnit = df[r][c + 4];
                    corec = 0;
                    extraValue = df[r][c];
                    if (typeof extraValue === 'string' && extraValue.includes('Laboratory sample number')) {
                        //console.log('Lab sampl numb');
                        corec = 0;
                        measurementUnit = df[r][c + 4];
                    } else {
                        //console.log('No Lab sampl numb');
                        corec = 0;
                        measurementUnit = df[r][c + 3];
                    }
                    //}
//console.log('unit ',measurementUnit);
                    if (!(sheetName === 'Physical Data')) {
                        if (!(sheetName === 'PCB data')) {
                            startRow = r + 2;
                        } else {
                            startRow = r + 3;
                        }
                        startCol = c;
                        for (let col = startCol + 1; col < df[startRow].length; col++) {
                            if (!(sheetName === 'PCB data')) {
                                rawChemical = df[startRow - 1][col];
                            } else {
                                rawChemical = df[startRow - 2][col];
                                congener = df[startRow - 1][col];
                            }
                            if (rawChemical !== null && rawChemical !== undefined) {
                                // Need to tidy name coming from template
                                // In BDE seem to have variations some with \n or \r\n
                                //if(sheetName === 'BDE data') {
                                //    console.log('r ',rawChemical);
                                //}
                                chemical = cleanChemicalString(rawChemical);

                                //if(sheetName === 'BDE data') {
                                //    console.log('c ',chemical);
                                //}
                                if (!meas.chemicals) {
                                    meas.chemicals = {};
                                    meas.total = {};
                                    if (sheetName === 'PCB data') {
                                        meas.congeners = {};
                                    }
                                }
                                if (!meas.chemicals[chemical]) {
                                    meas.chemicals[chemical] = {};
                                    if (sheetName === 'PCB data') {
                                        meas.congeners[chemical] = congener;
                                    }
                                }
                                for (let row = startRow; row < df.length; row++) {
                                    sample = df[row][startCol + 2]; //bodge to pick up sample id
                                    // If sample id not present then use Laboratory sample number instead
                                    if (sample == undefined || sample == null) {
                                        sample = df[row][startCol];
                                    }
                                    if (!(sample == undefined || sample == null)) {
                                        //console.log(sample);
                                        let concentration = df[row][col + corec];
                                        if (isNaN(concentration)) {
                                            concentration = 0.0;
                                        }
                                        if (sample.includes('detection')) {
                                            meas.chemicals[chemical][sample] = concentration;
                                            //.push(parseFloat(concentration) || 0);
                                        } else {
                                            if (!meas.chemicals[chemical].samples) {
                                                meas.chemicals[chemical].samples = {};
                                            }
                                            if (!meas.chemicals[chemical].samples[sample]) {
                                                meas.chemicals[chemical].samples[sample] = {};
                                            }
                                            if (!meas.total[sample]) {
                                                meas.total[sample] = 0;
                                            }
                                            if (concentration !== null && concentration !== undefined) {
                                                meas.chemicals[chemical].samples[sample] = parseFloat(concentration);
                                                meas.total[sample] += parseFloat(concentration) || 0;
                                                totalSum += parseFloat(concentration) || 0;
                                            }
                                        }
                                    }
                                }
                            } else if (sheetName === 'PAH data') {
                                hydrocarbon = df[startRow - 2][col];
                                if (hydrocarbon !== null && hydrocarbon !== undefined) {
                                    if (hydrocarbon === 'Total hydrocarbon content (mg/kg)') {
                                        for (let row = startRow; row < df.length; row++) {
                                            sample = df[row][startCol + 2]; //bodge to pick up sample id
                                            // If sample id not present then use Laboratory sample number instead
                                            if (sample == undefined || sample == null) {
                                                sample = df[row][startCol];
                                            }
                                            if (!(sample == undefined || sample == null)) {
                                                const concentration = parseFloat(df[row][col + corec]);
                                                if (sample.includes('detection')) {
                                                    meas[sample] = concentration;
                                                    //.push(parseFloat(concentration) || 0);
                                                } else {
                                                    if (!meas.totalHC) {
                                                        meas.totalHC = {};
                                                        meas.totalHCUnit = hydrocarbon;
                                                    }
                                                    if (isNaN(concentration)) {
                                                        meas.totalHC[sample] = 0.0;
                                                    } else {
                                                        meas.totalHC[sample] = concentration;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
//console.log('meas ',meas,sheetName,dateSampled);
//fred = df;
                        if ('total' in meas) {

                        allSamples = Object.keys(meas.total);
//console.log('allSamples ',allSamples,sheetName,dateSampled);
//console.log(sampleMeasurements[dateSampled]['Physical Data'].samples[allSamples[0]]);
//fred = sampleMeasurements[dateSampled]['Physical Data'].samples[allSamples[0]];
//                        if (!sampleMeasurements[dateSampled]['Physical Data'].samples[allSamples[0]]['Total solids (% total sediment)']) {
//                        if (sampleMeasurements[dateSampled]['Physical Data'].samples[allSamples[0]]['Total solids (% total sediment)'] === undefined) {
//console.log('New test: No total solids',dateSampled, sheetName, allSamples[0]);
//console.log(sampleMeasurements[dateSampled]['Physical Data'].samples[allSamples[0]]);
// Code that reads Total Solids column into physical data
                        if (!(sampleMeasurements[dateSampled]?.['Physical Data']?.samples?.[allSamples[0]]?.['Total solids (% total sediment)'])) {
col = startCol + 3;
row = startRow - 2;
//console.log('col ',col,' row ',row, df[row][col]);
if(!(df[row][col] === undefined)) {
                            if (df[row][col].includes('Total Solids (%)')) {
//console.log('Total Solids found column found');
let ts = {};
let missingTotalSolids = true;
                                        for (let row = startRow; row < df.length; row++) {
                                            sample = df[row][startCol + 2]; //bodge to pick up sample id
                                            // If sample id not present then use Laboratory sample number instead
                                            if (sample == undefined || sample == null) {
                                                sample = df[row][startCol];
                                            }
                                            if (!(sample == undefined || sample == null)) {
                                                const totalSolids = parseFloat(df[row][col + corec]);
//                                                if (sample.includes('detection')) {
//                                                    ts[sample] = totalSolids;
//                                                    //.push(parseFloat(concentration) || 0);
//                                                } else {
                                                    if (isNaN(totalSolids)) {
                                                        ts[sample] = 0.0;
                                                    } else {
                                                        ts[sample] = totalSolids;
                                                        missingTotalSolids = false;
                                                    }
//                                                }
                                            }
                                        }

// Total solids are now dealt with as part of physical data, so if no other physical data then total solids won't be added!!!!!!!!!
// Possibly need to rethink this?????


                                        if (!missingTotalSolids && sampleMeasurements[dateSampled]?.['Physical Data']) {
                                        for (let sample in ts) {
//                                            if (!(sampleMeasurements[dateSampled]['Physical Data'].samples[sample] === undefined)) {
                                            if (!sampleMeasurements[dateSampled]?.['Physical Data']) {
                                                sampleMeasurements[dateSampled]['Physical Data'] = {};
                                                sampleMeasurements[dateSampled]['Physical Data'].samples = {};
                                            }
                                            if (sampleMeasurements[dateSampled]?.['Physical Data']?.samples[sample]) {
                                                sampleMeasurements[dateSampled]['Physical Data'].samples[sample]['Total solids (% total sediment)'] = ts[sample];
                                                if (!(ts[sample] === undefined)) {
                                                    missingTotalSolids = false;
                                                }
                                            } else {
                                                console.log('No physical data for ',sample);
                                            }
                                        }
                                    }

                            }
                        }

                        }
                    }
                    } else {
                        measurementUnit = df[r][c + 7];
                        meas.samples = {};
                        meas.sizes = [];
                        startRow = r + 3;
                        startCol = c;
                        deltaExempt = 0;
//console.log(df[startRow],df[startRow-1],df[startRow-2],df[startRow-3]);
                        if (df[startRow - 3][startCol + 4].includes('Exempt')) {
                            deltaExempt = 1;
                        }
                        let blankLine = 0;
                        for (let col = startCol + 6 + deltaExempt; col < df[startRow - 1].length; col++) {
                            meas.sizes.push(parseFloat(df[startRow - 2][col]) || 0);
                            for (let row = startRow; row < df.length; row++) {
                                sample = df[row][startCol + 2]; //bodge to pick up sample id
                                // If sample id not present then use Laboratory sample number instead
                                if (sample == undefined || sample == null) {
                                    sample = df[row][startCol];
                                }
                                //Stop if no sample id - end of data - may break if blank rows in data
                                if (!(sample == undefined || sample == null)) {
                                    //console.log(sheetName, col, row, sample);
                                    if (!meas.samples) {
                                        meas.samples = {}
                                    }
                                    if (!meas.samples[sample]) {
                                        meas.samples[sample] = {};
                                        meas.samples[sample].psd = [];
                                        visualAppearance = df[row][startCol + 3];
                                        meas.samples[sample]['Visual Appearance'] = visualAppearance;
//console.log(visualAppearance);
                                        if (!(visualAppearance === undefined)) {
//console.log('setting to false');
                                            missingVisualAppearance = false;
                                        }
//                                        meas.samples[sample]['Total solids (% total sediment)'] = df[row][startCol + 5];
//                                        meas.samples[sample]['Organic matter (total organic carbon)'] = df[row][startCol + 6];
                                        totalSolids = df[row][startCol + 4 + deltaExempt];
                                        meas.samples[sample]['Total solids (% total sediment)'] = totalSolids;
                                        if (!(totalSolids === undefined)) {
                                            missingTotalSolids = false;
                                        }
                                        organicCarbon = df[row][startCol + 5 + deltaExempt];
                                        meas.samples[sample]['Organic matter (total organic carbon)'] = organicCarbon;
                                        if (!(organicCarbon === undefined)) {
                                            missingOrganicCarbon = false;
                                        }
                                    }
                                    //console.log(sample);
                                    meas.samples[sample].psd.push(parseFloat(df[row][col]) || 0);
                                    //console.log('meas.psd ',df[row][col]);
                                } else {
                                    blankLine += 1;
                                    if (blankLine > 5) { // Allow for up to 5 blank lines in PSD data
                                        break;
                                    }
                                }
//console.log(sample);
                                        if (!(sample in sampleInfo[dateSampled].position)) {
                                            break;
                                        }
                            }
                        }
                        totalOfTotalArea = 0;
//console.log(meas.samples);
                        for (sample in meas.samples) {
                            currentPsd = meas.samples[sample].psd;
                            retData = psdPostProcess(currentPsd,meas.sizes);
                            meas.samples[sample].psd = [...retData['currentPsd'],0];
                            meas.samples[sample].psdAreas = retData['areas'];
                            meas.samples[sample].psdRelativeAreas = retData['relativeAreas'];
                            meas.samples[sample].splitWeights = retData['splitWeights'];
                            meas.samples[sample].splitAreas = retData['splitAreas'];
                            meas.samples[sample].splitRelativeAreas = retData['splitRelativeAreas'];
                            meas.samples[sample].cumWeights = retData['cumWeights'];
                            meas.samples[sample].cumAreas = retData['cumAreas'];
                            meas.samples[sample].totalArea = retData['totalArea'];
//                            totalOfTotalArea += retData['totalArea'];
                            totalSum += retData['totalArea'];
//console.log(totalSum);
                        }
                        meas.sizes = [...standard_phiSizes, 0];
                    }
                    break;
                }
            }
            if (startRow !== -1 && startCol !== -1) {
                break;
            }
        }
//console.log(meas,sheetName,dateSampled);
        if (sheetName === 'Physical Data') {
//console.log('Physical Data',Object.keys(meas.samples).length);
            if ((Object.keys(meas.samples).length === 0)) {
                disableRadioButtons(sortButtonGroups[sheetName], true);
//console.log('No data for ',sheetName,dateSampled);
                return 'No data for ' + sheetName;
            }
        } else {
            if (!(totalSum > 0)) {
                disableRadioButtons(sortButtonGroups[sheetName], true);
//console.log('No data for ',sheetName,dateSampled);
                return 'No data for ' + sheetName;
            }
        }
//console.log('Saving meas for ',sheetName,dateSampled);
        meas['Date analysed'] = dateAnalysed;
        meas['Unit of measurement'] = measurementUnit;
        meas['Laboratory/contractor'] = contractor;
//if (sheetName === 'Physical Data') {console.log(meas,totalSum);}
//        if (!(sheetName === 'Physical Data')) {
/*            if (!totalSum > 0) {
                disableRadioButtons(sortButtonGroups[sheetName], true);
                return 'No data for ' + sheetName;
            }*/
        //console.log(dateSampled, sheetName, 'meas ', meas);
//        if (!(meas.samples === undefined || meas.samples === null)) {
        if (sheetName === 'Physical Data') {
//console.log(meas);
            for (sample in meas.samples) {
                if (missingVisualAppearance) {
                    delete meas.samples[sample]['Visual Appearance'];
                }
                if (missingTotalSolids) {
                    delete meas.samples[sample]['Total solids (% total sediment)'];
                }
                if (missingOrganicCarbon) {
                    delete meas.samples[sample]['Organic matter (total organic carbon)'];
                }
            }
        }
//if (sheetName === 'Physical Data') {console.log(meas);}
            sampleMeasurements[dateSampled][sheetName] = meas;
            const sums = {};
            //console.log(meas);
            //for (const sheetName in meas) {
            if (sheetName === 'PAH data') {
                pahPostProcess(meas, dateSampled);
            }
            if (sheetName === 'PCB data') {
                pcbPostProcess(meas, dateSampled);
            }
        //}
//        }
        //}
        return dateAnalysed;
    }

    function extractApplicationDataFromSheet(sheetName, sheetData, url, fileNumber) {
//console.log('extractappdata',url);
        //            dateSampled = 'SD Missing';
        const df = XLSX.utils.sheet_to_json(sheetData, { header: 1 });
        //                const df = XLSX.utils.sheet_to_json(sheetData, { header: 1, cellText: true });

        //console.log(sheetName);  //Output each cell value to console
        //console.log(df.length);
        let startRow = -1;
        let startCol = -1;

        // This code should have found Applicant: but doesn't so bodged above
        /*                        if (typeof cellValue === 'string' && cellValue.includes('Applicant:')) {
                                console.log('found applicant');
                                const applicant = df[r][c+1];
                                const applicationNumber = df[r+1][c+1];
                                const applicationTitle = df[r+2][c+1];
                                const dateSampled = df[r+3][c+1];
                                const samplingLocation = df[r+4][c+1];
                            }
        */


        /*                // This relies on template first page not changing at all
                     const applicant = df[14][4];
                    const applicationNumber = df[15][4];
                    const applicationTitle = df[16][4];*/
        for (i = 16; i<19; i++) {
            dateRow = i;
//console.log('df[dateRow][2]',sheetName,i,dateRow,df[dateRow][2],df);                
            if (df[dateRow][2]?.includes('Date sampled:')) {
                break;
            }
            dateRow = 0;
            //					dateSampled = 'SD Missing';
        }
        if (dateRow > 0) {
            //console.log('here',dateRow);
            applicant = df[dateRow - 3][4];
            applicationNumber = df[dateRow - 2][4];
            applicationTitle = df[dateRow - 1][4];
            //console.log(df[dateRow][4]);
            //console.log(df);
            dateSampled = parseDates(df[dateRow][4])[0];
            //console.log(dateSampled);
        } else {
            //console.log('there');
            applicant = df[14][4];
            applicationNumber = df[15][4];
            applicationTitle = df[16][4];
            dateSampled = 'Missing';
            dateRow = 17;
        }
        dateSampled = dateSampled+' '+fileNumber;
        sampleInfo[dateSampled] = {};
        sampleInfo[dateSampled]['Applicant'] = applicant;
        sampleInfo[dateSampled]['Application number'] = applicationNumber;
        sampleInfo[dateSampled]['Application title'] = applicationTitle;
        sampleInfo[dateSampled]['Date sampled'] = dateSampled;
        sampleInfo[dateSampled]['fileURL'] = url;
        //console.log('extractapplicationdatafromsheet ', dateSampled,url);
        sampleInfo[dateSampled].position = {};
        sampleInfo[dateSampled].label = dateSampled;
        sampleMeasurements[dateSampled] = {};

        const samplingLocation = df[dateRow + 1][4];
        for (let c = 0; c < df.length; c++) {

            //Bodge as didn't read enough of columns when set by length alone
            //                    for (let r = 0; r < df[c].length; r++) {
            if (df[c].length < 40) {
                cdepth = 40;
            } else {
                cdepth = df[c].length;
            }
            for (let r = 0; r < cdepth; r++) {
                const cellValue = df[r][c];
                // console.log(c,r,cellValue);
                //                        if (typeof cellValue === 'string' && cellValue.includes('Excluded sample (MMO use)')) {
                if (typeof cellValue === 'string' && cellValue.includes('Sample location (decimal degrees, WGS84)')) {
                    //console.log('Sample Location');
                    const extraValue = df[r][c - 1]
                    //console.log(extraValue);
                    if (typeof extraValue === 'string' && extraValue.includes('Excluded sample (MMO use)')) {
                        startRow = r + 2;
                        startCol = c - 2;
                        samCol = startCol;
                        excCol = startCol + 1;
                        latCol = startCol + 2;
                        lonCol = startCol + 3;
                        namCol = startCol + 4;
                        depCol = startCol + 5;
                        dreCol = startCol + 6;
                    } else {
                        startRow = r + 2;
                        startCol = c - 1;
                        samCol = startCol;
                        excCol = startCol + 6; // not present here
                        dreCol = startCol + 5;
                        latCol = startCol + 1;
                        lonCol = startCol + 2;
                        namCol = startCol + 3;
                        depCol = startCol + 4;
                    }

                    for (let row = startRow; row < df.length; row++) {
                        const sample = df[row][samCol]; //bodge to pick up sample id
                        if (!(sample == undefined || sample == null)) {
                            sInfo = {};
                            sInfo['Excluded sample (MMO use)'] = df[row][excCol];
                            sInfo['Dredge area'] = df[row][dreCol];
                            point = parseCoordinates(df[row][latCol], df[row][lonCol]);
                            //console.log(df[row][latCol],df[row][lonCol]);
//console.log('point: ',point);
                            if (point === null || point === undefined) {
                                // latitude and longitude aren't specified so try to retrieve latlon from previously entered locations
                                cleanSample = sample.replace(/\s+/g, '').toLowerCase();
//console.log(sample,cleanSample);
                                if (cleanSample in namedLocations) {
//                                if (namedLocations[cleanSample] !== null && namedLocations[cleanSample] !== undefined) {
//console.log('found');
                                    point = {};
                                    point['latitude'] = namedLocations[cleanSample].latitude;
                                    point['longitude'] = namedLocations[cleanSample].longitude;
                                } else {
//console.log('not found');
                                    //console.log('lat and long undefined does not match', sample);
                                    point = {};
                                    point['latitude'] = undefined;
                                    point['longitude'] = undefined;
                                }
                            }
                            sInfo['Position latitude'] = point['latitude'];
                            sInfo['Position longitude'] = point['longitude'];
                            sInfo['Location name (as per sampling plan)'] = df[row][namCol];
                            sInfo['Sampling depth (m)'] = processDepth(df[row][depCol]);
                            sInfo['Sampling location'] = samplingLocation;
                            sInfo['label'] = sample;
                            sampleInfo[dateSampled].position[sample] = sInfo;
                        }
                    }
                    break;
                }
            }
            if (startRow !== -1 && startCol !== -1) {
                // console.log('Breaking up');
                break;
            }
        }
        /*            if (dateSampled === 'Missing'){
                        dateSampled = 'Missing';
        console.log('This is test');
                    }*/
        //console.log('end of function',dateSampled);
        return dateSampled;
    }


//                workbook.SheetNames.forEach(sheetName => {
//                    const sheetData = workbook.Sheets[sheetName];
//                    extractDataFromSheet(sheetName, sheetData);
//                });
        sheetName = 'Application info';
        sheetData = workbook.Sheets[sheetName];
//console.log('fileNumber',fileNumber);
        dateSampled = extractApplicationDataFromSheet(sheetName, sheetData, url, fileNumber);
//console.log('dateSampled',dateSampled);

        sheetName = 'Physical Data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);


        sheetName = 'PAH data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);
        newDateSampled = dateSampled;
//console.log(dateSampled,dateAnalysed);
        if (dateSampled.includes('Missing')) {
            // Date sampled is missing so include an M for missing and the analysis date
            newDateSampled = dateAnalysed + ' M'+fileNumber;
        } else if (dateSampled > dateAnalysed) {
            // Date sampled is later than date analysed so include an L for late and the analysis date
            newDateSampled = dateAnalysed + ' L'+fileNumber;
        }
        //Add in application number
//console.log(dateSampled,sampleInfo[dateSampled]);
        if ('Application number' in sampleInfo[dateSampled]) {
            if(!sampleInfo[dateSampled]['Application number']) {
                patternFile = '[A-Z]{3}_[0-9]{4}\_[0-9]{5}';
                fileURL = sampleInfo[dateSampled]['fileURL'];
//console.log(fileURL);
//console.log(pattern);
                matches = fileURL.match(patternFile);
/*                if (matches) {
                    console.log('matches');
                }*/
                sampleInfo[dateSampled]['Application number'] = matches ? matches[0] : 'NAN';
//console.log(fileURL);
//console.log(pattern.match(sampleInfo[dateSampled]['fileURL']));
//                sampleInfo[dateSampled]['Application number'] = fileURL.match(pattern)[0];
//                sampleInfo[dateSampled]['Application number'] = pattern.match(fileURL)[0];
}
            newDateSampled = newDateSampled + ' f ' + sampleInfo[dateSampled]['Application number'];
            sampleInfo[newDateSampled] = sampleInfo[dateSampled];
            sampleInfo[newDateSampled]['Date sampled'] = newDateSampled;
            sampleInfo[newDateSampled].label = newDateSampled;
            delete sampleInfo[dateSampled];
            sampleMeasurements[newDateSampled] = sampleMeasurements[dateSampled];
            delete sampleMeasurements[dateSampled];
        }
        dateSampled = newDateSampled;
        sheetName = 'PCB data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);
        sheetName = 'Trace metal data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);
        sheetName = 'BDE data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);
        sheetName = 'Organotins data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);
        sheetName = 'Organochlorine data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);
        
/*        sheetName = 'Physical Data';
        sheetData = workbook.Sheets[sheetName];
        dateAnalysed = extractDataFromSheet(sheetName, sheetData, dateSampled, fileNumber);*/

        
        selectedSampleMeasurements = sampleMeasurements;
        selectedSampleInfo = sampleInfo;
//        updateChart();
    };
//    updateChart();

    function processDepth(enteredDepth) {
//		console.log(enteredDepth);
      if (!enteredDepth) {
          return {
            minDepth: 0.0,
            maxDepth: 0.0,
      };
      }
      // Remove any non-numeric characters, except for dots and hyphens
      const cleanedDepth = enteredDepth.replace(/[^0-9.\-]/g, '');
    
      // Split the cleaned depth by hyphens to handle ranges
      const depthParts = cleanedDepth.split('-');
    
      // Convert the parts to numbers
      const numericDepths = depthParts.map(parseFloat);
    
      // Determine min and max depths
      const minDepth = Math.min(...numericDepths);
      const maxDepth = Math.max(...numericDepths);
    
      // Return the result
      return {
        minDepth: isNaN(minDepth) ? 0.0 : minDepth,
        maxDepth: isNaN(maxDepth) ? 0.0 : maxDepth,
      };
    }
    
// Function to create a new canvas for a chart
function createCanvas(instanceNo, row) {
//    if(typeof row === 'undefined') {
        htmlContainer = 'chartContainer';
        const container = document.getElementById(htmlContainer);
//    const container = document.getElementById('chartContainer');
        const canvas = document.createElement('canvas');
        canvas.id = 'chart' + instanceNo; // Unique chart ID
        container.appendChild(canvas); // Append the canvas to the container
/*    } else {
        htmlContainer = 'table';
console.log(row);
//        const cell = row.insertCell(); // Create a cell
        const container = document.getElementById(htmlContainer);
//    const container = document.getElementById('chartContainer');
        const canvas = document.createElement('canvas');
        canvas.id = 'chart' + instanceNo; // Unique chart ID
        row.appendChild(canvas); // Append the canvas to the container
    }*/
}

// Function to create a button for resetting zoom
function createExportButton(chart, instanceNo, container) {
    //console.log('creating zoom buttom',instanceNo);
    if (!container) {
        container = document.getElementById('chartContainer');
    }
    const button = document.createElement('button');
    button.id = 'buttone' + instanceNo
    button.textContent = 'Export';
    button.addEventListener('click', () => {
        exportChart(instanceNo);
    });
    container.appendChild(button);
}
        
function createGnuplotExportButton(chart, instanceNo, container) {
    if (!container) {
        container = document.getElementById('chartContainer');
    }
    const button = document.createElement('button');
    button.id = 'buttong' + instanceNo
    button.textContent = 'Export Gnuplot';
    button.addEventListener('click', () => {
        exportGnuplot(instanceNo);
    });
    container.appendChild(button);
}

function exportGnuplot(instanceNo) {
    const chart = chartInstance[instanceNo];
    if (!chart) return;

    const type = chart.config.type;
    let title = chart.options.plugins.title.text;
    if (Array.isArray(title)) title = title.join(' ');
    title = title || 'Chart';
    
    let xLabel = chart.options.scales.x.title.text;
    if (Array.isArray(xLabel)) xLabel = xLabel.join(' ');
    xLabel = xLabel || 'X Axis';
    
    let yLabel = chart.options.scales.y.title.text;
    if (Array.isArray(yLabel)) yLabel = yLabel.join(' ');
    yLabel = yLabel || 'Y Axis';
    
    let gnuplotContent = `# Gnuplot script for ${title}\n`;
    gnuplotContent += `set title "${title}"\n`;
    gnuplotContent += `set xlabel "${xLabel}"\n`;
    gnuplotContent += `set ylabel "${yLabel}"\n`;
    gnuplotContent += `set datafile separator ","\n`;
    gnuplotContent += `set term pngcairo size 1200,800\n`;
    gnuplotContent += `set output "${title.replace(/[^a-z0-9]/gi, '_').toLowerCase()}.png"\n`;

    if (type === 'bar') {
        gnuplotContent += `set style data histograms\n`;
        gnuplotContent += `set style histogram cluster gap 1\n`;
        gnuplotContent += `set style fill solid border -1\n`;
        gnuplotContent += `set boxwidth 0.9\n`;
        gnuplotContent += `set xtics rotate by -90 scale 0\n`;
        gnuplotContent += `set grid y\n`;
        gnuplotContent += `set key outside\n`;

        const datasets = chart.data.datasets;
        const labels = chart.data.labels;
        
        let dataBlock = `$DATA << EOD\n`;
        for (let i = 0; i < labels.length; i++) {
            let row = `"${labels[i]}"`;
            datasets.forEach(ds => {
                if (!ds.hidden) {
                    let val = ds.data[i];
                    if (val === undefined || val === null) val = 0;
                    row += `,${val}`;
                }
            });
            dataBlock += row + `\n`;
        }
        dataBlock += `EOD\n`;
        gnuplotContent += dataBlock;

        let plotCmds = [];
        let colIndex = 2; 
        datasets.forEach((ds) => {
            if (!ds.hidden) {
                plotCmds.push(`$DATA using ${colIndex}:xtic(1) title "${ds.label}"`);
                colIndex++;
            }
        });
        
        gnuplotContent += `plot ` + plotCmds.join(', ') + `\n`;

    } else if (type === 'line') {
        if (chart.options.scales.x.type === 'logarithmic') {
            gnuplotContent += `set logscale x\n`;
            gnuplotContent += `set format x "10^{%L}"\n`;
        }
        gnuplotContent += `set key outside\n`;
        gnuplotContent += `set grid\n`;

        const datasets = chart.data.datasets;
        const labels = chart.data.labels;

        let dataBlock = `$DATA << EOD\n`;
        for (let i = 0; i < labels.length; i++) {
            let row = `${labels[i]}`;
            datasets.forEach(ds => {
                if (!ds.hidden) {
                    let val = ds.data[i];
                    if (val === undefined || val === null) val = "NaN";
                    row += `,${val}`;
                }
            });
            dataBlock += row + `\n`;
        }
        dataBlock += `EOD\n`;
        gnuplotContent += dataBlock;

        let plotCmds = [];
        let colIndex = 2;
        datasets.forEach((ds) => {
            if (!ds.hidden) {
                plotCmds.push(`$DATA using 1:${colIndex} with lines title "${ds.label}" lw 2`);
                colIndex++;
            }
        });
        
        gnuplotContent += `plot ` + plotCmds.join(', ') + `\n`;
    }

    const blob = new Blob([gnuplotContent], { type: 'text/plain' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `${title.replace(/[^a-z0-9]/gi, '_')}.gp`;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
}

    // Function to create a button for resetting zoom
function createResetZoomButton(chart,instanceNo, container) {
//console.log('creating zoom buttom',instanceNo);
    if (!container) {
        container = document.getElementById('chartContainer');
    }
    const button = document.createElement('button');
    button.id = 'buttonz'+instanceNo
    button.textContent = 'Reset Zoom';
    button.addEventListener('click', () => {
        chart.resetZoom();
    });
    container.appendChild(button);
}
    
// Function to create a button for toggling legend
function createToggleLegendButton(chart,instanceNo, container) {
    if (!container) {
        container = document.getElementById('chartContainer');
    }
    const button = document.createElement('button');
    button.id = 'buttonl'+instanceNo
    if (!legends[instanceNo]) {
        button.textContent = 'Legend';
    } else {
        button.textContent = 'No Legend';
    }
    button.addEventListener('click', () => {
        if (legends[instanceNo]) {
            chartInstance[instanceNo].options.plugins.legend.display = false;
            chartInstance[instanceNo].update();
            legends[instanceNo] = false;
            button.innerHTML = 'Legend';
        } else {
            chartInstance[instanceNo].options.plugins.legend.display = true;
            chartInstance[instanceNo].update();
            legends[instanceNo] = true;
            button.innerHTML = 'No Legend';
        }
//        chart.resetZoom();
    });
    container.appendChild(button);
}

/*
// Function to create a button for canvassize
function createToggleFocusChart(convas, chart, instanceNo, oneChemical, scatterData, sheetName, unitTitle, xAxisTitle, yAxisTitle,largeInstanceNo) {
console.log(instanceNo, chemical, scatterData, sheetName, unitTitle, xAxisTitle, yAxisTitle,largeInstanceNo)
    const container = document.getElementById('chartButtons');
    const button = document.createElement('button');
    button.id = 'buttonf'+instanceNo
    if (!largeSize[instanceNo]) {
        button.textContent = unitTitle;
    } else {
        button.textContent = unitTitle;
    }
    button.addEventListener('click', () => {
        displayScatterChart(scatterData, oneChemical, sheetName, largeInstanceNo, unitTitle, xAxisTitle, yAxisTitle, -1);
        chartInstance[largeInstanceNo].update();
//                           (scatterData, oneChemical, sheetName, instanceNo, unitTitle, xAxisTitle, yAxisTitle, largeInstanceNo)   

    });
    container.appendChild(button);
}*/

// Function to create a button for canvassize
function createToggleCanvasSize(canvas, chart,instanceNo,chemical) {
    const container = document.getElementById('chartContainer');
    const button = document.createElement('button');
    button.id = 'buttonc'+instanceNo
    if (!largeSize[instanceNo]) {
        button.textContent = chemical;
    } else {
        button.textContent = chemical;
    }
    button.addEventListener('click', () => {
        if (largeSize[instanceNo]) {
            canvas.width = 1200;
            canvas.height = 800;
            largeSize[instanceNo] = false;
//            button.innerHTML = 'Y Log';
        } else {
              canvas.width = 400;
              canvas.height = 250;
              largeSize[instanceNo] = true;
//              button.innerHTML = 'Y Lin';
        }
        chartInstance[instanceNo].update();
    });
    container.appendChild(button);
}
    
// Function to create a button for toggling log scale
function createToggleLinLogButton(chart,instanceNo, container) {
    if (!container) {
        container = document.getElementById('chartContainer');
    }
    const button = document.createElement('button');
    button.id = 'buttono'+instanceNo
    if (!ylinlog[instanceNo]) {
        button.textContent = 'Y Log';
    } else {
        button.textContent = 'Y Lin';
    }
    button.addEventListener('click', () => {
        if (ylinlog[instanceNo]) {
            chartInstance[instanceNo].options.scales.y.type = 'linear';
            chartInstance[instanceNo].update();
            ylinlog[instanceNo] = false;
            button.innerHTML = 'Y Log';
        } else {
            chartInstance[instanceNo].options.scales.y.type = 'logarithmic';
            chartInstance[instanceNo].update();
            ylinlog[instanceNo] = true;
            button.innerHTML = 'Y Lin';
        }
    });
    container.appendChild(button);
}
    
// Function to create a button for toggling legend
function createStackedButton(chart,instanceNo, container) {
    if (!container) {
        container = document.getElementById('chartContainer');
    }
    const button = document.createElement('button');
    button.id = 'buttons'+instanceNo
    if (!stacked[instanceNo]) {
        button.textContent = 'Stack';
    } else {
        button.textContent = 'Unstack';
    }
    button.addEventListener('click', () => {
        if (stacked[instanceNo]) {
            chartInstance[instanceNo].options.scales.x.stacked = false;
            chartInstance[instanceNo].options.scales.y.stacked = false;
            chartInstance[instanceNo].update();
            stacked[instanceNo] = false;
            button.innerHTML = 'Stack';
        } else {
            chartInstance[instanceNo].options.scales.x.stacked = true;
            chartInstance[instanceNo].options.scales.y.stacked = true;
            chartInstance[instanceNo].update();
            stacked[instanceNo] = true;
            button.innerHTML = 'Unstack';
        }
//        chart.resetZoom();
    });
    container.appendChild(button);
}
    
function clearCanvasAndChart(canvas, chartInstanceNo) {
    if (canvas) {
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        if (chartInstance[chartInstanceNo]) {
            chartInstance[chartInstanceNo].destroy();
            chartInstance[chartInstanceNo] = null;
        }
        /*            // Hide the canvas
                   const convas = document.getElementById("chart" + chartInstanceNo);
                convas.style.display = "none";*/
        // Remove the canvas
        const convas = document.getElementById("chart" + chartInstanceNo);
        convas.remove();
        // Remove all the buttons if created
        removeButtons(chartInstanceNo);
    }
}

function removeButtons(chartInstanceNo) {
//console.log(lastInstanceNo);
//console.log(chartInstanceNo);
    removeButton(chartInstanceNo, 'z');
    removeButton(chartInstanceNo, 'l');
    removeButton(chartInstanceNo, 'o');
    removeButton(chartInstanceNo, 's');
    removeButton(chartInstanceNo, 'c');    
    removeButton(chartInstanceNo, 'e');    
    removeButton(chartInstanceNo, 'g');
    removeButton(chartInstanceNo, 'r');
    removeButton(chartInstanceNo, 'epa');    
    removeButton(chartInstanceNo, 'lmw');    
    removeButton(chartInstanceNo, 'hmw');    
    removeButton(chartInstanceNo, 'smallpts');    
    removeButton(chartInstanceNo, 'organicc');    
}

function removeButton(chartInstanceNo, buttonType) {
        // Remove a reset button if created
        const buttonToRemove = document.getElementById('button' + buttonType + chartInstanceNo);
        // Check if the button exists
        if (buttonToRemove) {
            // Remove the button
            buttonToRemove.remove();
//        } else {
//            console.log('Button ' + buttonType + ' not found', chartInstanceNo);
        }
}

/*function wrongchemicalTypeHasData(sheetName) {
    chemicalTypeData = false;
    for (const ds in selectedSampleMeasurements) {
//console.log(ds);
//console.log(ds, sheetName);
        const chemicalTypes = Object.keys(selectedSampleMeasurements[ds]);
//console.log(ds, sheetName, chemicalTypes);
        if (chemicalTypes.includes(sheetName)) {
            chemicalTypeData = true;
            return chemicalTypeData;
        }
    }
    return chemicalTypeData;
}*/

//Everything has to have chemicalType data
/*function chemicalTypeHasData(sheetName) {
    chemicalTypeData = true;
    for (const ds in selectedSampleMeasurements) {
//console.log(ds);
//console.log(ds, sheetName);
        const chemicalTypes = Object.keys(selectedSampleMeasurements[ds]);
//console.log(ds, sheetName, chemicalTypes);
        if (!(chemicalTypes.includes(sheetName))) {
            chemicalTypeData = false;
//console.log('No data for ', sheetName);
            return chemicalTypeData;
        }
    }
    return chemicalTypeData;
}*/

//One or more datasets have to have chemicalType data
function chemicalTypeHasData(sheetName) {
    chemicalTypeData = false;
    for (const ds in selectedSampleMeasurements) {
//console.log(ds);
//console.log(ds, sheetName);
        const chemicalTypes = Object.keys(selectedSampleMeasurements[ds]);
//console.log(ds, sheetName, chemicalTypes);
        if (chemicalTypes.includes(sheetName)) {
            chemicalTypeData = true;
//console.log('No data for ', sheetName);
            return chemicalTypeData;
        }
    }
    return chemicalTypeData;
}

function filenameDisplay() {
    const fileDisplayDiv = document.getElementById("fileDisplay");
    // Blank it each time
    fileDisplayDiv.innerHTML = "";

    const datesSampled = Object.keys(selectedSampleInfo);
    if (datesSampled.length > 1) {
        datesSampled.sort((a, b) => {
            const labelA = selectedSampleInfo[a].label || a;
            const labelB = selectedSampleInfo[b].label || b;
            return labelA.localeCompare(labelB);
        });
    }

    datesSampled.forEach(dateSampled => {
        // Get the corresponding color for the dataset
        const currentColor = (typeof dateColors !== 'undefined' && dateColors[dateSampled]) ? dateColors[dateSampled] : '#000000';

        const fileURL = sampleInfo[dateSampled].fileURL;

        // --- CHANGE START ---
        // Create a span element for the colored dot instead of an image
        const iconElement = document.createElement("span");
        iconElement.style.height = "15px";
        iconElement.style.width = "15px";
        iconElement.style.backgroundColor = currentColor;
        iconElement.style.borderRadius = "50%"; // This makes the span a circle
        iconElement.style.display = "inline-block";
        iconElement.style.verticalAlign = "middle";
        iconElement.style.marginRight = "8px";
        iconElement.style.border = "1px solid #555"; // Optional: adds a subtle outline
        // --- CHANGE END ---

        // Create a link element for each file and append it to the div
        const linkElement = document.createElement("a");
        linkElement.href = fileURL;
        
        let infos = '';
        for (dataType in selectedSampleMeasurements[dateSampled]) {
            if (dataType === 'Physical Data') {
                infos += `${dataSheetAbr[dataType]} `;
            } else {
                let allChemicals = Object.keys(selectedSampleMeasurements[dateSampled][dataType].chemicals);
                infos += `${Object.keys(selectedSampleMeasurements[dateSampled][dataType].chemicals[allChemicals[0]].samples).length}[${allChemicals.length}x${dataSheetAbr[dataType]}s] `;
            }
        }
        
        const positions = Object.keys(selectedSampleInfo[dateSampled].position);
        const textElement1 = document.createTextNode(`${dateSampled} has ${positions.length} samples with ${infos}:`);
        const textElement2 = document.createTextNode(`File `);
        linkElement.textContent = `${fileURL}`;
        linkElement.target = "_blank"; // Open link in a new tab/window

        // Append the icon before the link
        fileDisplayDiv.appendChild(iconElement);
        fileDisplayDiv.appendChild(textElement1);
        fileDisplayDiv.appendChild(document.createElement("br"));
        fileDisplayDiv.appendChild(textElement2);
        fileDisplayDiv.appendChild(linkElement);

        // Add a line break for better readability
        fileDisplayDiv.appendChild(document.createElement("br"));
    });
    fileDisplayDiv.style.display = 'none';
}

function toggleFileDisplay() {
    const fileDisplayDiv = document.getElementById("fileDisplay");
    if (fileDisplayDiv.style.display === 'block') {
        fileDisplayDiv.style.display = 'none';
    } else {
        fileDisplayDiv.style.display = 'block';
    }
}

    function toggleMapPosition() {
        const fixMapCheckbox = document.getElementById('fixMap');
        const outputArea = document.querySelector('.output-area');
        const mapContainer = document.getElementById('everything-maps');
        const chartsAndTablesContainer = document.getElementById('charts-and-tables-container');

        if (fixMapCheckbox.checked) {
            outputArea.style.overflowY = 'auto';
            mapContainer.classList.add('fixed-map-container');
            if (chartsAndTablesContainer) {
                chartsAndTablesContainer.classList.add('scrollable-charts-container');
            }
        } else {
            outputArea.style.overflowY = 'hidden';
            mapContainer.classList.remove('fixed-map-container');
            if (chartsAndTablesContainer) {
                chartsAndTablesContainer.classList.remove('scrollable-charts-container');
            }
        }
    }