<!--
// IDQP2026
// Idaho QSO Party Log Checker
// Written by Jim Larson - KK7A
//
// ================= 2026 ==================================================================================
//
// 2025-11-24 - Working on conversion to Javascript so that anyone can adjudicate the logs via a web page.
//
// ================= 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 exceptoin 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 2025-12-31 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>
<button onclick="processInput()">Process</button>
<button onclick="downloadOutput()">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>
	let processedOutput = ""; 		// store the output for download
	let strOutputCallsign = "";		// Used to pass the callsign to the downloadOutput function

    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) {
        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 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(["ADA", false, 500]);
		arrayBonusCounties.push(["TWI", false, 1000]);
		arrayBonusCounties.push(["OWY", false, 1500]);

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


		// 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 = [];

		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 downloadOutput 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 "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];

                // 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);
                  }
                }

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

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


  function downloadOutput() {
    if (!processedOutput) {
      alert("No processed output to download. Please process a file or paste text first.");
      return;
    }

    const blob = new Blob([processedOutput], { type: "text/plain" });
    const url = URL.createObjectURL(blob);
    const a = document.createElement("a");
    a.href = url;
    a.download = strOutputCallsign + ".txt";
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
  }
</script>

</body>
</html>