<!--
// IDQP2026
// Idaho QSO Party Log Checker
// Written by Jim Larson - KK7A
//
// ================= 2026 ==================================================================================
//
// 2026-02-10	Putting a "." on blank lines of the report so Kelly can see lines to skip.
// 2026-02-09	Added check to see if signal reports are in QSO record and ignore them if found.
//				Initialize Target Station array at start of each log showing none worked.
//				Initialize Bonus County array at start of each log showing none worked.
//
// 2026-01-13	Added checkbox to turn off/on QSO Date checking.
//
// 2026-01-12	Added QSO date validation.
//				*** Considering a checkbox to turn off date checking
//
// 2026-01-09	Re-added the functionality to write the soapbox record to a separate file.
//				The only thing that should be left is validation of the QSO dates.  Thinking I might add
//				a checkbox to flip the date check from UTC to local time, but would have to take into
//				account the 2 time zones for Idaho stations.  I may wait and see if any come in with local
//				entries.
//
// 2026-01-01 - Updated SPUD stations to be 5 points each.
//              Updated Bonus Counties list to reflect new entries for 2026.
//              *** still need to add functionality for Soapbox entries ***
//
// 2025-11-24 - Converted to from C# to Javascript so it can be accessable from a web browser with no 
//              need for any installation of sofware.
//
// ================= 2025 ==================================================================================
//
// 2025-03-01   Working on 2025 version
//              Changed the dates for the contest to 2025-03-08 through 2025-03-09
//              Fixed issue where there would be an exception thrown if the bonus_counties.txt file
//                  contained a blank entry.
//
// ================= 2024 ==================================================================================
//
// 2024-01-15   Working on 2024 version
//              Added code to handle different bonus point amounts given to the activated counties.
//
// ================= 2023 ==================================================================================
//
// 2023-01-19:  Working on 2023 version
//              /debug commandline switch is working as desired.
//              All QRP QSOs are 5 points regardless of mode.
//              On the OPERATORS line, print the entire line, not just the first field.
// 2023-01-23:  Added code for working "target stations."
// 2023-01-30:  Added code for activating from "bonus county" list.
// 2023-02-13:  Added logic to keep track of all counties activated.  Displays a "Counties Activated" line on the report.
// 2023-03-18:  Added check to see if Idaho log contains a county of "DX" which will need to be converted to a country code.
//
// Changes from K7SU that need to be done prior to 2023 event:
//  DONE * All QRP QSOs are 5 points regardless of mode.
//
//  * Any station working the "target stations" will get 100 pts. per station but if they work all 3 they get an extra 100 bonus points.
//      * Create a file external to the program to give the ability to change target stations with no changes to the software needed.
//      * Add code to check for QSOs with the target list and score appropriately.
//          * 100 points (per target station) for 1 or more QSOs with a station on the list.
//          * 100 extra points awarded if all target stations in the list are worked.
//  * Expedition (Rover) stations(from previously non-activated counties) working 11 or more QSO's from that county will get
//    500 bonus points for that county.
//      * Create a file external to the program to give the ability to change the “non-activated” county list with no changes to the
//        software needed.
//      * For each source county in the log that matches an entry in the list, count up QSOs for that county.
//          * If 11 or more QSOs, then add 500 points to the score.
//          * If 10 or less, then no bonus points.
//  * List all the counties that each rover activated
//
// ================= 2022 ==================================================================================
// 2022-01-24: Initial version working with same functionality as the Powershell Script.
//
// Look for LOCATION: ID and if found, consider this an in-state log, otherwise it is an out-of-state log
// *** New feature to add: command line parameter to force it to be in-state or out-of-state
//
// for in-state QSOs, county abbreviations are converted to "ID"
//                    State abbreviations and countries entered are not checked, so trusting that logging was correct.
//                    *** This should be addressed at sometime, adding State and Country list for validation.
//
// Added EMAIL: field
// 2022-02-15:  Received output from the idqp.contesting.com site which has the signal reports removed.  Adjusted fields to 
//              compensate for that.  Also changed the LOCATION/ARRL-SECTION header on the output to be just LOCATION.
// 2022-02-18:  Added soapbox processing.
//              Created functions to allow both write to console and write to file for output.
//              Set up constants to point to input and output folders.
//              Looks for "\" in path.  If found, it uses the path specifid.  If not, then it points to PATH_TO_LOGS.
// 2022-02-28:  Added the following checks to validate the log prior to writing the output callsign.txt file:
//              - 0 QSOs in the log
//              - Total QSO records do not match the total number of QSO (CW+PH+DG).
//              - No callsign found in either the CALLSIGN header or the callsign field in the QSO record
//              - QSO date / time is out of contest period
//              - QSO record has issues
//              Beeps if any error is found, otherwise, creates the output log if success.
// 2022-03-01:  Added a directory parser to read through the log directory, passing off the name of the file to process
//              to Filestuff.ReadLogFile()
// 2022-03-04:  Added DEBUG code - If DEBUG set to FALSE, just prints out a single line for each log processed
//              Only processes files that end in ".LOG" - converts to upper case before checking
// 2022-03-12:  Added logic to look for mode category and only count QSOs if the mode matches the entry category.
//              This is for those who work more than 1 mode, but are entering as a single mode.  That way their
//              logs can be used as checklogs for the other modes.
// 2022-03-13:  Added users own county to dupe check to handle rovers.  Otherwise, QSOs were showing up as dupes.
//              Fixed a duplicate QSO error which caused log to be a failed log instead of just a bad QSO record.
//              Added new "County" field to the results.
// 2022-12-29:  Verifying that I can push to GitHub.
//
// =========================================================================================================
-->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Idaho QSO Party - Log Analysis</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      margin: 30px;
      background-color: #f0f0f0;
    }
    textarea {
      width: 100%;
      height: 150px;
      margin-bottom: 10px;
      font-family: monospace;
    }
    input[type="file"] {
      margin-bottom: 10px;
    }
    button {
      padding: 10px 20px;
      font-size: 16px;
      margin-bottom: 10px;
    }
    #output {
      margin-top: 20px;
      background: white;
      padding: 15px;
      border-radius: 8px;
      box-shadow: 0 0 5px rgba(0,0,0,0.1);
      white-space: pre-wrap;
      font-family: monospace;
    }
    #debug_output {
      margin-top: 20px;
      background: white;
      padding: 15px;
      border-radius: 8px;
      box-shadow: 0 0 5px rgba(0,0,0,0.1);
      white-space: pre-wrap;
      font-family: monospace;
    }
  </style>
</head>
<body>

<h2>Idaho QSO Party - Log Analysis</h2>
<h3>Version 2026-02-10 written by KK7A</h3>

<p>You can either paste the contents of a Cabrillo log file below or select a log file to read:</p>

<textarea id="pasteText" placeholder="Paste contents of log file here..."></textarea>
<br>
<input type="file" id="fileInput" accept=".log">
<br>
<label>
	<input type="checkbox" id="ValidateQSODateCheckbox" checked>
	Check QSO Dates
</label>
<br>
<br>
<button onclick="processInput()">Process</button>
<button onclick="saveFiles()">Download Results</button>


<p><br>Results:</p>
<div id="output"></div>

<p><br>Below is the debug area that will display issues found in a Cabrillo log file:</p>
<div id="debug_output"></div>


<script>
	// ===================================================================
	// The following dates will need to be changed every year
	// ===================================================================

	// Load BONUS counties array - this will change every year
	// Array consists of name, bool for activated or not, and the point value for the BONUS county
	let arrayBonusCounties = [];
	arrayBonusCounties.push(["BLA", false, 500]);
	arrayBonusCounties.push(["BUT", false, 500]);
	arrayBonusCounties.push(["CAM", false, 500]);
	arrayBonusCounties.push(["CLA", false, 500]);
	arrayBonusCounties.push(["CLE", false, 500]);
	arrayBonusCounties.push(["CUS", false, 500]);
	arrayBonusCounties.push(["FRA", false, 500]);
	arrayBonusCounties.push(["JEF", false, 500]);
	arrayBonusCounties.push(["LEM", false, 500]);
	arrayBonusCounties.push(["LIN", false, 1000]);
	arrayBonusCounties.push(["VAL", false, 500]);

	// Load TargetSstations array
	// Array consists of callsign and bool for worked or not, and the point value for the Target Station
	let arrayTargetStations = [];
	arrayTargetStations.push(["K7S", false, 5]);
	arrayTargetStations.push(["K7P", false, 5]);
	arrayTargetStations.push(["K7U", false, 5]);
	arrayTargetStations.push(["K7D", false, 5]);

	// Time block 1 - start and end
	const rangeStartStr1 = "2026-03-14 1600";		// These dates will need be changed every year
	const rangeEndStr1   = "2026-03-15 0359";		// These dates will need be changed every year

	// Time block 2 - start and end
	const rangeStartStr2 = "2026-03-15 1400";		// These dates will need be changed every year
	const rangeEndStr2   = "2026-03-16 0159";		// These dates will need be changed every year

	// ===================================================================
	// End of yearly changes
	// ===================================================================


	// Convert start and end date/times to a value to use in checking of QSO date.
	const startDate1 = parseDateTime(rangeStartStr1);
	const endDate1   = parseDateTime(rangeEndStr1);
	const startDate2 = parseDateTime(rangeStartStr2);
	const endDate2   = parseDateTime(rangeEndStr2);
	let QSODateCheckResult = false;		// set to false as the default
	let QSODateTime = "";				// this variable will be used for the QSO date.

	let processedOutput = ""; 		// store the output for download
	let strOutputCallsign = "";		// Used to pass the callsign to the saveFiles function
	let strSoapbox = "";			// Used to pass the soapbox record to the saveFiles function

	let boolCheckQSODate = true;
	const checkbox = document.getElementById("ValidateQSODateCheckbox");

	// Update boolean variable when QSODateCheck checkbox changes
	checkbox.addEventListener("change", function () {
		boolCheckQSODate = checkbox.checked;
	});

    function processInput() {
        const fileInput = document.getElementById("fileInput");
        const pasteText = document.getElementById("pasteText").value.trim();

        if (fileInput.files.length > 0) {
            // Process file
            const file = fileInput.files[0];
            const reader = new FileReader();
            reader.onload = function(event) {
                processText(event.target.result, file.name);
            };
            reader.readAsText(file);
        } else if (pasteText) {
            // Process pasted text
            processText(pasteText, "Pasted Text");
        } else {
            alert("Please paste text or select a file to process.");
        }
    }

	// ===================================================
	// process all the records in the Cabrilo file
	// ===================================================
    function processText(text, sourceName) {
		processedOutput = "";		// set global variable back to blank at start of a file
		strOutputCallsign = "";
		strSoapbox = "";


        const upperText = text.toUpperCase();       // convert to upper case
        const lines = upperText.split(/\r?\n/);     // split by field


		// Set valid modes for QSO records
		const modes = ["CW", "PH", "DG", "RY"];

		// Load counties array
		let arrayCounties = [];
		arrayCounties.push(["ADA", false]);
		arrayCounties.push(["ADM", false]);
		arrayCounties.push(["BAN", false]);
		arrayCounties.push(["BEA", false]);
		arrayCounties.push(["BEN", false]);
		arrayCounties.push(["BIN", false]);
		arrayCounties.push(["BLA", false]);
		arrayCounties.push(["BNR", false]);
		arrayCounties.push(["BNV", false]);
		arrayCounties.push(["BOI", false]);
		arrayCounties.push(["BOU", false]);
		arrayCounties.push(["BUT", false]);
		arrayCounties.push(["CAM", false]);
		arrayCounties.push(["CAN", false]);
		arrayCounties.push(["CAR", false]);
		arrayCounties.push(["CAS", false]);
		arrayCounties.push(["CLA", false]);
		arrayCounties.push(["CLE", false]);
		arrayCounties.push(["CUS", false]);
		arrayCounties.push(["ELM", false]);
		arrayCounties.push(["FRA", false]);
		arrayCounties.push(["FRE", false]);
		arrayCounties.push(["GEM", false]);
		arrayCounties.push(["GOO", false]);
		arrayCounties.push(["IDA", false]);
		arrayCounties.push(["JEF", false]);
		arrayCounties.push(["JER", false]);
		arrayCounties.push(["KOO", false]);
		arrayCounties.push(["LAT", false]);
		arrayCounties.push(["LEM", false]);
		arrayCounties.push(["LEW", false]);
		arrayCounties.push(["LIN", false]);
		arrayCounties.push(["MAD", false]);
		arrayCounties.push(["MIN", false]);
		arrayCounties.push(["NEZ", false]);
		arrayCounties.push(["ONE", false]);
		arrayCounties.push(["OWY", false]);
		arrayCounties.push(["PAY", false]);
		arrayCounties.push(["POW", false]);
		arrayCounties.push(["SHO", false]);
		arrayCounties.push(["TET", false]);
		arrayCounties.push(["TWI", false]);
		arrayCounties.push(["VAL", false]);
		arrayCounties.push(["WAS", false]);

		// Create array for holding all multipliers found.
		arrayMultiplier = [];

		// Initialize Bonus station array showing nothing as being worked.
       	for (let i = 0; i < arrayTargetStations.length; i++) {
           	arrayTargetStations[i][1] = false;
       	}

		// Initialize Bonus County array showing nothing as being worked.
       	for (let i = 0; i < arrayBonusCounties.length; i++) {
           	arrayBonusCounties[i][1] = false;
       	}


		let intCWCounter = 0;   // used to count the number of CW QSOs
		let intPHCounter = 0;   // used to count the number of Phone QSOs
		let intDGCounter = 0;   // used to count the number of Digital QSOs
		let intDupeCounter = 0; // used to count the number of Duplicate QSOs
		let intFinalScore = 0;
		let intMultiplierTotal = 0;
		let intTotalQSOs = 0;
		let intQSOPoints = 0;
		let intFrequency = 0;
		let intTargetStationPoints = 0;
		let intBonusCountiesActivated = 0;

		let qsoCount = 0;
		let boolIdahoLocation = false;
		let strQSOBand = "";
		let boolValidQSO = true;
		let outputHTML = "Output goes here\n\n";
		let debug_outputHTML = `Source: ${sourceName}\n\n`;
		let strLogCallsign = "";
		let strLogLocation = "";
		let strEmail = "";
		let strCategoryOperator = "";
		let strCategoryStation = "";
		let strCategoryTransmitter = "";
		let strCategoryPower = "";
		let strCategoryAssisted = "";
		let strCategoryBand = "";
		let strCategoryMode = "";
		let strOperators = "";
		let strClaimedScore = "";
		let strDupeCheck = "";
		let strMultiplier = "";
		let strCountiesActivated = "";
		let strTargetStationsWorked = "";
		let strBonusCountiesActivated = "";

	    // Create DupeCheck Array
    	// The record will consist of: my_county + callsign + band + mode + county
		let arrayDupeCheck = [];

		// This is how the QSO records are set up in standard Cabrillo file:
        let strQSOFrequency = "";
        let strQSOMode = "";
        let strQSODate = "";
        let strQSOTime = "";
        let strQSOMyCallsign = "";
        let strQSOMyQTH = "";
        let strQSOTheirCallsign = "";
        let strQSOTheirQTH = "";

        for (let line of lines) {
        	if (!line.trim()) continue;                 // skip empty lines
        	const fields = line.trim().split(/\s+/);
        	const firstField = fields[0];

          	switch (firstField) {
            	case "CALLSIGN:":
            	if (fields.length > 1) {
                	strLogCallsign = fields[1];
					strOutputCallsign = fields[1];		// store in global variable to use in saveFiles function
					for (let i = 0; i <= strOutputCallsign.length; i++) {	//Swap out / for -
						if (strOutputCallsign[i] == "/") {
							strOutputCallsign[i] = "_";
						}
					}
                  	debug_outputHTML += "Header Callsign:      " + strLogCallsign + "\n";
                }
                	break;

              	case "LOCATION:":
              	case "ARRL-SECTION:":
                	if (fields.length > 1) {
             	       debug_outputHTML += `Header Location:      ${fields[1]}\n`;
                	    if (fields[1] === "ID") boolIdahoLocation = true;
						strLogLocation = fields[1];
                	}
               		break;

              	case "EMAIL:":
                	if (fields.length > 1) {
                    	strEmail = fields[1];
                	    debug_outputHTML += "Email address:        " + strEmail + "\n";
                	}
                	break;

              	case "CATEGORY-OPERATOR:":
        	      	if (fields.length > 1) {
            	        strCategoryOperator = fields[1];
                	    debug_outputHTML += "Category Operator:    " + strCategoryOperator + "\n";
                	}
               		break;

              	case "CATEGORY-STATION:":
        	      	if (fields.length > 1) {
            	        strCategoryStation = fields[1];
                	    debug_outputHTML += "Category Station:     " + strCategoryStation + "\n";
                	}
               		break;

              	case "CATEGORY-TRANSMITTER:":
        	      	if (fields.length > 1) {
            	        strCategoryTransmitter = fields[1];
                	    debug_outputHTML += "Category Transmitter: " + strCategoryTransmitter + "\n";
                	}
               		break;

              	case "CATEGORY-POWER:":
        	      	if (fields.length > 1) {
            	        strCategoryPower = fields[1];
                	    debug_outputHTML += "Category Power:       " + strCategoryPower + "\n";
                	}
               		break;

              	case "CATEGORY-ASSISTED:":
        	      	if (fields.length > 1) {
            	        strCategoryAssisted = fields[1];
                	    debug_outputHTML += "Category Assisted:    " + strCategoryAssisted + "\n";
                	}
               		break;

              	case "CATEGORY-BAND:":
        	      	if (fields.length > 1) {
            	        strCategoryBand = fields[1];
                	    debug_outputHTML += "Category Band:        " + strCategoryBand + "\n";
                	}
               		break;

              	case "CATEGORY-MODE:":
        	      	if (fields.length > 1) {
            	        strCategoryMode = fields[1];
                	    debug_outputHTML += "Category Mode:        " + strCategoryMode + "\n";
                	}
               		break;

				case "CLAIMED-SCORE:":
        	      	if (fields.length > 1) {
            	        strClaimedScore = fields[1];
                	    debug_outputHTML += "Claimed Score:        " + strClaimedScore + "\n";
                	}
                	break;

				case "OPERATORS:":
					strOperators = "";
        	      	if (fields.length > 1) {
						for (let i = 1; i < fields.length; i++) {
							strOperators += fields[i] + " ";
						}
                	    debug_outputHTML += "Operators:            " + strOperators + "\n";
                	}
                	break;

				case "SOAPBOX:":
 					strSoapbox += line.substring(9);			// remove the SOAPBOX: header from the string
                	debug_outputHTML += "Soapbox:              " + strSoapbox + "\n";
                	break;


              case "QSO:":
                qsoCount++;
                boolValidQSO = true;
                boolValidCounty = true;
                const strQSOFrequency = fields[1];
                strQSOMode = fields[2];
                strQSODate = fields[3];
                strQSOTime = fields[4];
                strQSOMyCallsign = fields[5];
                strQSOMyQTH = fields[6];
                strQSOTheirCallsign = fields[7];
                strQSOTheirQTH = fields[8];

				// If the Cabrillo file contains signal reports, then remove those reports before processing
				if (strQSOMyQTH.startsWith("59")) {
               		strQSOMyQTH = fields[7];
                	strQSOTheirCallsign = fields[8];
                	strQSOTheirQTH = fields[10];
				}

                // Display the contents of the first QSO record
                if (qsoCount == 1 ) {
                  debug_outputHTML += "\n======= First QSO Record =======\n"
                  debug_outputHTML += "RAW Log entry:   " + line + "\n";
                  debug_outputHTML += "Frequency:       " + strQSOFrequency + "\n";
                  debug_outputHTML += "Mode:            " + strQSOMode + "\n";
                  debug_outputHTML += "QSO Date:        " + strQSODate + "\n";
                  debug_outputHTML += "QSO Time:        " + strQSOTime + "\n";
                  debug_outputHTML += "My Call:         " + strQSOMyCallsign + "\n";
                  debug_outputHTML += "My QTH:          " + strQSOMyQTH + "\n";
                  debug_outputHTML += "Their Call:      " + strQSOTheirCallsign + "\n";
                  debug_outputHTML += "Their QTH:       " + strQSOTheirQTH + "\n";
                  debug_outputHTML += "================================\n\n"
                }

                // Check to see if date is in the correct timeframe
                // code goes here.....

                // Convert strQSOFrequency to strQSOBand

                intFrequency = Number(strQSOFrequency);                    // convert the string from the QSO record to a numeric value
                if ((intFrequency >= 1800) && (intFrequency <= 2000))
                {
                    strQSOBand = "160";
                }
                else if ((intFrequency >= 3500) && (intFrequency <= 4000))
                {
                    strQSOBand = "80";
                }
                else if ((intFrequency >= 7000) && (intFrequency <= 7300))
                {
                    strQSOBand = "40";
                }
                else if ((intFrequency >= 14000) && (intFrequency <= 14350))
                {
                    strQSOBand = "20";
                }
                else if ((intFrequency >= 21000) && (intFrequency <= 21450))
                {
                    strQSOBand = "15";
                }
                else if ((intFrequency >= 28000) && (intFrequency <= 29600))
                {
                    strQSOBand = "10";
                }
                else
                {
                    strQSOBand = "XX";
                    debug_outputHTML += "Bad band - Frequency = " + strQSOFrequency + "\n";
                    boolValidQSO = false;
                }
                //console.log("Frequency = " + strQSOFrequency + " Band = " + strQSOBand + " Valid QSO = " + boolValidQSO);

                // Check to see if mode is valid
                if (modes.includes(strQSOMode) == false) {
                  	debug_outputHTML += "Bad mode = " + strQSOMode + "\n";
                  	boolValidQSO = false;       // not valid, so flag the QSO as bad
                }

				// See if Idaho entrant and if so, flag the County as activated.
				if (boolIdahoLocation == true) {
					for (let i = 0; i< arrayCounties.length; i++) {
						if (arrayCounties[i][0] === strQSOMyQTH) {
							arrayCounties[i][1] = true;		// yes, set the flag as activated from
						}
					}
				}

				// Since Idaho entrants can't count Idaho counties, set strQSOTheirQTH field to ID if any counties are found.
                if (boolIdahoLocation == true) {
                	for (let i = 0; i < arrayCounties.length; i++) {
                    	if (arrayCounties[i][0] === strQSOTheirQTH) {		// if it is a valid Idaho county, then 
                      		strQSOTheirQTH = "ID";							// ... set the QTH to ID
                      		break;
                    	}
                  	}
                } else {  // not an ID entrant - check to see if county is valid
                  boolValidCounty = false;
                  for (let i = 0; i < arrayCounties.length; i++) {
                    if (arrayCounties[i][0] === strQSOTheirQTH) {
                      boolValidCounty = true;
                      break;
                    }
                  }
                  if (boolValidCounty == false) {
                    debug_outputHTML += "Invalid County = " + strQSOTheirQTH + "\n";
                    boolValidQSO = false;       // not valid, so flag the QSO as bad
                  }
                } 

                // If still a good QSO, then check it against the dupe check array
                if (boolValidQSO == true) {
                  strDupeCheck = strQSOMyQTH + strQSOTheirCallsign + strQSOBand + strQSOMode + strQSOTheirQTH;
                  //debug_outputHTML += "Dupe Check: " + strDupeCheck + "\n";
                  if (arrayDupeCheck.includes(strDupeCheck) == true) {
                    debug_outputHTML += "Duplicate QSO = " + strDupeCheck + "\n";
                    intDupeCounter++;
                    boolValidQSO = false;
                  } else {
                    // add new QSO entry to dupe check array
                    arrayDupeCheck.push(strDupeCheck);
                  }
                }

				// If still a good QSO, then validate to see if the QSO date is in the correct range for the year.
				if (boolCheckQSODate == true) {						// only check the date of the checkbox is chedked
					QSODateTime = strQSODate + " " + strQSOTime;
					QSODateCheckResult = checkRange(QSODateTime);	// check the QSO date and time
					if (QSODateCheckResult == false) {
						debug_outputHTML += "BAD QSO Date = " + QSODateTime + "\n";
						boolValidQSO = false;
					}
				}

                // Display the record if it is going to be rejected
                if (boolValidQSO == false ) {
                  	debug_outputHTML += "Log entry: " + `${strQSOFrequency} ${strQSOBand} ${strQSOMode} ${strQSODate} ${strQSOTime} ${strQSOMyCallsign} ${strQSOMyQTH} ${strQSOTheirCallsign} ${strQSOTheirQTH} \n\n`;
				} 

                // ===============================================================================================
                // At this point, all checks have been completed on the QSO record. 
				// Only execute the rest of this section if the QSO is valid.
                // ===============================================================================================

				if (boolValidQSO == true ) {
					// Check to see if this QSO is a new multiplier and if not, add it to the multiplier array
					strMultiplier = strQSOMode + strQSOTheirQTH;
					if (arrayMultiplier.includes(strMultiplier) == false ) {
						arrayMultiplier.push(strMultiplier);	// add the value if it is not already there
					}

					// Count the QSO points by mode
					if (boolValidQSO == true) {
					switch (strQSOMode) {
						case "CW":
							intCWCounter++ ;
							break ;
						case "PH":
							intPHCounter++ ;
							break ;
						case "RY":
						case "DG":
							intDGCounter++ ;
							break ;
						default: 
							debug_outputHTML += "Missing Mode in QSO record - this should never been seen\n";
							break;
						}
					}

					// See if Bonus Station worked - set flag to true if the target station was worked
                	for (let i = 0; i < arrayTargetStations.length; i++) {
                    	if (arrayTargetStations[i][0] === strQSOTheirCallsign) {
                      		arrayTargetStations[i][1] = true;
                    	  	break;
                    	}
                  	}

					// See if Bonus Counties operated from - set flag to true if the county was activated
                	for (let i = 0; i < arrayBonusCounties.length; i++) {
                    	if (arrayBonusCounties[i][0] === strQSOMyQTH) {
                      		arrayBonusCounties[i][1] = true;
                    	  	break;
                    	}
                  	}
				}

                break;  // End of the QSO record switch conditional

              default:
                // ignore other records
                break;
          }
        }

		// ===============================================================================================
        // All records in the Cabrillo file have been read and processed.  Now the scoring can begin.
        // ===============================================================================================

		intMultiplierTotal = arrayMultiplier.length;	// get the total number of mults worked
		intTotalQSOs = qsoCount;						// get the total number of QSOs


        // Calculate QSO points - note that a log may contain entrys for multiple modes, but the operator may just be subbmit for a single mode.
            intQSOPoints = 0;

            // New for 2023:  All QRP log entries are worth 5 points:
            if (strCategoryPower == "QRP") {
                if (strCategoryMode == "MIXED" || strCategoryMode == "CW")
                {
                    intQSOPoints += (intCWCounter * 5);
                }
                if (strCategoryMode == "MIXED" || strCategoryMode == "DIGI")
                {
                    intQSOPoints += (intDGCounter * 5);
                }
                if (strCategoryMode == "MIXED" || strCategoryMode == "SSB")
                {
                    intQSOPoints += (intPHCounter * 5);
                }
            }
            else {
                if (strCategoryMode == "MIXED" || strCategoryMode == "CW")
                {
                    intQSOPoints += (intCWCounter * 2);
                }
                if (strCategoryMode == "MIXED" || strCategoryMode == "DIGI")
                {
                    intQSOPoints += (intDGCounter * 2);
                }
                if (strCategoryMode == "MIXED" || strCategoryMode == "SSB")
                {
                    intQSOPoints += intPHCounter;
                }
            }

            //            qso_points = (cw_counter * 2) + (dg_counter * 2) + ph_counter;
            //            total_qsos = cw_counter + ph_counter + dg_counter;

            intFinalScore = intQSOPoints * intMultiplierTotal;

		// See which bonus stations were worked 
		for (let i = 0; i < arrayTargetStations.length; i++) {
       		if (arrayTargetStations[i][1] === true ) {
       			strTargetStationsWorked += arrayTargetStations[i][0] + " ";
 				if (boolIdahoLocation == false) {								// don't give bonus points to Idaho Stations
					intTargetStationPoints += arrayTargetStations[i][2];		// get point value from array
       			}
			}
		}
		intFinalScore += intTargetStationPoints;	// add the target station bonus points to the final score

		// See which bonus counties were operated from
        for (let i = 0; i < arrayBonusCounties.length; i++) {
           	if (arrayBonusCounties[i][1] === true ) {
           		strBonusCountiesActivated += arrayBonusCounties[i][0] + " ";
				intBonusCountiesActivated += arrayBonusCounties[i][2];			// get point value from array
			}
        }
		intFinalScore += intBonusCountiesActivated;	// add the bonus counties points to the final score

        debug_outputHTML += `\nTotal QSOs: ${intTotalQSOs}\n`;

		// See if Idaho entrant and if so, see how many counties they activated from and add to variable to display
		if (boolIdahoLocation == true) {
			for (let i = 0; i < arrayCounties.length; i++ ) {
				if (arrayCounties[i][1] == true) {
					strCountiesActivated += arrayCounties[i][0] + " ";
				}
			}
		}

		outputHTML = ".\r\n.\r\n------------ HEADER -------------\r\n";
		if (boolIdahoLocation == true) {
			outputHTML += "       >> IDAHO Entry <<\r\n.\r\n.\r\n";
		} else {
			outputHTML += "    >> Out of state entry <<\r\n.\r\n.\r\n";
		}
		outputHTML += "CALLSIGN:" + strLogCallsign + "\r\n";
		outputHTML += "LOCATION:" + strLogLocation + "\r\n";
		outputHTML += "CATEGORY-OPERATOR:" + strCategoryOperator + "\r\n";
		outputHTML += "CATEGORY-STATION:" + strCategoryStation + "\r\n";
		outputHTML += "CATEGORY-TRANSMITTER:" + strCategoryTransmitter + "\r\n";
		outputHTML += "CATEGORY-POWER:" + strCategoryPower + "\r\n";
		outputHTML += "CATEGORY-ASSISTED:" + strCategoryAssisted + "\r\n";
		outputHTML += "CATEGORY-BAND:" + strCategoryBand + "\r\n";
		outputHTML += "CATEGORY-MODE:" + strCategoryMode + "\r\n";
		outputHTML += "CLAIMED-SCORE:" + strClaimedScore + "\r\n";
		outputHTML += "OPERATORS:" + strOperators + "\r\n.\r\n.";
		outputHTML += "\r\n------------ RESULTS ------------\r\n";
		outputHTML += "Callsign:" + strQSOMyCallsign + "\r\n";
		outputHTML += "Email:" + strEmail.toLowerCase() + "\r\n";
		outputHTML += "Duplicate QSOs:" + intDupeCounter + "\r\n";
		outputHTML += "CW QSOs:" + intCWCounter + "\r\n";
		outputHTML += "Phone QSOs:" + intPHCounter + "\r\n";
		outputHTML += "Digital QSOs:" + intDGCounter + "\r\n";
		outputHTML += "Total QSOs:" + intTotalQSOs +"\r\n";
		outputHTML += "Total QSO Points:" + intQSOPoints + "\r\n";
		outputHTML += "Total Mults:" + intMultiplierTotal + "\r\n";
		outputHTML += "Final Score:" + intFinalScore + "\r\n";
		outputHTML += "County:" + strQSOMyQTH + "\r\n";
		outputHTML += "Counties Activated:" + strCountiesActivated + "\r\n";
		outputHTML += "Target Stations Worked:" + strTargetStationsWorked + "\r\n";
		outputHTML += "Target Stations Bonus:" + intTargetStationPoints + "\r\n";
		outputHTML += "Bonus Counties Activated:" + strBonusCountiesActivated + "\r\n";
		outputHTML += "Bonus Counties Bonus:" + intBonusCountiesActivated + "\r\n";
		outputHTML += "---------------------------------" + "\r\n";

        processedOutput = outputHTML; // save for download
        document.getElementById("output").textContent = outputHTML;
        document.getElementById("debug_output").textContent = debug_outputHTML;
    }

	// called from the saveFiles function to do the actual write of the file. 
	// The files are saved in the downloads folder.
	function writeStringToFile(filename, content) {
		const blob = new Blob([content], { type: "text/plain" });
		const link = document.createElement("a");

		link.href = URL.createObjectURL(blob);
		link.download = filename;

		document.body.appendChild(link);
		link.click();

		document.body.removeChild(link);
		URL.revokeObjectURL(link.href);
	}

	// function to save the results file and if there was a soapbox record, the soapbox file will be created.
	function saveFiles() {
		if (!processedOutput) {
			alert("No processed output to download. Please process a file or paste text first.");
		} else {
			writeStringToFile(strOutputCallsign + ".txt", processedOutput);
			
			// if there was a Soapbox record, create a output text file for it.
			if (strSoapbox.length > 0) {
				setTimeout(() => {			// Small delay so browser allows second download
					writeStringToFile(strOutputCallsign + "_soapbox.txt", strSoapbox);
			    }, 300);
			}
		}	
	}

	// =============================================================================
	// THe following functions are used for the date validation of a QSO
	// =============================================================================

	// function to put date and time into the correct format needed for computation
	function parseDateTime(dateTimeStr) {
		// Expected format: YYYY-MM-DD HHMM
		const [datePart, timePart] = dateTimeStr.split(" ");
		const [year, month, day] = datePart.split("-").map(Number);
		const hour = parseInt(timePart.substring(0, 2), 10);
		const minute = parseInt(timePart.substring(2, 4), 10);

		// Month is 0-based in JavaScript Date
		return new Date(year, month - 1, day, hour, minute);
	}

	// function to see if QSO date is in the the tested window
	function isWithinRange(target, start, end) {
		return target >= start && target <= end;
	}

	// function to see if QSO date is both date/time windows
	function checkRange(testDateTime) {
		let result = false;
		let testDate  = parseDateTime(testDateTime);
		let result1 = isWithinRange(testDate, startDate1, endDate1);
		let result2 = isWithinRange(testDate, startDate2, endDate2);
		if (result1 == true || result2 == true) result = true;
		return result;
	}

</script>

</body>
</html>