module.exports = function(RED) {

  function Z2MSmartSocketHomeBusNode(config) {

    RED.nodes.createNode(this, config);

    var node = this;

    node.adapterId = "z2m-smart-socket-homebus";

    node.site = normalizeToken(config.site || config.mqttSite || "");

    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.deviceRegistry = Object.create(null);

    node.statsPublishEvery = 25;

    node.stats = {

      processed_inputs: 0,

      raw_inputs: 0,

      command_inputs: 0,

      devices_detected: 0,

      home_messages: 0,

      last_messages: 0,

      meta_messages: 0,

      home_availability_messages: 0,

      raw_command_messages: 0,

      operational_messages: 0,

      invalid_messages: 0,

      invalid_topics: 0,

      invalid_payloads: 0,

      unmapped_messages: 0,

      unknown_devices: 0,

      errors: 0,

      dlq: 0

    };

    var HOME_MAPPINGS = [

      {

        targetCapability: "power",

        core: true,

        writable: true,

        payloadProfile: "scalar",

        dataType: "boolean",

        historianMode: "state",

        historianEnabled: true,

        read: function(payload) {

          var value = asSwitchState(payload.state);

          return value === null ? undefined : value;

        }

      },

      {

        targetCapability: "power_restore_mode",

        core: true,

        payloadProfile: "scalar",

        dataType: "string",

        historianMode: "state",

        historianEnabled: true,

        read: function(payload, model) {

          var raw = null;

          if (model === "A1Z") raw = asLowerEnum(payload.power_outage_memory);

          else if (model === "S60ZBTPF") raw = asLowerEnum(payload.power_on_behavior);

          if (!raw) return undefined;

          if (raw === "restore") return "previous";

          return raw;

        }

      },

      {

        models: ["A1Z"],

        targetCapability: "countdown",

        core: false,

        payloadProfile: "scalar",

        dataType: "number",

        unit: "s",

        precision: 1,

        historianMode: "sample",

        historianEnabled: true,

        read: function(payload) {

          var value = asNumber(payload.countdown);

          return value === null ? undefined : value;

        }

      },

      {

        models: ["A1Z"],

        targetCapability: "lock",

        core: false,

        payloadProfile: "scalar",

        dataType: "boolean",

        historianMode: "state",

        historianEnabled: true,

        read: function(payload) {

          var value = asLockState(payload.child_lock);

          return value === null ? undefined : value;

        }

      },

      {

        models: ["A1Z"],

        targetCapability: "indicator_mode",

        core: false,

        payloadProfile: "scalar",

        dataType: "string",

        historianMode: "state",

        historianEnabled: true,

        read: function(payload) {

          var value = asLowerEnum(payload.indicator_mode);

          return value || undefined;

        }

      },

      {

        models: ["A1Z"],

        targetCapability: "button_mode",

        core: false,

        payloadProfile: "scalar",

        dataType: "string",

        historianMode: "state",

        historianEnabled: true,

        read: function(payload) {

          var value = asLowerEnum(payload.switch_type_button);

          return value || undefined;

        }

      },

      {

        models: ["S60ZBTPF"],

        targetCapability: "protection_enabled",

        core: false,

        payloadProfile: "scalar",

        dataType: "boolean",

        historianMode: "state",

        historianEnabled: true,

        read: function(payload) {

          var value = asBool(payload.outlet_control_protect);

          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" || v === "lock" || v === "locked") return true;

        if (v === "false" || v === "0" || v === "off" || v === "no" || v === "offline" || v === "unlock" || v === "unlocked") 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 asLowerEnum(value) {

      var s = normalizeToken(value).toLowerCase();

      return s || null;

    }

    function asSwitchState(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 === "on" || v === "true" || v === "1") return true;

        if (v === "off" || v === "false" || v === "0") return false;

      }

      return null;

    }

    function asLockState(value) {

      if (typeof value === "string") {

        var v = value.trim().toLowerCase();

        if (v === "lock" || v === "locked") return true;

        if (v === "unlock" || v === "unlocked") return false;

      }

      return asBool(value);

    }

    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 registryKey(site, location, deviceId) {

      return [site || "", location || "", deviceId || ""].join("|");

    }

    function translatedMessageCount() {

      return node.stats.home_messages

        + node.stats.last_messages

        + node.stats.meta_messages

        + node.stats.home_availability_messages

        + node.stats.raw_command_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 buildHomeTopic(identity, mapping, stream) {

      return identity.site + "/home/" + identity.location + "/" + mapping.targetCapability + "/" + identity.deviceId + "/" + 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.home.v1",

        payload_profile: mapping.payloadProfile || "scalar",

        stream_payload_profiles: mapping.writable

          ? { value: "scalar", last: "envelope", set: "scalar" }

          : { 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.targetCapability),

        tags: ["zigbee2mqtt", "smart-socket", identity.model.toLowerCase(), "home"],

        historian: {

          enabled: !!mapping.historianEnabled,

          mode: mapping.historianMode

        }

      };

      if (mapping.unit) payload.unit = mapping.unit;

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

      if (mapping.writable) {

        payload.writable = true;

        payload.set_topic = buildHomeTopic(identity, mapping, "set");

      }

      return payload;

    }

    function enqueueHomeMeta(messages, identity, mapping) {

      var topic = buildHomeTopic(identity, mapping, "meta");

      var payload = buildMetaPayload(identity, mapping);

      if (!shouldPublishRetained("meta:" + topic, payload)) return;

      messages.push(makePublishMsg(topic, payload, true));

      noteMessage("meta_messages");

    }

    function enqueueHomeAvailability(messages, identity, mapping, online) {

      var topic = buildHomeTopic(identity, mapping, "availability");

      var payload = online ? "online" : "offline";

      if (!shouldPublishRetained("availability:" + topic, payload)) return;

      messages.push(makePublishMsg(topic, payload, true));

      noteMessage("home_availability_messages");

    }

    function enqueueHomeLast(messages, identity, mapping, value, observation) {

      var topic = buildHomeTopic(identity, mapping, "last");

      var payload = buildLastPayload(value, observation);

      if (!shouldPublishRetained("last:" + topic, payload)) return;

      messages.push(makePublishMsg(topic, payload, true));

      noteMessage("last_messages");

    }

    function enqueueHomeValue(messages, identity, mapping, value) {

      var topic = buildHomeTopic(identity, mapping, "value");

      if (!shouldPublishLive("value:" + topic, value)) return;

      messages.push(makePublishMsg(topic, value, false));

      noteMessage("home_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,

        command_inputs: node.stats.command_inputs,

        devices_detected: node.stats.devices_detected,

        translated_messages: translatedMessageCount(),

        home_messages: node.stats.home_messages,

        last_messages: node.stats.last_messages,

        meta_messages: node.stats.meta_messages,

        home_availability_messages: node.stats.home_availability_messages,

        raw_command_messages: node.stats.raw_command_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,

        unknown_devices: node.stats.unknown_devices,

        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" || code === "unsupported_set") noteMessage("invalid_topics");

      else if (code === "payload_not_object" || code === "invalid_availability_payload" || code === "invalid_command_payload") noteMessage("invalid_payloads");

      else if (code === "no_mapped_fields") noteMessage("unmapped_messages");

      else if (code === "unknown_device") noteMessage("unknown_devices");

      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 parseSetTopic(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 !== 6) return null;

      if (tokens[1] !== "home") return null;

      if (tokens[3] !== "power" || tokens[5] !== "set") return null;

      return {

        site: toKebabCase(tokens[0], node.site || "unknown"),

        location: toKebabCase(tokens[2], "unknown"),

        capability: tokens[3],

        deviceId: toKebabCase(tokens[4], "socket")

      };

    }

    function buildIdentity(parsed) {

      return {

        model: parsed.model,

        site: parsed.site || node.site || "unknown",

        location: parsed.location || "unknown",

        deviceId: parsed.deviceId || parsed.model.toLowerCase(),

        sourceRef: parsed.sourceTopic,

        sourceTopic: parsed.sourceTopic,

        displayName: [parsed.location || "unknown", parsed.deviceId || parsed.model.toLowerCase()].join(" ")

      };

    }

    function noteDevice(identity) {

      var key = registryKey(identity.site, identity.location, identity.deviceId);

      if (!Object.prototype.hasOwnProperty.call(node.deviceRegistry, key)) {

        node.stats.devices_detected += 1;

      }

      node.deviceRegistry[key] = {

        site: identity.site,

        location: identity.location,

        deviceId: identity.deviceId,

        model: identity.model,

        sourceTopic: identity.sourceTopic,

        sourceRef: identity.sourceRef

      };

    }

    function lookupDevice(parsedSet) {

      return node.deviceRegistry[registryKey(parsedSet.site, parsedSet.location, parsedSet.deviceId)] || null;

    }

    function activeMappings(model, payloadObject) {

      var result = [];

      for (var i = 0; i < HOME_MAPPINGS.length; i++) {

        var mapping = HOME_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"].indexOf(keys[i]) < 0) return false;

      }

      return true;

    }

    function parsePowerCommand(payload) {

      var value = payload;

      var sourceTopicHint = "";

      if (value && typeof value === "object" && !Array.isArray(value)) {

        if (typeof value.source_topic === "string" && value.source_topic.trim()) sourceTopicHint = value.source_topic.trim();

        else if (typeof value.source_ref === "string" && value.source_ref.trim()) sourceTopicHint = value.source_ref.trim();

        if (Object.prototype.hasOwnProperty.call(value, "value")) value = value.value;

        else if (Object.prototype.hasOwnProperty.call(value, "power")) value = value.power;

        else if (Object.prototype.hasOwnProperty.call(value, "state")) value = value.state;

      }

      if (typeof value === "string" && value.trim().toLowerCase() === "toggle") {

        return {

          kind: "toggle",

          sourceTopicHint: sourceTopicHint

        };

      }

      var boolValue = asSwitchState(value);

      if (boolValue === null) return null;

      return {

        kind: "state",

        value: boolValue,

        sourceTopicHint: sourceTopicHint

      };

    }

    function statusText(prefix) {

      return [

        prefix || (node.subscriptionStarted ? "live" : "idle"),

        "in:" + node.stats.processed_inputs,

        "home:" + node.stats.home_messages,

        "set:" + node.stats.raw_command_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, rawCommandMessages, controlMessages, error) {

      send([

        publishMessages.length ? publishMessages : null,

        rawCommandMessages.length ? rawCommandMessages : 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, 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 rawCommandMessages = [];

        var controlMessages = [];

        var setTopic = parseSetTopic(msg.topic);

        if (setTopic) {

          node.stats.command_inputs += 1;

          enqueueAdapterAvailability(publishMessages, setTopic.site, true);

          var command = parsePowerCommand(msg.payload);

          if (!command) {

            enqueueError(publishMessages, setTopic.site, "invalid_command_payload", "Power set payload must be boolean, on/off, or toggle", msg.topic);

            enqueueDlq(publishMessages, setTopic.site, "invalid_command_payload", msg.topic, msg.payload);

            enqueueAdapterStats(publishMessages, setTopic.site, true);

            logIssue("warn", "invalid_command_payload", "Power set payload must be boolean, on/off, or toggle", msg, msg.payload);

            updateNodeStatus("yellow", "ring", "bad set");

            flush(send, done, publishMessages, rawCommandMessages, controlMessages);

            return;

          }

          var registryEntry = lookupDevice(setTopic);

          if (!registryEntry && command.sourceTopicHint) {

            var hinted = parseRawTopic(command.sourceTopicHint);

            if (hinted) {

              registryEntry = {

                site: hinted.site,

                location: hinted.location,

                deviceId: hinted.deviceId,

                model: hinted.model,

                sourceTopic: hinted.sourceTopic,

                sourceRef: hinted.sourceTopic

              };

            }

          }

          if (!registryEntry) {

            enqueueError(publishMessages, setTopic.site, "unknown_device", "No raw Zigbee2MQTT topic is known yet for this canonical power endpoint", msg.topic);

            enqueueDlq(publishMessages, setTopic.site, "unknown_device", msg.topic, msg.payload);

            enqueueAdapterStats(publishMessages, setTopic.site, true);

            logIssue("warn", "unknown_device", "No raw Zigbee2MQTT topic is known yet for this canonical power endpoint", msg, msg.payload);

            updateNodeStatus("yellow", "ring", "unknown device");

            flush(send, done, publishMessages, rawCommandMessages, controlMessages);

            return;

          }

          rawCommandMessages.push(makePublishMsg(

            registryEntry.sourceTopic + "/set",

            command.kind === "toggle" ? { state: "TOGGLE" } : { state: command.value ? "ON" : "OFF" },

            false

          ));

          noteMessage("raw_command_messages");

          enqueueAdapterStats(publishMessages, setTopic.site, false);

          updateNodeStatus("green", "dot", "set->z2m");

          flush(send, done, publishMessages, rawCommandMessages, controlMessages);

          return;

        }

        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 homebus 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 homebus adapter", msg, msg.payload);

          updateNodeStatus("yellow", "ring", "bad topic");

          flush(send, done, publishMessages, rawCommandMessages, controlMessages);

          return;

        }

        node.stats.raw_inputs += 1;

        var identity = buildIdentity(parsed);

        noteDevice(identity);

        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, rawCommandMessages, controlMessages);

            return;

          }

          var availabilityMappings = activeMappings(identity.model, null);

          for (var i = 0; i < availabilityMappings.length; i++) {

            enqueueHomeMeta(publishMessages, identity, availabilityMappings[i].mapping);

            enqueueHomeAvailability(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, rawCommandMessages, 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, rawCommandMessages, 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++) {

          enqueueHomeMeta(publishMessages, identity, mappings[j].mapping);

          enqueueHomeAvailability(publishMessages, identity, mappings[j].mapping, online);

          if (mappings[j].hasValue) {

            hasMappedValue = true;

            enqueueHomeLast(publishMessages, identity, mappings[j].mapping, mappings[j].value, observation);

            enqueueHomeValue(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 HomeBus 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 HomeBus 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, rawCommandMessages, 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-homebus", Z2MSmartSocketHomeBusNode);

};