module.exports = function(RED) {

  function Z2MZG204ZVHomeBusNode(config) {

    RED.nodes.createNode(this, config);

    var node = this;

    node.adapterId = "z2m-zg-204zv";

    node.sourceTopic = "zigbee2mqtt/ZG-204ZV/#";

    node.subscriptionStarted = false;

    node.startTimer = null;

    node.legacyRoom = normalizeToken(config.mqttRoom);

    node.legacySensor = normalizeToken(config.mqttSensor);

    node.legacyBus = normalizeToken(config.mqttBus);

    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;

    node.batteryType = normalizeToken(config.batteryType).toLowerCase() || "alkaline";

    var CAPABILITY_MAPPINGS = [

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",

        sourceFields: ["presence", "occupancy"],

        targetBus: "home",

        targetCapability: "motion",

        core: true,

        stream: "value",

        payloadProfile: "scalar",

        dataType: "boolean",

        historianMode: "event",

        historianEnabled: true,

        applies: function(payload) {

          return readNumber(payload, "fading_time") === 0;

        },

        read: function(payload) {

          return readBool(payload, this.sourceFields);

        }

      },

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",

        sourceFields: ["presence", "occupancy"],

        targetBus: "home",

        targetCapability: "presence",

        core: true,

        stream: "value",

        payloadProfile: "scalar",

        dataType: "boolean",

        historianMode: "state",

        historianEnabled: true,

        applies: function(payload) {

          var fadingTime = readNumber(payload, "fading_time");

          return fadingTime === undefined || fadingTime !== 0;

        },

        read: function(payload) {

          return readBool(payload, this.sourceFields);

        }

      },

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",

        sourceFields: ["temperature"],

        targetBus: "home",

        targetCapability: "temperature",

        core: true,

        stream: "value",

        payloadProfile: "scalar",

        dataType: "number",

        unit: "C",

        precision: 0.1,

        historianMode: "sample",

        historianEnabled: true,

        read: function(payload) {

          return readNumber(payload, this.sourceFields[0]);

        }

      },

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",

        sourceFields: ["humidity"],

        targetBus: "home",

        targetCapability: "humidity",

        core: true,

        stream: "value",

        payloadProfile: "scalar",

        dataType: "number",

        unit: "%",

        precision: 1,

        historianMode: "sample",

        historianEnabled: true,

        read: function(payload) {

          return readNumber(payload, this.sourceFields[0]);

        }

      },

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",

        sourceFields: ["illuminance"],

        targetBus: "home",

        targetCapability: "illuminance",

        core: true,

        stream: "value",

        payloadProfile: "scalar",

        dataType: "number",

        unit: "lx",

        precision: 1,

        historianMode: "sample",

        historianEnabled: true,

        read: function(payload) {

          return readNumber(payload, this.sourceFields[0]);

        }

      },

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<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 translateBatteryLevel(value);

        }

      },

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<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 = translateBatteryLevel(readNumber(payload, this.sourceFields[2]));

          if (battery === undefined) return undefined;

          return battery <= node.batteryLowThreshold;

        }

      },

      {

        sourceSystem: "zigbee2mqtt",

        sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<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));

    }

    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 undefined;

      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 translateBatteryLevel(rawValue) {

      if (rawValue === undefined) return undefined;

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

        }

        if (tokens.length >= 5 && tokens[4].toLowerCase() === "availability") {

          result.location = tokens[2];

          result.deviceId = tokens[3];

          result.friendlyName = tokens.slice(1, 4).join("/");

          result.isAvailabilityTopic = true;

          return result;

        }

        if (tokens.length >= 4) {

          result.location = tokens[2];

          result.deviceId = tokens[3];

          result.friendlyName = tokens.slice(1, 4).join("/");

          return result;

        }

        result.friendlyName = tokens.slice(1).join("/");

        result.deviceId = tokens[1];

        result.isAvailabilityTopic = tokens.length >= 3 && tokens[tokens.length - 1].toLowerCase() === "availability";

        return result;

      }

      if (tokens.length >= 5 && tokens[1].toLowerCase() === "home") {

        result.site = tokens[0];

        result.location = tokens[2];

        result.deviceId = tokens[4];

        result.isAvailabilityTopic = tokens.length >= 6 && tokens[5].toLowerCase() === "availability";

        return result;

      }

      if (tokens.length >= 4) {

        result.site = tokens[0];

        result.location = tokens[2];

        result.deviceId = tokens[3];

      } else if (tokens.length >= 2) {

        result.location = tokens[tokens.length - 2];

        result.deviceId = tokens[tokens.length - 1];

      } else if (tokens.length === 1) {

        result.deviceId = tokens[0];

      }

      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"]))

        || "";

      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

        || "ZG-204ZV";

      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-zg-204zv";

      return {

        site: toKebabCase(siteRaw, "unknown"),

        location: toKebabCase(locationRaw, "unknown"),

        deviceId: toKebabCase(deviceRaw, toKebabCase(inferred.deviceType, "zg-204zv")),

        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/ZG-204ZV/<site>/<location>/<device_id>[/availability]"

        };

      }

      if (tokens[0].toLowerCase() !== "zigbee2mqtt" || tokens[1].toLowerCase() !== "zg-204zv") {

        return {

          valid: false,

          reason: "Topic must start with zigbee2mqtt/ZG-204ZV"

        };

      }

      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 (node.stats.invalid_topics > 0) parts.push("topic " + node.stats.invalid_topics);

      if (node.stats.invalid_messages > 0) parts.push("msg " + node.stats.invalid_messages);

      if (node.stats.invalid_payloads > 0) parts.push("payload " + node.stats.invalid_payloads);

      if (node.stats.unmapped_messages > 0) parts.push("unmapped " + node.stats.unmapped_messages);

      if (node.stats.adapter_exceptions > 0) parts.push("exc " + node.stats.adapter_exceptions);

      if (node.stats.dlq > 0) parts.push("dlq " + node.stats.dlq);

      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 shouldPublishLiveValue(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 humanizeCapability(capability) {

      return capability.replace(/_/g, " ").replace(/\b[a-z]/g, function(ch) { return ch.toUpperCase(); });

    }

    function resolveObservation(msg, payloadObject) {

      var safeMsg = (msg && typeof msg === "object") ? msg : {};

      var observedAtRaw = pickFirstPath(payloadObject, [

        "observed_at",

        "observedAt",

        "timestamp",

        "time",

        "ts",

        "last_seen",

        "lastSeen",

        "device.last_seen",

        "device.lastSeen"

      ]) || pickFirstPath(safeMsg, [

        "observed_at",

        "observedAt",

        "timestamp",

        "time",

        "ts"

      ]);

      var observedAt = toIsoTimestamp(observedAtRaw);

      if (observedAt) {

        return {

          observedAt: observedAt,

          quality: "good"

        };

      }

      return {

        observedAt: new Date().toISOString(),

        quality: "estimated"

      };

    }

    function buildMetaPayload(identity, mapping) {

      var payload = {

        schema_ref: "mqbus.home.v1",

        payload_profile: mapping.payloadProfile,

        stream_payload_profiles: {

          value: "scalar",

          last: "envelope"

        },

        data_type: mapping.dataType,

        adapter_id: node.adapterId,

        source: mapping.sourceSystem,

        source_ref: identity.sourceRef,

        source_topic: identity.sourceTopic,

        display_name: identity.displayName + " " + humanizeCapability(mapping.targetCapability),

        tags: [mapping.sourceSystem, "zg-204zv", mapping.targetBus],

        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 buildLastPayload(value, observation) {

      var payload = {

        value: value,

        observed_at: observation.observedAt

      };

      if (observation.quality && observation.quality !== "good") payload.quality = observation.quality;

      return payload;

    }

    function noteMessage(kind) {

      if (!Object.prototype.hasOwnProperty.call(node.stats, kind)) return;

      node.stats[kind] += 1;

    }

    function noteErrorKind(code) {

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

      } else if (code === "adapter_exception") {

        noteMessage("adapter_exceptions");

      }

    }

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

        if (serialized.length > 180) return serialized.slice(0, 177) + "...";

        return serialized;

      } catch (err) {

        return String(value);

      }

    }

    function logIssue(level, code, reason, msg, rawPayload) {

      var parts = [

        "[" + node.adapterId + "]",

        code + ":",

        reason

      ];

      var sourceTopic = msg && typeof msg === "object" ? normalizeToken(msg.topic) : "";

      if (sourceTopic) parts.push("topic=" + sourceTopic);

      if (rawPayload !== undefined) parts.push("payload=" + summarizeForLog(rawPayload));

      var text = parts.join(" ");

      if (level === "error") {

        node.error(text, msg);

        return;

      }

      node.warn(text);

    }

    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 (!shouldPublishLiveValue("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,

        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,

        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,

        adapter_exceptions: node.stats.adapter_exceptions,

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

      noteErrorKind(code);

      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 activeMappings(payloadObject) {

      var result = [];

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

        var mapping = CAPABILITY_MAPPINGS[i];

        if (typeof mapping.applies === "function" && !mapping.applies(payloadObject)) continue;

        var value = payloadObject ? mapping.read(payloadObject) : undefined;

        var seen = mapping.core || node.seenOptionalCapabilities[mapping.targetCapability];

        if (value !== undefined) node.seenOptionalCapabilities[mapping.targetCapability] = true;

        if (mapping.core || seen || value !== 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;

      var active = true;

      if (typeof payloadObject.availability === "string") active = payloadObject.availability.trim().toLowerCase() !== "offline";

      if (typeof payloadObject.online === "boolean") active = payloadObject.online;

      return active;

    }

    function flush(send, done, controlMessages, publishMessages, error) {

      send([

        publishMessages.length ? publishMessages : null,

        controlMessages.length ? controlMessages : null

      ]);

      if (done) done(error);

    }

    function startSubscriptions() {

      if (node.subscriptionStarted) return;

      node.subscriptionStarted = true;

      node.send([null, makeSubscribeMsg(node.sourceTopic)]);

      updateNodeStatus("grey", "dot", "subscribed");

    }

    node.on("input", function(msg, send, done) {

      send = send || function() { node.send.apply(node, arguments); };

      node.stats.processed_inputs += 1;

      try {

        var controlMessages = [];

        if (!msg || typeof msg !== "object") {

          var invalidMessages = [];

          var invalidSite = resolveIdentity({}, null).site;

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

          return;

        }

        var payload = msg.payload;

        var payloadObject = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;

        var identity = resolveIdentity(msg, payloadObject);

        var observation = resolveObservation(msg, payloadObject);

        var messages = [];

        var topicValidation = validateInboundTopic(msg.topic);

        var availabilityValue = null;

        enqueueAdapterAvailability(messages, identity.site, true);

        if (!topicValidation.valid) {

          enqueueError(messages, identity.site, "invalid_topic", topicValidation.reason, msg.topic);

          enqueueDlq(messages, identity.site, "invalid_topic", msg.topic, payload);

          enqueueAdapterStats(messages, identity.site, true);

          logIssue("warn", "invalid_topic", topicValidation.reason, msg, payload);

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

          flush(send, done, controlMessages, messages);

          return;

        }

        identity.isAvailabilityTopic = topicValidation.isAvailabilityTopic;

        noteDevice(identity);

        var isAvailabilityTopic = topicValidation.isAvailabilityTopic;

        if (isAvailabilityTopic) {

          availabilityValue = asBool(payload);

          if (availabilityValue === null) {

            enqueueError(messages, identity.site, "invalid_availability_payload", "Availability payload must be online/offline or boolean", msg.topic);

            enqueueDlq(messages, identity.site, "invalid_availability_payload", msg.topic, payload);

            enqueueAdapterStats(messages, identity.site, true);

            logIssue("warn", "invalid_availability_payload", "Availability payload must be online/offline or boolean", msg, payload);

            updateNodeStatus("yellow", "ring", "invalid availability");

            flush(send, done, controlMessages, messages);

            return;

          }

        } else if (!payloadObject) {

          enqueueError(messages, identity.site, "payload_not_object", "Telemetry payload must be an object", msg.topic);

          enqueueDlq(messages, identity.site, "payload_not_object", msg.topic, payload);

          enqueueAdapterStats(messages, identity.site, true);

          logIssue("warn", "payload_not_object", "Telemetry payload must be an object", msg, payload);

          updateNodeStatus("yellow", "ring", "payload not object");

          flush(send, done, controlMessages, messages);

          return;

        }

        var online = resolveOnlineState(payloadObject, availabilityValue);

        var mappings = activeMappings(payloadObject);

        var hasMappedValue = false;

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

          if (mappings[i].hasValue) {

            hasMappedValue = true;

            break;

          }

        }

        var hasAvailabilityField = isAvailabilityTopic || (payloadObject && (typeof payloadObject.availability === "string" || typeof payloadObject.online === "boolean"));

        if (!hasMappedValue && !hasAvailabilityField) {

          enqueueError(messages, identity.site, "no_mapped_fields", "Payload did not contain any supported ZG-204ZV fields", msg.topic);

          enqueueDlq(messages, identity.site, "no_mapped_fields", msg.topic, payloadObject);

          logIssue("warn", "no_mapped_fields", "Payload did not contain any supported ZG-204ZV fields", msg, payloadObject);

        }

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

          enqueueHomeMeta(messages, identity, mappings[i].mapping);

          enqueueHomeAvailability(messages, identity, mappings[i].mapping, online);

          if (mappings[i].hasValue) {

            enqueueHomeLast(messages, identity, mappings[i].mapping, mappings[i].value, observation);

            enqueueHomeValue(messages, identity, mappings[i].mapping, mappings[i].value);

          }

        }

        enqueueAdapterStats(messages, identity.site, false);

        if (!hasMappedValue && !hasAvailabilityField) {

          updateNodeStatus("yellow", "ring", "unmapped");

        } else {

          updateNodeStatus(online ? "green" : "yellow", online ? "dot" : "ring", online ? null : "offline");

        }

        flush(send, done, controlMessages, messages);

      } catch (err) {

        var errorPayload = msg && msg.payload && typeof msg.payload === "object" && !Array.isArray(msg.payload) ? msg.payload : null;

        var errorIdentity = resolveIdentity(msg, errorPayload);

        noteDevice(errorIdentity);

        var errorMessages = [];

        enqueueAdapterAvailability(errorMessages, errorIdentity.site, true);

        enqueueError(errorMessages, errorIdentity.site, "adapter_exception", err.message, msg && msg.topic);

        enqueueAdapterStats(errorMessages, errorIdentity.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-zg-204zv-homebus", Z2MZG204ZVHomeBusNode);

};