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

    node.adapterId = "z2m-smart-socket-energy";
    node.site = normalizeToken(config.site || config.mqttSite || "");
    node.entityType = normalizeToken(config.entityType || "load").toLowerCase() || "load";
    node.sourceModels = ["A1Z", "S60ZBTPF"];
    node.sourceTopics = node.sourceModels.map(function(model) { return "zigbee2mqtt/" + model + "/#"; });
    node.subscriptionStarted = false;
    node.startTimer = null;
    node.publishCache = Object.create(null);
    node.retainedCache = Object.create(null);
    node.statsPublishEvery = 25;

    node.stats = {
      processed_inputs: 0,
      raw_inputs: 0,
      energy_messages: 0,
      last_messages: 0,
      meta_messages: 0,
      energy_availability_messages: 0,
      operational_messages: 0,
      invalid_messages: 0,
      invalid_topics: 0,
      invalid_payloads: 0,
      unmapped_messages: 0,
      errors: 0,
      dlq: 0
    };

    var ENERGY_MAPPINGS = [
      {
        targetMetric: "active_power",
        core: true,
        payloadProfile: "scalar",
        dataType: "number",
        unit: "W",
        precision: 0.1,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = asNumber(payload.power);
          return value === null ? undefined : value;
        }
      },
      {
        targetMetric: "energy_total",
        core: true,
        payloadProfile: "scalar",
        dataType: "number",
        unit: "kWh",
        precision: 0.001,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = asNumber(payload.energy);
          return value === null ? undefined : value;
        }
      },
      {
        targetMetric: "voltage",
        core: true,
        payloadProfile: "scalar",
        dataType: "number",
        unit: "V",
        precision: 0.1,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = asNumber(payload.voltage);
          return value === null ? undefined : value;
        }
      },
      {
        targetMetric: "current",
        core: true,
        payloadProfile: "scalar",
        dataType: "number",
        unit: "A",
        precision: 0.001,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = asNumber(payload.current);
          return value === null ? undefined : value;
        }
      },
      {
        models: ["S60ZBTPF"],
        targetMetric: "energy_today",
        core: false,
        payloadProfile: "scalar",
        dataType: "number",
        unit: "kWh",
        precision: 0.001,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = asNumber(payload.energy_today);
          return value === null ? undefined : value;
        }
      },
      {
        models: ["S60ZBTPF"],
        targetMetric: "energy_yesterday",
        core: false,
        payloadProfile: "scalar",
        dataType: "number",
        unit: "kWh",
        precision: 0.001,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = asNumber(payload.energy_yesterday);
          return value === null ? undefined : value;
        }
      },
      {
        models: ["S60ZBTPF"],
        targetMetric: "energy_month",
        core: false,
        payloadProfile: "scalar",
        dataType: "number",
        unit: "kWh",
        precision: 0.001,
        historianMode: "sample",
        historianEnabled: true,
        read: function(payload) {
          var value = asNumber(payload.energy_month);
          return value === null ? undefined : value;
        }
      }
    ];

    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 humanizeCapability(capability) {
      return String(capability || "").replace(/_/g, " ").replace(/\b[a-z]/g, function(ch) { return ch.toUpperCase(); });
    }

    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 || value === "") return "";
      var parsed = new Date(value);
      if (isNaN(parsed.getTime())) return "";
      return parsed.toISOString();
    }

    function resolveObservation(msg, payloadObject) {
      var observedAt = "";
      if (payloadObject && typeof payloadObject === "object") {
        observedAt = toIsoTimestamp(payloadObject.observed_at)
          || toIsoTimestamp(payloadObject.observedAt)
          || toIsoTimestamp(payloadObject.timestamp)
          || toIsoTimestamp(payloadObject.time)
          || toIsoTimestamp(payloadObject.ts)
          || toIsoTimestamp(payloadObject.last_seen);
      }

      if (!observedAt && msg && typeof msg === "object") {
        observedAt = toIsoTimestamp(msg.observed_at)
          || toIsoTimestamp(msg.observedAt)
          || toIsoTimestamp(msg.timestamp)
          || toIsoTimestamp(msg.time)
          || toIsoTimestamp(msg.ts);
      }

      if (observedAt) {
        return {
          observedAt: observedAt,
          quality: "good"
        };
      }

      return {
        observedAt: new Date().toISOString(),
        quality: "estimated"
      };
    }

    function supportsModel(mapping, model) {
      if (!mapping.models || !mapping.models.length) return true;
      return mapping.models.indexOf(model) >= 0;
    }

    function translatedMessageCount() {
      return node.stats.energy_messages
        + node.stats.last_messages
        + node.stats.meta_messages
        + node.stats.energy_availability_messages;
    }

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

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

    function buildEnergyTopic(identity, mapping, stream) {
      return identity.site + "/energy/" + identity.entityType + "/" + identity.entityId + "/" + mapping.targetMetric + "/" + stream;
    }

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

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

    function shouldPublishLive(cacheKey, payload) {
      var sig = signature(payload);
      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 buildLastPayload(value, observation) {
      var payload = {
        value: value,
        observed_at: observation.observedAt
      };
      if (observation.quality && observation.quality !== "good") payload.quality = observation.quality;
      return payload;
    }

    function buildMetaPayload(identity, mapping) {
      var payload = {
        schema_ref: "mqbus.energy.v1",
        payload_profile: mapping.payloadProfile || "scalar",
        stream_payload_profiles: { value: "scalar", last: "envelope" },
        data_type: mapping.dataType,
        adapter_id: node.adapterId,
        source: "zigbee2mqtt",
        source_ref: identity.sourceRef,
        source_topic: identity.sourceTopic,
        display_name: identity.displayName + " " + humanizeCapability(mapping.targetMetric),
        tags: ["zigbee2mqtt", "smart-socket", identity.model.toLowerCase(), "energy", identity.entityType],
        historian: {
          enabled: !!mapping.historianEnabled,
          mode: mapping.historianMode
        }
      };

      if (mapping.unit) payload.unit = mapping.unit;
      if (mapping.precision !== undefined) payload.precision = mapping.precision;

      return payload;
    }

    function enqueueEnergyMeta(messages, identity, mapping) {
      var topic = buildEnergyTopic(identity, mapping, "meta");
      var payload = buildMetaPayload(identity, mapping);
      if (!shouldPublishRetained("meta:" + topic, payload)) return;
      messages.push(makePublishMsg(topic, payload, true));
      noteMessage("meta_messages");
    }

    function enqueueEnergyAvailability(messages, identity, mapping, online) {
      var topic = buildEnergyTopic(identity, mapping, "availability");
      var payload = online ? "online" : "offline";
      if (!shouldPublishRetained("availability:" + topic, payload)) return;
      messages.push(makePublishMsg(topic, payload, true));
      noteMessage("energy_availability_messages");
    }

    function enqueueEnergyLast(messages, identity, mapping, value, observation) {
      var topic = buildEnergyTopic(identity, mapping, "last");
      var payload = buildLastPayload(value, observation);
      if (!shouldPublishRetained("last:" + topic, payload)) return;
      messages.push(makePublishMsg(topic, payload, true));
      noteMessage("last_messages");
    }

    function enqueueEnergyValue(messages, identity, mapping, value) {
      var topic = buildEnergyTopic(identity, mapping, "value");
      if (!shouldPublishLive("value:" + topic, value)) return;
      messages.push(makePublishMsg(topic, value, false));
      noteMessage("energy_messages");
    }

    function enqueueAdapterAvailability(messages, site, online) {
      var topic = buildSysTopic(site, "availability");
      var payload = online ? "online" : "offline";
      if (!shouldPublishRetained("sys:availability:" + topic, payload)) return;
      messages.push(makePublishMsg(topic, payload, true));
      noteMessage("operational_messages");
    }

    function enqueueAdapterStats(messages, site, force) {
      if (!force && node.stats.processed_inputs !== 1 && (node.stats.processed_inputs % node.statsPublishEvery) !== 0) return;
      var topic = buildSysTopic(site, "stats");
      var payload = {
        processed_inputs: node.stats.processed_inputs,
        raw_inputs: node.stats.raw_inputs,
        translated_messages: translatedMessageCount(),
        energy_messages: node.stats.energy_messages,
        last_messages: node.stats.last_messages,
        meta_messages: node.stats.meta_messages,
        energy_availability_messages: node.stats.energy_availability_messages,
        operational_messages: node.stats.operational_messages,
        invalid_messages: node.stats.invalid_messages,
        invalid_topics: node.stats.invalid_topics,
        invalid_payloads: node.stats.invalid_payloads,
        unmapped_messages: node.stats.unmapped_messages,
        errors: node.stats.errors,
        dlq: node.stats.dlq
      };
      messages.push(makePublishMsg(topic, payload, true));
      noteMessage("operational_messages");
    }

    function enqueueError(messages, site, code, reason, sourceTopic) {
      var payload = {
        code: code,
        reason: reason,
        source_topic: normalizeToken(sourceTopic),
        adapter_id: node.adapterId
      };
      messages.push(makePublishMsg(buildSysTopic(site, "error"), payload, false));
      if (code === "invalid_message") noteMessage("invalid_messages");
      else if (code === "invalid_topic") noteMessage("invalid_topics");
      else if (code === "payload_not_object" || code === "invalid_availability_payload") noteMessage("invalid_payloads");
      else if (code === "no_mapped_fields") noteMessage("unmapped_messages");
      noteMessage("errors");
      noteMessage("operational_messages");
    }

    function enqueueDlq(messages, site, code, sourceTopic, rawPayload) {
      var payload = {
        code: code,
        source_topic: normalizeToken(sourceTopic),
        payload: rawPayload
      };
      messages.push(makePublishMsg(buildSysTopic(site, "dlq"), payload, false));
      noteMessage("dlq");
      noteMessage("operational_messages");
    }

    function noteMessage(kind) {
      if (Object.prototype.hasOwnProperty.call(node.stats, kind)) {
        node.stats[kind] += 1;
      }
    }

    function summarizeForLog(value) {
      if (value === undefined) return "undefined";
      if (value === null) return "null";
      if (typeof value === "string") return value.length > 180 ? value.slice(0, 177) + "..." : value;
      try {
        var serialized = JSON.stringify(value);
        return serialized.length > 180 ? serialized.slice(0, 177) + "..." : serialized;
      } catch (err) {
        return String(value);
      }
    }

    function logIssue(level, code, reason, msg, rawPayload) {
      var parts = ["[" + node.adapterId + "]", code + ":", reason];
      if (msg && typeof msg === "object" && normalizeToken(msg.topic)) {
        parts.push("topic=" + normalizeToken(msg.topic));
      }
      if (rawPayload !== undefined) {
        parts.push("payload=" + summarizeForLog(rawPayload));
      }
      var text = parts.join(" ");
      if (level === "error") {
        node.error(text, msg);
      } else {
        node.warn(text);
      }
    }

    function parseRawTopic(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") return null;
      if (node.sourceModels.indexOf(tokens[1]) < 0) return null;
      if (tokens.length === 6 && tokens[5].toLowerCase() !== "availability") return null;
      return {
        model: tokens[1],
        site: toKebabCase(tokens[2], node.site || "unknown"),
        location: toKebabCase(tokens[3], "unknown"),
        deviceId: toKebabCase(tokens[4], tokens[1].toLowerCase()),
        sourceTopic: tokens.slice(0, 5).join("/"),
        availabilityTopic: tokens.length === 6
      };
    }

    function buildIdentity(parsed) {
      var entityId = toKebabCase((parsed.location || "unknown") + "-" + (parsed.deviceId || parsed.model.toLowerCase()), parsed.deviceId || parsed.model.toLowerCase());
      return {
        model: parsed.model,
        site: parsed.site || node.site || "unknown",
        entityType: node.entityType || "load",
        entityId: entityId,
        sourceRef: parsed.sourceTopic,
        sourceTopic: parsed.sourceTopic,
        displayName: [parsed.location || "unknown", parsed.deviceId || parsed.model.toLowerCase()].join(" ")
      };
    }

    function activeMappings(model, payloadObject) {
      var result = [];
      for (var i = 0; i < ENERGY_MAPPINGS.length; i++) {
        var mapping = ENERGY_MAPPINGS[i];
        if (!supportsModel(mapping, model)) continue;
        var value = payloadObject ? mapping.read(payloadObject, model) : undefined;
        result.push({
          mapping: mapping,
          hasValue: value !== undefined,
          value: value
        });
      }
      return result;
    }

    function resolveOnlineState(payloadObject, availabilityValue) {
      if (availabilityValue !== null && availabilityValue !== undefined) return !!availabilityValue;
      if (!payloadObject) return true;
      if (typeof payloadObject.availability === "string") {
        return payloadObject.availability.trim().toLowerCase() !== "offline";
      }
      if (typeof payloadObject.online === "boolean") {
        return payloadObject.online;
      }
      return true;
    }

    function housekeepingOnly(payloadObject) {
      if (!payloadObject || typeof payloadObject !== "object") return false;
      var keys = Object.keys(payloadObject);
      if (!keys.length) return true;
      for (var i = 0; i < keys.length; i++) {
        if (["last_seen", "linkquality", "update", "availability", "online", "state", "power_on_behavior", "power_outage_memory", "indicator_mode", "child_lock", "countdown", "switch_type_button", "outlet_control_protect", "overload_protection"].indexOf(keys[i]) < 0) return false;
      }
      return !Object.prototype.hasOwnProperty.call(payloadObject, "power")
        && !Object.prototype.hasOwnProperty.call(payloadObject, "energy")
        && !Object.prototype.hasOwnProperty.call(payloadObject, "voltage")
        && !Object.prototype.hasOwnProperty.call(payloadObject, "current")
        && !Object.prototype.hasOwnProperty.call(payloadObject, "energy_today")
        && !Object.prototype.hasOwnProperty.call(payloadObject, "energy_yesterday")
        && !Object.prototype.hasOwnProperty.call(payloadObject, "energy_month");
    }

    function statusText(prefix) {
      return [
        prefix || (node.subscriptionStarted ? "live" : "idle"),
        "in:" + node.stats.processed_inputs,
        "energy:" + node.stats.energy_messages,
        "err:" + node.stats.errors
      ].join(" ");
    }

    function updateNodeStatus(fill, shape, prefix) {
      node.status({
        fill: fill || (node.stats.errors ? "red" : "green"),
        shape: shape || "dot",
        text: statusText(prefix)
      });
    }

    function flush(send, done, publishMessages, controlMessages, error) {
      send([
        publishMessages.length ? publishMessages : null,
        controlMessages.length ? controlMessages : null
      ]);
      if (done) done(error);
    }

    function startSubscriptions() {
      if (node.subscriptionStarted) return;
      node.subscriptionStarted = true;
      var controls = node.sourceTopics.map(function(topic) { return makeSubscribeMsg(topic); });
      node.send([null, controls]);
      updateNodeStatus("yellow", "dot", "subscribed");
    }

    node.on("input", function(msg, send, done) {
      send = send || function() { node.send.apply(node, arguments); };
      node.stats.processed_inputs += 1;

      try {
        if (!msg || typeof msg !== "object") {
          var invalidMessages = [];
          var invalidSite = node.site || "unknown";
          enqueueAdapterAvailability(invalidMessages, invalidSite, true);
          enqueueError(invalidMessages, invalidSite, "invalid_message", "Input must be an object", "");
          enqueueDlq(invalidMessages, invalidSite, "invalid_message", "", null);
          enqueueAdapterStats(invalidMessages, invalidSite, true);
          logIssue("warn", "invalid_message", "Input must be an object", null, msg);
          updateNodeStatus("yellow", "ring", "bad msg");
          flush(send, done, invalidMessages, []);
          return;
        }

        var publishMessages = [];
        var controlMessages = [];
        var parsed = parseRawTopic(msg.topic);

        if (!parsed) {
          var unknownSite = node.site || "unknown";
          enqueueAdapterAvailability(publishMessages, unknownSite, true);
          enqueueError(publishMessages, unknownSite, "invalid_topic", "Unsupported topic for smart socket energy adapter", msg.topic);
          enqueueDlq(publishMessages, unknownSite, "invalid_topic", msg.topic, msg.payload);
          enqueueAdapterStats(publishMessages, unknownSite, true);
          logIssue("warn", "invalid_topic", "Unsupported topic for smart socket energy adapter", msg, msg.payload);
          updateNodeStatus("yellow", "ring", "bad topic");
          flush(send, done, publishMessages, controlMessages);
          return;
        }

        node.stats.raw_inputs += 1;
        var identity = buildIdentity(parsed);
        enqueueAdapterAvailability(publishMessages, identity.site, true);

        if (parsed.availabilityTopic) {
          var availabilityValue = asBool(msg.payload);
          if (availabilityValue === null) {
            enqueueError(publishMessages, identity.site, "invalid_availability_payload", "Availability payload must be online/offline or boolean", msg.topic);
            enqueueDlq(publishMessages, identity.site, "invalid_availability_payload", msg.topic, msg.payload);
            enqueueAdapterStats(publishMessages, identity.site, true);
            logIssue("warn", "invalid_availability_payload", "Availability payload must be online/offline or boolean", msg, msg.payload);
            updateNodeStatus("yellow", "ring", "bad availability");
            flush(send, done, publishMessages, controlMessages);
            return;
          }

          var availabilityMappings = activeMappings(identity.model, null);
          for (var i = 0; i < availabilityMappings.length; i++) {
            enqueueEnergyMeta(publishMessages, identity, availabilityMappings[i].mapping);
            enqueueEnergyAvailability(publishMessages, identity, availabilityMappings[i].mapping, availabilityValue);
          }

          enqueueAdapterStats(publishMessages, identity.site, false);
          updateNodeStatus(availabilityValue ? "green" : "yellow", availabilityValue ? "dot" : "ring", availabilityValue ? "live" : "offline");
          flush(send, done, publishMessages, controlMessages);
          return;
        }

        var payloadObject = msg.payload && typeof msg.payload === "object" && !Array.isArray(msg.payload) ? msg.payload : null;
        if (!payloadObject) {
          enqueueError(publishMessages, identity.site, "payload_not_object", "Telemetry payload must be an object", msg.topic);
          enqueueDlq(publishMessages, identity.site, "payload_not_object", msg.topic, msg.payload);
          enqueueAdapterStats(publishMessages, identity.site, true);
          logIssue("warn", "payload_not_object", "Telemetry payload must be an object", msg, msg.payload);
          updateNodeStatus("yellow", "ring", "payload");
          flush(send, done, publishMessages, controlMessages);
          return;
        }

        var observation = resolveObservation(msg, payloadObject);
        var online = resolveOnlineState(payloadObject, null);
        var mappings = activeMappings(identity.model, payloadObject);
        var hasMappedValue = false;

        for (var j = 0; j < mappings.length; j++) {
          enqueueEnergyMeta(publishMessages, identity, mappings[j].mapping);
          enqueueEnergyAvailability(publishMessages, identity, mappings[j].mapping, online);
          if (mappings[j].hasValue) {
            hasMappedValue = true;
            enqueueEnergyLast(publishMessages, identity, mappings[j].mapping, mappings[j].value, observation);
            enqueueEnergyValue(publishMessages, identity, mappings[j].mapping, mappings[j].value);
          }
        }

        if (!hasMappedValue && !housekeepingOnly(payloadObject)) {
          enqueueError(publishMessages, identity.site, "no_mapped_fields", "Payload did not contain any supported smart socket Energy Bus fields", msg.topic);
          enqueueDlq(publishMessages, identity.site, "no_mapped_fields", msg.topic, payloadObject);
          logIssue("warn", "no_mapped_fields", "Payload did not contain any supported smart socket Energy Bus fields", msg, payloadObject);
        }

        enqueueAdapterStats(publishMessages, identity.site, false);
        if (!hasMappedValue && !housekeepingOnly(payloadObject)) {
          updateNodeStatus("yellow", "ring", "unmapped");
        } else {
          updateNodeStatus(online ? "green" : "yellow", online ? "dot" : "ring", online ? "live" : "offline");
        }
        flush(send, done, publishMessages, controlMessages);
      } catch (err) {
        var site = node.site || "unknown";
        var errorMessages = [];
        enqueueAdapterAvailability(errorMessages, site, true);
        enqueueError(errorMessages, site, "adapter_exception", err.message, msg && msg.topic);
        enqueueAdapterStats(errorMessages, site, true);
        logIssue("error", "adapter_exception", err.message, msg, msg && msg.payload);
        updateNodeStatus("red", "ring", "error");
        flush(send, done, errorMessages, [], err);
      }
    });

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

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

  RED.nodes.registerType("z2m-smart-socket-energy", Z2MSmartSocketEnergyNode);
};