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

    node.adapterId = "z2m-pa-44z";
    node.sourceTopic = "zigbee2mqtt/PA-44Z/#";
    node.site = normalizeToken(config.site || config.mqttSite || "unknown");
    node.batteryType = normalizeToken(config.batteryType || "alkaline").toLowerCase() || "alkaline";
    node.batteryLowThreshold = parseNumber(config.batteryLowThreshold, 20, 0);
    node.publishCache = Object.create(null);
    node.startTimer = null;
    node.subscriptionStarted = false;

    node.stats = {
      processed: 0,
      published: 0,
      invalid: 0,
      errors: 0
    };

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

    function parseNumber(value, fallback, min) {
      var n = Number(value);
      if (!Number.isFinite(n)) return fallback;
      if (typeof min === "number" && n < min) return fallback;
      return n;
    }

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

    var ALKALINE_BATTERY_CURVE = [
      { pct: 100, voltage: 1.60 },
      { pct: 90, voltage: 1.55 },
      { pct: 80, voltage: 1.50 },
      { pct: 70, voltage: 1.46 },
      { pct: 60, voltage: 1.42 },
      { pct: 50, voltage: 1.36 },
      { pct: 40, voltage: 1.30 },
      { pct: 30, voltage: 1.25 },
      { pct: 20, voltage: 1.20 },
      { pct: 10, voltage: 1.10 },
      { pct: 0, voltage: 0.90 }
    ];

    var NIMH_BATTERY_CURVE = [
      { pct: 100, voltage: 1.40 },
      { pct: 95, voltage: 1.33 },
      { pct: 90, voltage: 1.28 },
      { pct: 85, voltage: 1.24 },
      { pct: 80, voltage: 1.20 },
      { pct: 75, voltage: 1.19 },
      { pct: 70, voltage: 1.18 },
      { pct: 60, voltage: 1.17 },
      { pct: 50, voltage: 1.16 },
      { pct: 40, voltage: 1.15 },
      { pct: 30, voltage: 1.13 },
      { pct: 20, voltage: 1.11 },
      { pct: 10, voltage: 1.07 },
      { pct: 0, voltage: 1.00 }
    ];

    function interpolateCurve(points, inputKey, outputKey, inputValue) {
      if (!Array.isArray(points) || points.length === 0) return null;
      if (inputValue >= points[0][inputKey]) return points[0][outputKey];

      for (var i = 1; i < points.length; i++) {
        var upper = points[i - 1];
        var lower = points[i];
        var upperInput = upper[inputKey];
        var lowerInput = lower[inputKey];

        if (inputValue >= lowerInput) {
          var range = upperInput - lowerInput;
          if (range <= 0) return lower[outputKey];
          var ratio = (inputValue - lowerInput) / range;
          return lower[outputKey] + ratio * (upper[outputKey] - lower[outputKey]);
        }
      }

      return points[points.length - 1][outputKey];
    }

    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 asNumber(value) {
      if (typeof value === "number" && isFinite(value)) return value;
      if (typeof value === "string") {
        var trimmed = value.trim();
        if (!trimmed) return null;
        var parsed = Number(trimmed);
        if (isFinite(parsed)) return parsed;
      }
      return null;
    }

    function toIsoTimestamp(value) {
      if (value === undefined || value === null) return "";
      if (typeof value === "string" && value.trim()) {
        var fromString = new Date(value);
        if (!isNaN(fromString.getTime())) return fromString.toISOString();
      }
      return new Date().toISOString();
    }

    function translateBatteryLevel(rawValue) {
      if (rawValue === null || rawValue === undefined) return null;
      var raw = clamp(Math.round(Number(rawValue)), 0, 100);
      if (node.batteryType !== "nimh") return raw;

      // Reinterpret the reported percentage on an alkaline discharge curve,
      // then project the equivalent cell voltage onto a flatter NiMH curve.
      var estimatedVoltage = interpolateCurve(ALKALINE_BATTERY_CURVE, "pct", "voltage", raw);
      var nimhPct = interpolateCurve(NIMH_BATTERY_CURVE, "voltage", "pct", estimatedVoltage);
      return clamp(Math.round(nimhPct), 0, 100);
    }

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

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

    function makePublish(topic, payload, retain) {
      return {
        topic: topic,
        payload: payload,
        qos: 2,
        retain: !!retain
      };
    }

    function setStatus(prefix, fill) {
      node.status({
        fill: fill || (node.stats.errors ? "red" : "green"),
        shape: "dot",
        text: [prefix || "live", "in:" + node.stats.processed, "out:" + node.stats.published, "err:" + node.stats.errors].join(" ")
      });
    }

    function buildTopic(site, location, capability, deviceId, stream) {
      return [site, "home", location, capability, deviceId, stream].join("/");
    }

    function pushCapability(messages, identity, capability, value, observedAt, meta) {
      if (value === null || value === undefined) return;

      var valueTopic = buildTopic(identity.site, identity.location, capability, identity.deviceId, "value");
      var lastTopic = buildTopic(identity.site, identity.location, capability, identity.deviceId, "last");
      var metaTopic = buildTopic(identity.site, identity.location, capability, identity.deviceId, "meta");

      if (shouldPublish(valueTopic, value)) {
        messages.push(makePublish(valueTopic, value, false));
        node.stats.published += 1;
      }

      var lastPayload = {
        value: value,
        observed_at: observedAt,
        quality: "reported"
      };
      if (shouldPublish(lastTopic, lastPayload)) {
        messages.push(makePublish(lastTopic, lastPayload, true));
        node.stats.published += 1;
      }

      if (meta && shouldPublish(metaTopic, meta)) {
        messages.push(makePublish(metaTopic, meta, true));
        node.stats.published += 1;
      }
    }

    function publishAvailability(messages, identity, active, observedAt) {
      var availabilityTopic = buildTopic(identity.site, identity.location, "adapter", identity.deviceId, "availability");
      var availabilityPayload = active;
      if (shouldPublish(availabilityTopic, availabilityPayload)) {
        messages.push(makePublish(availabilityTopic, availabilityPayload, true));
        node.stats.published += 1;
      }

      var lastTopic = buildTopic(identity.site, identity.location, "adapter", identity.deviceId, "last");
      var lastPayload = { value: active, observed_at: observedAt, quality: "reported" };
      if (shouldPublish(lastTopic, lastPayload)) {
        messages.push(makePublish(lastTopic, lastPayload, true));
        node.stats.published += 1;
      }
    }

    function parseTopic(topic) {
      if (typeof topic !== "string") return null;
      var tokens = topic.split("/").map(function(token) { return token.trim(); }).filter(function(token) { return !!token; });
      if (tokens.length !== 5 && tokens.length !== 6) return null;
      if (tokens[0].toLowerCase() !== "zigbee2mqtt" || tokens[1].toLowerCase() !== "pa-44z") return null;
      if (tokens.length === 6 && tokens[5].toLowerCase() !== "availability") return null;
      return {
        site: toKebabCase(tokens[2], node.site || "unknown"),
        location: toKebabCase(tokens[3], "unknown"),
        deviceId: toKebabCase(tokens[4], "pa-44z"),
        availabilityTopic: tokens.length === 6
      };
    }

    function buildIdentity(parsed) {
      return {
        site: parsed.site || node.site || "unknown",
        location: parsed.location || "unknown",
        deviceId: parsed.deviceId || "pa-44z"
      };
    }

    function buildMeta(identity, capability, unit, core) {
      var out = {
        adapter_id: node.adapterId,
        device_type: "PA-44Z",
        capability: capability,
        core: !!core,
        source_ref: ["zigbee2mqtt", "PA-44Z", identity.site, identity.location, identity.deviceId].join("/")
      };
      if (unit) out.unit = unit;
      return out;
    }

    function processTelemetry(identity, payload, observedAt) {
      var messages = [];
      var smoke = asBool(payload.smoke);
      var battery = translateBatteryLevel(asNumber(payload.battery));
      var batteryLowRaw = asBool(payload.battery_low);
      var batteryLow = batteryLowRaw === null ? (battery !== null && battery <= node.batteryLowThreshold) : batteryLowRaw;
      var deviceFault = asBool(payload.device_fault);
      var silence = asBool(payload.silence);
      var test = asBool(payload.test);
      var concentration = asNumber(payload.smoke_concentration);

      publishAvailability(messages, identity, true, observedAt);
      pushCapability(messages, identity, "smoke", smoke, observedAt, buildMeta(identity, "smoke", "", true));
      pushCapability(messages, identity, "battery", battery, observedAt, buildMeta(identity, "battery", "%", true));
      pushCapability(messages, identity, "battery_low", batteryLow, observedAt, buildMeta(identity, "battery_low", "", true));
      pushCapability(messages, identity, "device_fault", deviceFault, observedAt, buildMeta(identity, "device_fault", "", true));
      pushCapability(messages, identity, "silence", silence, observedAt, buildMeta(identity, "silence", "", false));
      pushCapability(messages, identity, "test", test, observedAt, buildMeta(identity, "test", "", false));
      pushCapability(messages, identity, "smoke_concentration", concentration, observedAt, buildMeta(identity, "smoke_concentration", "ppm", false));

      return messages;
    }

    function startSubscriptions() {
      if (node.subscriptionStarted) return;
      node.subscriptionStarted = true;
      node.send([null, { action: "subscribe", topic: node.sourceTopic, qos: 2, rh: 0, rap: true }]);
      setStatus("subscribed", "yellow");
    }

    node.on("input", function(msg, send, done) {
      send = send || function() { node.send.apply(node, arguments); };
      try {
        node.stats.processed += 1;
        var parsed = parseTopic(msg && msg.topic);
        if (!parsed) {
          node.stats.invalid += 1;
          setStatus("invalid", "red");
          if (done) done();
          return;
        }

        var identity = buildIdentity(parsed);
        var observedAt = toIsoTimestamp(msg && msg.payload && msg.payload.last_seen);
        var messages = [];

        if (parsed.availabilityTopic) {
          var active = asBool(msg.payload);
          if (active === null) active = false;
          publishAvailability(messages, identity, active, observedAt);
        } else if (msg.payload && typeof msg.payload === "object" && !Array.isArray(msg.payload)) {
          messages = processTelemetry(identity, msg.payload, observedAt);
        } else {
          node.stats.invalid += 1;
          setStatus("invalid", "red");
          if (done) done();
          return;
        }

        if (messages.length) send([messages, null]);
        setStatus();
        if (done) done();
      } catch (err) {
        node.stats.errors += 1;
        node.status({ fill: "red", shape: "ring", text: "error: " + 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);
    node.status({ fill: "grey", shape: "ring", text: "starting" });
  }

  RED.nodes.registerType("z2m-pa-44z-homebus", PA44ZHomeBusNode);
};