module.exports = function(RED) {
  function Z2MSNZB04PHomeBusNode(config) {
    RED.nodes.createNode(this, config);
    var node = this;

    node.adapterId = "z2m-snzb-04p";
    node.sourceTopic = "zigbee2mqtt/SNZB-04P/#";
    node.subscriptionStarted = false;
    node.startTimer = null;
    node.site = normalizeToken(config.site || config.mqttSite);
    node.legacyRoom = normalizeToken(config.mqttRoom);
    node.legacySensor = normalizeToken(config.mqttSensor);
    node.publishCache = Object.create(null);
    node.retainedCache = Object.create(null);
    node.seenOptionalCapabilities = Object.create(null);
    node.detectedDevices = Object.create(null);
    node.stats = {
      processed_inputs: 0,
      devices_detected: 0,
      home_messages: 0,
      last_messages: 0,
      meta_messages: 0,
      home_availability_messages: 0,
      operational_messages: 0,
      invalid_messages: 0,
      invalid_topics: 0,
      invalid_payloads: 0,
      unmapped_messages: 0,
      adapter_exceptions: 0,
      errors: 0,
      dlq: 0
    };
    node.statsPublishEvery = 25;
    node.batteryLowThreshold = Number(config.batteryLowThreshold);
    if (!Number.isFinite(node.batteryLowThreshold)) node.batteryLowThreshold = 20;

    var CAPABILITY_MAPPINGS = [
      {
        sourceSystem: "zigbee2mqtt",
        sourceTopicMatch: "zigbee2mqtt/SNZB-04P/<site>/<location>/<device_id>",
        sourceFields: ["contact"],
        targetBus: "home",
        targetCapability: "contact",
        core: true,
        stream: "value",
        payloadProfile: "scalar",
        dataType: "boolean",
        historianMode: "state",
        historianEnabled: true,
        read: function(payload) {
          return readBool(payload, this.sourceFields);
        }
      },
      {
        sourceSystem: "zigbee2mqtt",
        sourceTopicMatch: "zigbee2mqtt/SNZB-04P/<site>/<location>/<device_id>",
        sourceFields: ["battery"],
        targetBus: "home",
        targetCapability: "battery",
        core: true,
        stream: "value",
        payloadProfile: "scalar",
        dataType: "number",
        unit: "%",
        precision: 1,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = readNumber(payload, this.sourceFields[0]);
          if (value === undefined) return undefined;
          return clamp(Math.round(value), 0, 100);
        }
      },
      {
        sourceSystem: "zigbee2mqtt",
        sourceTopicMatch: "zigbee2mqtt/SNZB-04P/<site>/<location>/<device_id>",
        sourceFields: ["battery_low", "batteryLow", "battery"],
        targetBus: "home",
        targetCapability: "battery_low",
        core: true,
        stream: "value",
        payloadProfile: "scalar",
        dataType: "boolean",
        historianMode: "state",
        historianEnabled: true,
        read: function(payload) {
          var raw = readBool(payload, this.sourceFields.slice(0, 2));
          if (raw !== undefined) return raw;
          var battery = readNumber(payload, this.sourceFields[2]);
          if (battery === undefined) return undefined;
          return battery <= node.batteryLowThreshold;
        }
      },
      {
        sourceSystem: "zigbee2mqtt",
        sourceTopicMatch: "zigbee2mqtt/SNZB-04P/<site>/<location>/<device_id>",
        sourceFields: ["voltage"],
        targetBus: "home",
        targetCapability: "voltage",
        core: false,
        stream: "value",
        payloadProfile: "scalar",
        dataType: "number",
        unit: "mV",
        precision: 1,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          return readNumber(payload, this.sourceFields[0]);
        }
      },
      {
        sourceSystem: "zigbee2mqtt",
        sourceTopicMatch: "zigbee2mqtt/SNZB-04P/<site>/<location>/<device_id>",
        sourceFields: ["tamper", "tampered", "tamper_alarm", "alarm_tamper"],
        targetBus: "home",
        targetCapability: "tamper",
        core: false,
        stream: "value",
        payloadProfile: "scalar",
        dataType: "boolean",
        historianMode: "state",
        historianEnabled: true,
        read: function(payload) {
          return readBool(payload, this.sourceFields);
        }
      }
    ];

    function normalizeToken(value) {
      if (value === undefined || value === null) return "";
      return String(value).trim();
    }

    function transliterate(value) {
      var s = normalizeToken(value);
      if (!s) return "";
      if (typeof s.normalize === "function") {
        s = s.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
      }
      return s;
    }

    function toKebabCase(value, fallback) {
      var s = transliterate(value).toLowerCase().replace(/[^a-z0-9]+/g, "-");
      s = s.replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
      return s || fallback || "";
    }

    function clamp(n, min, max) {
      return Math.max(min, Math.min(max, n));
    }

    function topicTokens(topic) {
      if (typeof topic !== "string") return [];
      return topic.split("/").map(function(token) { return token.trim(); }).filter(function(token) { return !!token; });
    }

    function asBool(value) {
      if (typeof value === "boolean") return value;
      if (typeof value === "number") return value !== 0;
      if (typeof value === "string") {
        var v = value.trim().toLowerCase();
        if (v === "true" || v === "1" || v === "on" || v === "yes" || v === "online") return true;
        if (v === "false" || v === "0" || v === "off" || v === "no" || v === "offline") return false;
      }
      return null;
    }

    function pickFirst(obj, keys) {
      if (!obj || typeof obj !== "object") return undefined;
      for (var i = 0; i < keys.length; i++) {
        if (Object.prototype.hasOwnProperty.call(obj, keys[i])) return obj[keys[i]];
      }
      return undefined;
    }

    function pickPath(obj, path) {
      if (!obj || typeof obj !== "object") return undefined;
      var parts = path.split(".");
      var current = obj;
      for (var i = 0; i < parts.length; i++) {
        if (!current || typeof current !== "object" || !Object.prototype.hasOwnProperty.call(current, parts[i])) return undefined;
        current = current[parts[i]];
      }
      return current;
    }

    function pickFirstPath(obj, paths) {
      for (var i = 0; i < paths.length; i++) {
        var value = pickPath(obj, paths[i]);
        if (value !== undefined && value !== null && normalizeToken(value) !== "") return value;
      }
      return undefined;
    }

    function readBool(payload, fields) {
      var raw = asBool(pickFirst(payload, fields));
      return raw === null ? undefined : raw;
    }

    function readNumber(payload, field) {
      if (!payload || typeof payload !== "object") return undefined;
      var value = payload[field];
      if (typeof value !== "number" || !isFinite(value)) return undefined;
      return Number(value);
    }

    function toIsoTimestamp(value) {
      if (value === undefined || value === null) return "";
      if (value instanceof Date && !isNaN(value.getTime())) return value.toISOString();
      if (typeof value === "number" && isFinite(value)) {
        var ms = value < 100000000000 ? value * 1000 : value;
        var dateFromNumber = new Date(ms);
        return isNaN(dateFromNumber.getTime()) ? "" : dateFromNumber.toISOString();
      }
      if (typeof value === "string") {
        var trimmed = value.trim();
        if (!trimmed) return "";
        if (/^\d+$/.test(trimmed)) return toIsoTimestamp(Number(trimmed));
        var dateFromString = new Date(trimmed);
        return isNaN(dateFromString.getTime()) ? "" : dateFromString.toISOString();
      }
      return "";
    }

    function canonicalSourceTopic(topic) {
      var t = normalizeToken(topic);
      if (!t) return "";
      if (/\/availability$/i.test(t)) return t.replace(/\/availability$/i, "");
      return t;
    }

    function inferFromTopic(topic) {
      var tokens = topicTokens(topic);
      var result = {
        deviceType: "",
        site: "",
        location: "",
        deviceId: "",
        friendlyName: "",
        isAvailabilityTopic: false
      };

      if (tokens.length >= 2 && tokens[0].toLowerCase() === "zigbee2mqtt") {
        result.deviceType = tokens[1];

        if (tokens.length >= 6 && tokens[5].toLowerCase() === "availability") {
          result.site = tokens[2];
          result.location = tokens[3];
          result.deviceId = tokens[4];
          result.friendlyName = tokens.slice(1, 5).join("/");
          result.isAvailabilityTopic = true;
          return result;
        }

        if (tokens.length >= 5 && tokens[4].toLowerCase() !== "availability") {
          result.site = tokens[2];
          result.location = tokens[3];
          result.deviceId = tokens[4];
          result.friendlyName = tokens.slice(1, 5).join("/");
          return result;
        }
      }

      return result;
    }

    function resolveIdentity(msg, payload) {
      var safeMsg = (msg && typeof msg === "object") ? msg : {};
      var inferred = inferFromTopic(safeMsg.topic);
      var siteRaw = inferred.site
        || normalizeToken(pickFirst(payload, ["site", "homeSite"]))
        || normalizeToken(pickFirst(safeMsg, ["site", "homeSite"]))
        || node.site
        || "";

      var locationRaw = inferred.location
        || normalizeToken(pickFirst(payload, ["location", "room", "homeLocation", "mqttRoom"]))
        || normalizeToken(pickFirst(safeMsg, ["location", "room", "homeLocation", "mqttRoom"]))
        || node.legacyRoom
        || "";

      var deviceRaw = inferred.deviceId
        || normalizeToken(pickFirst(payload, ["deviceId", "device_id", "sensor", "mqttSensor", "friendly_name", "friendlyName", "name", "device"]))
        || normalizeToken(pickFirst(safeMsg, ["deviceId", "device_id", "sensor", "mqttSensor"]))
        || node.legacySensor
        || inferred.friendlyName
        || inferred.deviceType;

      var displayName = normalizeToken(pickFirst(payload, ["display_name", "displayName", "friendly_name", "friendlyName", "name"]))
        || normalizeToken(pickFirst(safeMsg, ["display_name", "displayName", "friendly_name", "friendlyName", "name"]))
        || inferred.friendlyName
        || deviceRaw
        || "SNZB-04P";

      var sourceRef = normalizeToken(pickFirstPath(payload, ["source_ref", "sourceRef", "ieee_address", "ieeeAddr", "device.ieee_address", "device.ieeeAddr"]))
        || normalizeToken(pickFirstPath(safeMsg, ["source_ref", "sourceRef", "ieee_address", "ieeeAddr", "device.ieee_address", "device.ieeeAddr"]))
        || canonicalSourceTopic(safeMsg.topic)
        || inferred.friendlyName
        || inferred.deviceType
        || deviceRaw
        || "z2m-snzb-04p";

      return {
        site: toKebabCase(siteRaw, "unknown"),
        location: toKebabCase(locationRaw, "unknown"),
        deviceId: toKebabCase(deviceRaw, "snzb-04p"),
        displayName: displayName,
        sourceRef: sourceRef,
        sourceTopic: canonicalSourceTopic(safeMsg.topic),
        isAvailabilityTopic: inferred.isAvailabilityTopic
      };
    }

    function noteDevice(identity) {
      if (!identity) return;
      var key = identity.site + "/" + identity.location + "/" + identity.deviceId;
      if (node.detectedDevices[key]) return;
      node.detectedDevices[key] = true;
      node.stats.devices_detected += 1;
    }

    function validateInboundTopic(topic) {
      var rawTopic = normalizeToken(topic);
      if (!rawTopic) return { valid: false, reason: "Topic must be a non-empty string" };
      var tokens = rawTopic.split("/").map(function(token) { return token.trim(); });
      if (tokens.length < 5) {
        return { valid: false, reason: "Topic must match zigbee2mqtt/SNZB-04P/<site>/<location>/<device_id>[/availability]" };
      }
      if (tokens[0].toLowerCase() !== "zigbee2mqtt" || tokens[1].toLowerCase() !== "snzb-04p") {
        return { valid: false, reason: "Topic must start with zigbee2mqtt/SNZB-04P" };
      }
      if (!tokens[2] || !tokens[3] || !tokens[4]) {
        return { valid: false, reason: "Topic must contain non-empty site, location and device_id segments" };
      }
      if (tokens.length === 5) return { valid: true, isAvailabilityTopic: false };
      if (tokens.length === 6 && tokens[5].toLowerCase() === "availability") {
        return { valid: true, isAvailabilityTopic: true };
      }
      return { valid: false, reason: "Topic must not contain extra segments beyond an optional /availability suffix" };
    }

    function translatedMessageCount() {
      return node.stats.home_messages + node.stats.last_messages + node.stats.meta_messages + node.stats.home_availability_messages;
    }

    function updateNodeStatus(fill, shape, suffix) {
      var parts = [
        "dev " + node.stats.devices_detected,
        "in " + node.stats.processed_inputs,
        "tr " + translatedMessageCount()
      ];
      if (node.stats.operational_messages > 0) parts.push("op " + node.stats.operational_messages);
      if (node.stats.errors > 0) parts.push("err " + node.stats.errors);
      if (suffix) parts.push(suffix);
      node.status({ fill: fill, shape: shape, text: parts.join(" | ") });
    }

    function buildHomeTopic(identity, mapping, stream) {
      return identity.site + "/" + mapping.targetBus + "/" + identity.location + "/" + mapping.targetCapability + "/" + identity.deviceId + "/" + stream;
    }

    function buildSysTopic(site, stream) {
      return site + "/sys/adapter/" + node.adapterId + "/" + stream;
    }

    function makePublishMsg(topic, payload, retain) {
      return { topic: topic, payload: payload, qos: 1, retain: !!retain };
    }

    function makeSubscribeMsg(topic) {
      return {
        action: "subscribe",
        topic: [{
          topic: topic,
          qos: 2,
          rh: 0,
          rap: true
        }]
      };
    }

    function signature(value) {
      return JSON.stringify(value);
    }

    function shouldPublish(cacheKey, payload, retain) {
      var sig = signature(payload) + "::" + (retain ? "r" : "n");
      if (node.publishCache[cacheKey] === sig) return false;
      node.publishCache[cacheKey] = sig;
      return true;
    }

    function shouldPublishRetained(cacheKey, payload) {
      var sig = signature(payload);
      if (node.retainedCache[cacheKey] === sig) return false;
      node.retainedCache[cacheKey] = sig;
      return true;
    }

    function buildLastEnvelope(value, observedAt, quality) {
      return {
        value: value,
        observed_at: observedAt || new Date().toISOString(),
        quality: quality || "source"
      };
    }

    function emitCapability(out, identity, mapping, value, observedAt, quality) {
      var valueTopic = buildHomeTopic(identity, mapping, "value");
      var lastTopic = buildHomeTopic(identity, mapping, "last");
      var valueKey = valueTopic + "::value";
      var lastPayload = buildLastEnvelope(value, observedAt, quality);
      if (shouldPublish(valueKey, value, false)) {
        out.push(makePublishMsg(valueTopic, value, false));
        node.stats.home_messages += 1;
      }
      if (shouldPublishRetained(lastTopic, lastPayload)) {
        out.push(makePublishMsg(lastTopic, lastPayload, true));
        node.stats.last_messages += 1;
      }
      node.seenOptionalCapabilities[mapping.targetCapability] = true;
    }

    function emitMeta(out, identity, sourcePayload) {
      var topic = identity.site + "/home/" + identity.location + "/meta/" + identity.deviceId + "/last";
      var payload = {
        adapter_id: node.adapterId,
        device_type: "SNZB-04P",
        display_name: identity.displayName,
        source_ref: identity.sourceRef,
        source_topic: identity.sourceTopic
      };
      if (sourcePayload && sourcePayload.update) payload.update = sourcePayload.update;
      if (shouldPublishRetained(topic, payload)) {
        out.push(makePublishMsg(topic, payload, true));
        node.stats.meta_messages += 1;
      }
    }

    function emitAvailability(out, identity, online) {
      var topic = identity.site + "/home/" + identity.location + "/availability/" + identity.deviceId + "/last";
      var payload = online ? "online" : "offline";
      if (shouldPublishRetained(topic, payload)) {
        out.push(makePublishMsg(topic, payload, true));
        node.stats.home_availability_messages += 1;
      }
    }

    function emitOperational(out, site, stream, payload, retain) {
      out.push(makePublishMsg(buildSysTopic(site || "unknown", stream), payload, retain));
      node.stats.operational_messages += 1;
    }

    function processTelemetry(msg) {
      var out = [];
      var payload = (msg && typeof msg.payload === "object" && msg.payload && !Array.isArray(msg.payload)) ? msg.payload : null;
      if (!payload) {
        node.stats.invalid_payloads += 1;
        emitOperational(out, "unknown", "dlq", { reason: "invalid-payload", topic: msg && msg.topic }, false);
        return out;
      }

      var validity = validateInboundTopic(msg.topic);
      if (!validity.valid) {
        node.stats.invalid_topics += 1;
        emitOperational(out, "unknown", "dlq", { reason: validity.reason, topic: msg.topic }, false);
        return out;
      }

      var identity = resolveIdentity(msg, payload);
      noteDevice(identity);
      emitMeta(out, identity, payload);

      var observedAt = toIsoTimestamp(payload.last_seen) || new Date().toISOString();
      var quality = toIsoTimestamp(payload.last_seen) ? "source" : "estimated";

      for (var i = 0; i < CAPABILITY_MAPPINGS.length; i++) {
        var mapping = CAPABILITY_MAPPINGS[i];
        try {
          var value = mapping.read(payload);
          if (value === undefined) continue;
          emitCapability(out, identity, mapping, value, observedAt, quality);
        } catch (err) {
          node.stats.adapter_exceptions += 1;
          emitOperational(out, identity.site, "error", { capability: mapping.targetCapability, error: err.message }, false);
        }
      }

      if (validity.isAvailabilityTopic || payload.availability !== undefined || payload.online !== undefined) {
        var online = asBool(payload.online);
        if (online === null) online = asBool(payload.availability);
        if (online !== null) emitAvailability(out, identity, online);
      }

      return out;
    }

    function startSubscriptions() {
      if (node.subscriptionStarted) return;
      node.subscriptionStarted = true;
      node.send([null, makeSubscribeMsg(node.sourceTopic)]);
      updateNodeStatus("yellow", "ring", "subscribed");
    }

    node.on("input", function(msg, send, done) {
      send = send || function() { node.send.apply(node, arguments); };
      try {
        node.stats.processed_inputs += 1;
        var outputs = processTelemetry(msg);
        send([outputs, null]);
        updateNodeStatus(node.stats.errors ? "red" : "green", "dot");
        if (done) done();
      } catch (err) {
        node.stats.errors += 1;
        updateNodeStatus("red", "ring", err.message);
        if (done) done(err);
        else node.error(err, msg);
      }
    });

    node.on("close", function() {
      if (node.startTimer) {
        clearTimeout(node.startTimer);
        node.startTimer = null;
      }
    });

    node.startTimer = setTimeout(startSubscriptions, 250);
    updateNodeStatus("grey", "ring", "starting");
  }

  RED.nodes.registerType("z2m-snzb-04p-homebus", Z2MSNZB04PHomeBusNode);
};