module.exports = function(RED) {

  function PresenceDetectorNode(config) {

    RED.nodes.createNode(this, config);

    var node = this;

    // Configuration

    node.motionTimeout = Number(config.motionTimeout) || 30000; // ms

    node.delayBetween = Number(config.delayBetween) || 3000; // ms between payload #1 and #2

    node.payload1Text = (config.payload1Text || "").trim();

    node.payload2Text = (config.payload2Text || "").trim();

    node.treatMissingDoorAsOpen = config.treatMissingDoorAsOpen === "true" || config.treatMissingDoorAsOpen === true;

    node.resetOnMotion = config.resetOnMotion === "true" || config.resetOnMotion === true;

    node.resetOnDoorOpen = config.resetOnDoorOpen === "true" || config.resetOnDoorOpen === true;

    // Internal state

    node.presence = false;

    node.doorOpen = node.treatMissingDoorAsOpen; // default initial

    node.lastMotion = false;

    node.timer = null;

    node.timerType = null; // "door" or "motion"

    function parsePayloadText(text) {

      if (!text) return null;

      try {

        return JSON.parse(text);

      } catch (e) {

        return text;

      }

    }

    node.payload1 = parsePayloadText(node.payload1Text);

    node.payload2 = parsePayloadText(node.payload2Text);

    // Helper: format milliseconds to HH:MM:SS

    function formatMs(ms) {

      ms = Math.max(0, Math.floor(ms/1000));

      var hrs = Math.floor(ms / 3600);

      var mins = Math.floor((ms % 3600) / 60);

      var secs = ms % 60;

      return [hrs, mins, secs].map(function(n){ return String(n).padStart(2, '0'); }).join(':');

    }

    function sendPresence(p) {

      if (node.presence === p) return; // only send on change

      node.presence = p;

      node.status({fill: p ? "green" : "grey", shape: "dot", text: p ? "present" : "absent"});

      var out = {payload: {presenceDetected: p}};

      node.send([out, null]);

    }

    function sendControl(payload) {

      node.send([null, {payload: payload}]);

    }

    function clearTimer() {

      if (node.timer) {

        clearTimeout(node.timer);

        node.timer = null;

      }

      if (node.updateInterval) {

        clearInterval(node.updateInterval);

        node.updateInterval = null;

      }

      node.timerType = null;

      node.timerEnd = null;

      node._lastStatusUpdate = null;

      node.status({fill: node.presence ? "green" : "grey", shape: "dot", text: node.presence ? "present" : "idle"});

    }

    function startTimer(type, timeoutMs) {

      clearTimer();

      node.timerType = type;

      node.timerEnd = Date.now() + timeoutMs;

      node._lastStatusUpdate = 0;

      function statusUpdater() {

        var now = Date.now();

        var remaining = Math.max(0, node.timerEnd - now);

        // update every 10s when remaining > 10s, otherwise every second

        var shouldUpdate = false;

        if (remaining <= 10000) {

          shouldUpdate = true;

        } else {

          if (!node._lastStatusUpdate || (now - node._lastStatusUpdate) >= 10000) shouldUpdate = true;

        }

        if (shouldUpdate) {

          node._lastStatusUpdate = now;

          node.status({fill: "yellow", shape: "ring", text: `waiting (${type}) ${formatMs(remaining)}`});

        }

      }

      // initial status

      statusUpdater();

      node.updateInterval = setInterval(statusUpdater, 1000);

      node.timer = setTimeout(function() {

        // clear interval and timers

        if (node.updateInterval) { clearInterval(node.updateInterval); node.updateInterval = null; }

        node.timer = null;

        node.timerType = null;

        node.timerEnd = null;

        node._lastStatusUpdate = null;

        // timeout fires -> absence

        sendPresence(false);

        // control payload sequence

        if (node.payload1 !== null) sendControl(node.payload1);

        if (node.payload2 !== null) {

          setTimeout(function() {

            sendControl(node.payload2);

          }, node.delayBetween);

        }

      }, timeoutMs);

    }

    function handleMotion(val) {

      var motion = (val === true || val === 1 || String(val) === "1" || String(val).toLowerCase() === "true");

      node.lastMotion = motion;

      if (motion) {

        // someone detected

        sendPresence(true);

        if (node.payload2 !== null) sendControl(node.payload2);

        if (node.resetOnMotion) clearTimer();

      } else {

        // no motion -> only start timer if door is open (or no door sensor)

        if (node.doorOpen) {

          // If the door is open and motion stops, start motion timeout

          startTimer("motion", node.motionTimeout);

        } else {

          // door closed — keep presence as-is until door opens

          node.status({fill: node.presence ? "green" : "grey", shape: "dot", text: node.presence ? "present (door closed)" : "idle"});

        }

      }

    }

    function handleDoor(val) {

      var open = null;

      if (typeof val === 'string') {

        var v = val.toLowerCase();

        if (v === 'open' || v === '1' || v === 'true') open = true;

        if (v === 'closed' || v === '0' || v === 'false') open = false;

      } else if (typeof val === 'number') {

        open = (val === 1);

      } else if (typeof val === 'boolean') {

        open = val;

      } else if (val && typeof val === 'object') {

        if ('ContactSensorState' in val) {

          open = (val.ContactSensorState === 1);

        } else if ('doorOpen' in val) {

          open = !!val.doorOpen;

        }

      }

      if (open === null) return; // unknown message

      node.doorOpen = open;

      if (open) {

        // door opened -> start deducing occupancy

        if (node.resetOnDoorOpen) clearTimer();

        if (node.lastMotion) {

          // motion present now -> confirm presence

          sendPresence(true);

          if (node.payload2 !== null) sendControl(node.payload2);

        } else {

          // no motion now -> start motion timeout to decide absence

          startTimer("motion", node.motionTimeout);

        }

      } else {

        // door closed -> stop any running timeout and keep current presence until door opens

        clearTimer();

        // presence remains as-is

      }

    }

    node.on('input', function(msg) {

      try {

        // Only accept explicit object payloads with fields: motionDetected, doorOpen, presenceDetected

        if (!msg.payload || typeof msg.payload !== 'object') return;

        var p = msg.payload;

        // Explicit presence override

        if ('presenceDetected' in p) {

          var pres = !!p.presenceDetected;

          sendPresence(pres);

          if (pres && node.payload2 !== null) sendControl(node.payload2);

          return;

        }

        var didSomething = false;

        if ('motionDetected' in p) { handleMotion(p.motionDetected); didSomething = true; }

        if ('motionDtected' in p) { handleMotion(p.motionDtected); didSomething = true; }

        if ('doorOpen' in p) { handleDoor(p.doorOpen); didSomething = true; }

        if ('ContactSensorState' in p) { handleDoor(p); didSomething = true; }

        // ignore other payloads

      } catch (err) {

        node.error(err.message);

      }

    });

    node.on('close', function() {

      clearTimer();

    });

    // initialize status

    node.status({fill: node.presence ? "green" : "grey", shape: "dot", text: node.presence ? "present" : "idle"});

  }

  RED.nodes.registerType("presence-detector", PresenceDetectorNode);

};