/**************** CONFIGURATION ****************/
let CONFIG = {
  timeoutMinutes: 2,          // Time without signal before triggering action(MUST BE HIGHER THAN INTERVAL FROM SENDER SCRIPT))
  actionIfTimeout: "on",      // "on" or "off" when no signal (What should relay do)
  relayID: 0,                 // Relay output ID
  virtualComponentID: 200,    // Shared ID for Text + Boolean
  debug: true                 // Enable advanced debug logging (LoRa Event Summary)
};
/************************************************/

const aesKey = 'MTIzNDU2Nzg5MGFiY2RlZg==';  // AES-128 key in base64
const CHECKSUM_SIZE = 4;

let totalPacketsReceived = 0;
let correctPacketFormatCount = 0;
let incorrectPacketFormatCount = 0;
let errorPercentage = 0;

let lastReceivedTime = Date.now();  // Start counting immediately
let relayState = null;

// --- Pad helper for Shelly ---
function zeroPad(value, length) {
  let str = String(value);
  while (str.length < length) str = "0" + str;
  return str;
}

// --- Advanced LoRa Event Summary ---
function logLoRaEventSummary(event, message) {
  let info = (event && event.info) ? event.info : {};
  totalPacketsReceived++;
  let isValid = (typeof message === 'string') &&
                message.indexOf(",") !== -1 &&
                message.split(",").length === 2;
  if (isValid) {
    correctPacketFormatCount++;
  } else {
    incorrectPacketFormatCount++;
  }
  errorPercentage = (incorrectPacketFormatCount / totalPacketsReceived) * 100;
  let summary = {
    time: new Date().toISOString(),
    signal_rssi: info.rssi,
    signal_snr: info.snr,
    base64_data: info.data,
    total_received: totalPacketsReceived,
    correct: correctPacketFormatCount,
    incorrect: incorrectPacketFormatCount,
    error_percent: errorPercentage.toFixed(2) + "%"
  };
  if (typeof info.packets_lost !== 'undefined') {
    summary.packets_lost = info.packets_lost;
  }
  console.log("LoRa Event Summary:", JSON.stringify(summary));
}

// --- Utilities ---
function base64ToBytes(b64) {
  const bin = atob(b64);
  const bytes = new Uint8Array(bin.length);
  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
  return bytes;
}

function generateChecksum(msg) {
  let checksum = 0;
  for (let i = 0; i < msg.length; i++) checksum ^= msg.charCodeAt(i);
  let hexChecksum = checksum.toString(16);
  while (hexChecksum.length < CHECKSUM_SIZE) hexChecksum = '0' + hexChecksum;
  return hexChecksum.slice(-CHECKSUM_SIZE);
}

function verifyMessage(message) {
  if (message.length < CHECKSUM_SIZE + 1) return;
  const receivedCheckSum = message.slice(0, CHECKSUM_SIZE);
  const _message = message.slice(CHECKSUM_SIZE);
  if (generateChecksum(_message) !== receivedCheckSum) return;
  return _message;
}

function decryptMessage(buffer, keyBase64) {
  if (typeof AES === 'undefined') return;

  const key = base64ToBytes(keyBase64);
  const decrypted = AES.decrypt(buffer, key, { mode: 'ECB' });

  if (!decrypted || decrypted.byteLength === 0) return;

  let hex = "";
  for (let i = 0; i < decrypted.length; i++) {
    hex += ("0" + decrypted[i].toString(16)).slice(-2);
  }

  let fullMessage = "";
  for (let i = 0; i < hex.length; i += 2) {
    fullMessage += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
  }

  return verifyMessage(fullMessage.trim());
}

// --- Set relay + virtual components ---
function updateOutput(active) {
  if (relayState === active) return;  // No change
  relayState = active;

  let text = active ? "on" : "off";
  let bool = active ? true : false;

  Shelly.call("Switch.Set", { id: CONFIG.relayID, on: active });
  Shelly.call("Text.Set", { id: CONFIG.virtualComponentID, value: text });
  Shelly.call("Boolean.Set", { id: CONFIG.virtualComponentID, value: bool });

  let now = new Date();
  let timeStr = zeroPad(now.getHours(), 2) + ":" + zeroPad(now.getMinutes(), 2) + ":" + zeroPad(now.getSeconds(), 2);
  print(timeStr + " - Relay changed to:", text);
}

// --- Check for timeout every 5 sec ---
Timer.set(5 * 1000, true, function () {
  let now = Date.now();
  let elapsedMin = (now - lastReceivedTime) / 60000;

  let elapsedMs = now - lastReceivedTime;
  let totalSeconds = Math.floor(elapsedMs / 1000);
  let hours = Math.floor(totalSeconds / 3600);
  let minutes = Math.floor((totalSeconds % 3600) / 60);
  let seconds = totalSeconds % 60;

  let timeStr =
    zeroPad(hours, 2) + ":" +
    zeroPad(minutes, 2) + ":" +
    zeroPad(seconds, 2);

  print("Time since last signal:", timeStr);

  if (elapsedMin >= CONFIG.timeoutMinutes && relayState !== (CONFIG.actionIfTimeout === "on")) {
    print("No signal for " + CONFIG.timeoutMinutes + " min → Relay set to:", CONFIG.actionIfTimeout);
    updateOutput(CONFIG.actionIfTimeout === "on");
  }
});

// --- Handle LoRa messages ---
Shelly.addEventHandler(function (event) {
  if (!event || event.name !== 'lora' || event.id !== 100 || !event.info || !event.info.data) return;

  const encryptedMsg = atob(event.info.data);
  const decryptedMessage = decryptMessage(encryptedMsg, aesKey);
  if (!decryptedMessage) return;

  lastReceivedTime = Date.now();  // Reset timer
  print("Signal received → LoRa message:", decryptedMessage);

  // Restore opposite of timeout action
  updateOutput(CONFIG.actionIfTimeout !== "on");

  if (CONFIG.debug) {
    Timer.set(100, false, function () {
      logLoRaEventSummary(event, decryptedMessage);
    });
  }
});

// --- Initial relay state (opposite of timeout action) ---
updateOutput(CONFIG.actionIfTimeout !== "on");