/**
 * Device Monitor - Collects device snapshots and pushes to Home Assistant
 *
 * Features:
 *   1. Connects to Huawei router via SCRAM authentication
 *   2. Generates device snapshots (JSON), appends to log storage
 *   3. Supports single-run or continuous daemon mode
 *   4. Auto-rotates logs on first run each day
 *   5. Pushes device metrics to Home Assistant as sensors
 *
 * Usage:
 *   node device-monitor.js              # Single collection
 *   node device-monitor.js --daemon     # Continuous (every 5 min)
 *   node device-monitor.js --interval 3 # Custom interval (minutes)
 *   node device-monitor.js --local      # Write logs locally instead of SSH
 */

const { execSync, spawnSync } = require('child_process');
const fs = require('fs');
const path = require('path');
const http = require('http');
const https = require('https');

// Load .env from project root
const envPath = path.join(__dirname, '..', '.env');
if (fs.existsSync(envPath)) {
  const envContent = fs.readFileSync(envPath, 'utf8');
  envContent.split('\n').forEach((line) => {
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith('#')) return;
    const eqIdx = trimmed.indexOf('=');
    if (eqIdx > 0) {
      const key = trimmed.slice(0, eqIdx).trim();
      const val = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
      if (!process.env[key]) process.env[key] = val;
    }
  });
}

const {
  createRouterClient,
  parseActive,
} = require(path.join(__dirname, '..', 'lib', 'huawei-router'));
const {
  DeviceStateTracker,
  parseTrackedDevices,
  toPositiveInteger,
} = require(path.join(__dirname, '..', 'lib', 'device-tracker'));
const { formatUtc8 } = require(path.join(__dirname, '..', 'lib', 'time-utils'));
const { parseDailyCron } = require(path.join(__dirname, '..', 'lib', 'cron-utils'));
const { rotate } = require(path.join(__dirname, 'device-log-rotate'));

// ---------- Built-in Logger ----------

const LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
const currentLevel = LOG_LEVELS[process.env.LOG_LEVEL || 'info'] ?? 1;

const logger = {
  debug: (...args) => currentLevel <= 0 && console.log('[DEBUG]', ...args),
  info: (...args) => currentLevel <= 1 && console.log('[INFO]', ...args),
  warn: (...args) => currentLevel <= 2 && console.warn('[WARN]', ...args),
  error: (...args) => currentLevel <= 3 && console.error('[ERROR]', ...args),
  success: (...args) => currentLevel <= 1 && console.log('[OK]', ...args),
  title: (msg) => currentLevel <= 1 && console.log(`\n=== ${msg} ===\n`),
  divider: (ch = '-') => currentLevel <= 1 && console.log(ch.repeat(50)),
};

// ---------- Configuration ----------

const NAS_HOST = process.env.NAS_SSH_HOST || '';
const LOG_DIR = process.env.LOG_DIR || path.join(__dirname, '..', 'logs');
const RETAIN_DAYS = parseInt(process.env.LOG_RETAIN_DAYS || '7', 10);
const MONITOR_INTERVAL = parseInt(process.env.MONITOR_INTERVAL || '5', 10);
const HA_URL = process.env.HA_URL || '';
const HA_TOKEN = process.env.HA_TOKEN || '';
const USE_LOCAL_LOGS = !NAS_HOST;
const STATE_FILE =
  process.env.STATE_FILE || path.join(__dirname, '..', 'data', 'device-state.json');
const ONLINE_CONFIRMATIONS = toPositiveInteger(
  process.env.ONLINE_CONFIRMATIONS,
  1
);
const OFFLINE_CONFIRMATIONS = toPositiveInteger(
  process.env.OFFLINE_CONFIRMATIONS,
  3
);
const TRACKED_DEVICES_RAW = process.env.TRACKED_DEVICES || '';
const ROUTER_REDIAL_CRON = (process.env.ROUTER_REDIAL_CRON || '').trim();
const TRACKED_DEVICES = parseTrackedDevices(TRACKED_DEVICES_RAW);
const TRACKED_ENTRY_COUNT = TRACKED_DEVICES_RAW
  .split(',')
  .filter((entry) => entry.trim()).length;

if (TRACKED_ENTRY_COUNT !== TRACKED_DEVICES.length) {
  logger.warn(
    `Ignored ${TRACKED_ENTRY_COUNT - TRACKED_DEVICES.length} invalid or duplicate TRACKED_DEVICES entries`
  );
}

// ---------- CLI Argument Parser ----------

function parseArgs() {
  const args = process.argv.slice(2);
  const options = {
    daemon: false,
    interval: MONITOR_INTERVAL,
    local: USE_LOCAL_LOGS,
  };

  for (let i = 0; i < args.length; i++) {
    if (args[i] === '--daemon' || args[i] === '-d') {
      options.daemon = true;
    }
    if (args[i] === '--interval' && args[i + 1]) {
      options.interval = parseInt(args[i + 1], 10);
      i++;
    }
    if (args[i] === '--local') {
      options.local = true;
    }
  }

  return options;
}

// ---------- SSH Helpers (for remote NAS storage) ----------

function sshExec(command) {
  const fullCmd = `ssh ${NAS_HOST} "${command.replace(/"/g, '\\"')}"`;
  logger.debug(`SSH: ${command}`);
  return execSync(fullCmd, { encoding: 'utf8', timeout: 30000 }).trim();
}

function sshWrite(remotePath, data, append = false) {
  const op = append ? '>>' : '>';
  const cmd = `cat ${op} ${remotePath}`;
  const result = spawnSync('ssh', [NAS_HOST, cmd], {
    input: data,
    encoding: 'utf8',
    timeout: 30000,
  });

  if (result.status !== 0) {
    throw new Error(`SSH write failed: ${result.stderr}`);
  }
}

// ---------- Local Log Helpers ----------

function ensureLocalLogDir() {
  if (!fs.existsSync(LOG_DIR)) {
    fs.mkdirSync(LOG_DIR, { recursive: true });
  }
}

function writeLocalLog(filename, data, append = false) {
  const filepath = path.join(LOG_DIR, filename);
  if (append) {
    fs.appendFileSync(filepath, data, 'utf8');
  } else {
    fs.writeFileSync(filepath, data, 'utf8');
  }
}

// ---------- Log Writing ----------

function ensureLogDir(local) {
  if (local) {
    ensureLocalLogDir();
  } else {
    try {
      sshExec(`mkdir -p ${LOG_DIR}`);
      logger.debug(`Remote log dir ready: ${LOG_DIR}`);
    } catch (err) {
      throw new Error(`Cannot create remote log dir: ${err.message}`);
    }
  }
}

function writeSnapshotToLog(snapshot, local) {
  const date = snapshot.timestamp.slice(0, 10);
  const filename = `devices-${date}.jsonl`;
  const line = JSON.stringify(snapshot) + '\n';

  try {
    if (local) {
      writeLocalLog(filename, line, true);
    } else {
      sshWrite(`${LOG_DIR}/${filename}`, line, true);
    }
    logger.info(
      `Snapshot written: ${filename} (${snapshot.active}/${snapshot.total} online)`
    );
  } catch (err) {
    throw new Error(`Failed to write log: ${err.message}`);
  }
}

function writeLatestSnapshot(snapshot, local) {
  const content = JSON.stringify(snapshot, null, 2);

  try {
    if (local) {
      writeLocalLog('latest.json', content, false);
    } else {
      const filepath = `${LOG_DIR}/latest.json`;
      sshWrite(`${filepath}.tmp`, content, false);
      sshExec(`mv ${filepath}.tmp ${filepath}`);
    }
    logger.debug('latest.json updated');
  } catch (err) {
    logger.warn(`Failed to update latest.json: ${err.message}`);
  }
}

// ---------- Home Assistant Integration ----------

/**
 * Simple HA REST API POST helper
 */
function haPost(endpoint, body) {
  if (!HA_URL || !HA_TOKEN) {
    return Promise.resolve(null);
  }

  return new Promise((resolve, reject) => {
    const u = new URL(endpoint, HA_URL);
    const transport = u.protocol === 'https:' ? https : http;
    const data = JSON.stringify(body);
    const req = transport.request(
      {
        hostname: u.hostname,
        port: u.port || (u.protocol === 'https:' ? 443 : 8123),
        path: u.pathname + u.search,
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${HA_TOKEN}`,
          'Content-Length': Buffer.byteLength(data),
        },
        timeout: 10000,
      },
      (res) => {
        let buf = '';
        res.on('data', (chunk) => (buf += chunk));
        res.on('end', () => {
          if (res.statusCode < 200 || res.statusCode >= 300) {
            reject(
              new Error(
                `HA request failed: HTTP ${res.statusCode}${
                  buf ? ` - ${buf.slice(0, 200)}` : ''
                }`
              )
            );
            return;
          }
          resolve(buf);
        });
      }
    );

    req.on('timeout', () => {
      req.destroy();
      reject(new Error('HA request timed out'));
    });
    req.on('error', reject);
    req.write(data);
    req.end();
  });
}

function trackedEntityId(result) {
  const slug = result.label
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, '_')
    .replace(/^_+|_+$/g, '');
  return `sensor.network_device_${slug || result.mac.toLowerCase()}`;
}

async function pushMonitorHealth(state, attributes = {}) {
  if (!HA_URL || !HA_TOKEN) return;
  await haPost('/api/states/sensor.network_monitor_status', {
    state,
    attributes: {
      friendly_name: 'Network Monitor Status',
      icon: state === 'online' ? 'mdi:router-network' : 'mdi:router-network-off',
      last_updated: formatUtc8(new Date()),
      ...attributes,
    },
  });
}

/**
 * Push device metrics to HA sensors
 */
async function pushToHA(snapshot, trackedResults = []) {
  if (!HA_URL || !HA_TOKEN) {
    logger.debug('HA integration disabled (HA_URL or HA_TOKEN not set)');
    return;
  }

  const activeDevices = snapshot.devices.filter((d) => d.active);
  const wifiDevices = activeDevices.filter((d) =>
    ['2.4GHz', '5GHz'].includes(d.frequency)
  );
  const lanDevices = activeDevices.filter((d) => d.interface_type === 'LAN');

  // Sensor 1: Online device count
  await haPost('/api/states/sensor.network_devices_online', {
    state: String(activeDevices.length),
    attributes: {
      friendly_name: 'Network Devices Online',
      icon: 'mdi:devices',
      unit_of_measurement: 'devices',
      total: snapshot.total,
      wifi_count: wifiDevices.length,
      wifi_2g: wifiDevices.filter((d) => d.frequency === '2.4GHz').length,
      wifi_5g: wifiDevices.filter((d) => d.frequency === '5GHz').length,
      lan_count: lanDevices.length,
      last_updated: formatUtc8(snapshot.timestamp),
    },
  });

  // Sensor 2: Active device list (as JSON attribute)
  const deviceList = activeDevices.map((d) => ({
    name: d.name,
    ip: d.ip,
    mac: d.mac,
    type: d.frequency || d.interface_type,
    rssi: d.rssi,
    vendor: d.vendor,
    tx_mb: Math.round(d.tx_kb / 1024),
    rx_mb: Math.round(d.rx_kb / 1024),
  }));

  await haPost('/api/states/sensor.network_devices_list', {
    state: String(activeDevices.length),
    attributes: {
      friendly_name: 'Network Device List',
      icon: 'mdi:lan',
      devices: deviceList,
      last_updated: formatUtc8(snapshot.timestamp),
    },
  });

  // Sensor 3: Total traffic
  const totalTxGB = (
    activeDevices.reduce((s, d) => s + d.tx_kb, 0) /
    1024 /
    1024
  ).toFixed(2);
  const totalRxGB = (
    activeDevices.reduce((s, d) => s + d.rx_kb, 0) /
    1024 /
    1024
  ).toFixed(2);

  await haPost('/api/states/sensor.network_total_traffic', {
    state: String(totalTxGB),
    attributes: {
      friendly_name: 'Network Total Traffic (Upload)',
      icon: 'mdi:upload-network',
      unit_of_measurement: 'GB',
      tx_gb: totalTxGB,
      rx_gb: totalRxGB,
      last_updated: formatUtc8(snapshot.timestamp),
    },
  });

  // Sensor 4: Tracked devices. A missing HostInfo entry is an offline
  // observation; the confirmed state changes only after the configured number
  // of consecutive observations.
  for (const result of trackedResults) {
    const device = result.device;
    const entityId = trackedEntityId(result);
    await haPost(`/api/states/${entityId}`, {
      state: result.confirmed,
      attributes: {
        friendly_name: `${result.label} Network Status`,
        icon:
          result.confirmed === 'online' ? 'mdi:devices' : 'mdi:close-network',
        mac: device?.mac || result.displayMac,
        present_in_hostinfo: Boolean(device),
        observed_state: result.observed,
        confirmation_count: result.consecutive,
        state_changed: result.changed,
        ip: device?.ip || '',
        frequency: device?.frequency || '',
        rssi: device?.rssi ?? null,
        link_rate: device?.link_rate ?? null,
        tx_mb: device ? Math.round(device.tx_kb / 1024) : null,
        rx_mb: device ? Math.round(device.rx_kb / 1024) : null,
        access_record: device?.access_record || '',
        offline_record: device?.offline_record || '',
        last_seen: formatUtc8(result.lastSeenAt),
        last_changed: formatUtc8(result.lastChangedAt),
        last_updated: formatUtc8(snapshot.timestamp),
      },
    });
  }

  // A single event entity lets one HA automation handle every device listed in
  // TRACKED_DEVICES. Its unique state changes once for every confirmed event.
  for (const result of trackedResults.filter((item) => item.changed)) {
    const device = result.device;
    await haPost('/api/states/sensor.network_device_event', {
      state: `${snapshot.timestamp}|${result.mac}|${result.confirmed}`,
      attributes: {
        friendly_name: 'Network Device Event',
        icon:
          result.confirmed === 'online' ? 'mdi:lan-connect' : 'mdi:lan-disconnect',
        device_label: result.label,
        device_entity_id: trackedEntityId(result),
        event_type: result.confirmed,
        previous_state: result.previousConfirmed,
        event_time: formatUtc8(snapshot.timestamp),
        ip: device?.ip || '',
        mac: device?.mac || result.displayMac,
        frequency: device?.frequency || '',
        rssi: device?.rssi ?? null,
        tx_mb: device ? Math.round(device.tx_kb / 1024) : null,
        rx_mb: device ? Math.round(device.rx_kb / 1024) : null,
        access_record: device?.access_record || '',
        offline_record: device?.offline_record || '',
        last_seen: formatUtc8(result.lastSeenAt),
      },
    });
  }

  await pushMonitorHealth('online', {
    tracked_devices: trackedResults.length,
    collection_timestamp: formatUtc8(snapshot.timestamp),
  });
  logger.info('HA sensors updated');
}

// ---------- Collection Logic ----------

async function configureRouterRedial(router) {
  if (!ROUTER_REDIAL_CRON) {
    logger.debug('Router timed redial is unmanaged (ROUTER_REDIAL_CRON not set)');
    return;
  }

  const current = await router.getTimedRedial();
  const disabled = /^(off|disabled|false)$/i.test(ROUTER_REDIAL_CRON);
  const redialTime = disabled
    ? current.RedialTime || '05:00'
    : parseDailyCron(ROUTER_REDIAL_CRON);
  const enabled = !disabled;

  if (parseActive(current.Enable) === enabled && current.RedialTime === redialTime) {
    logger.info(
      enabled
        ? `Router timed redial already configured: daily at ${redialTime}`
        : 'Router timed redial already disabled'
    );
    return;
  }

  await router.setTimedRedial(enabled, redialTime);
  logger.success(
    enabled
      ? `Router timed redial configured: daily at ${redialTime}`
      : 'Router timed redial disabled'
  );
}

async function collectOnce(local, router, tracker) {
  const startTime = Date.now();

  const client = router || createRouterClient();
  const snapshot = await client.getDeviceSnapshot();
  const trackedResults = tracker
    ? tracker.observeAll(TRACKED_DEVICES, snapshot.devices, snapshot.timestamp)
    : [];

  ensureLogDir(local);
  writeSnapshotToLog(snapshot, local);
  writeLatestSnapshot(snapshot, local);

  try {
    await pushToHA(snapshot, trackedResults);
  } catch (err) {
    logger.warn(`HA push failed (collection still saved): ${err.message}`);
  }

  for (const result of trackedResults.filter((item) => item.changed)) {
    logger.info(
      `Tracked device changed: ${result.label} ${result.previousConfirmed} -> ${result.confirmed}`
    );
  }

  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
  logger.success(
    `Collection complete: ${snapshot.active} online / ${snapshot.total} total (${elapsed}s)`
  );

  return snapshot;
}

// ---------- Daily Log Rotation ----------

let lastRotateDate = null;

function maybeRotate() {
  const today = new Date().toISOString().slice(0, 10);
  if (lastRotateDate === today) return;

  logger.info('Running daily log rotation...');
  try {
    rotate({ days: RETAIN_DAYS, dryRun: false });
    lastRotateDate = today;
  } catch (err) {
    logger.warn(`Log rotation failed: ${err.message}`);
  }
}

// ---------- Daemon Mode ----------

async function runDaemon(intervalMinutes, local) {
  logger.title(`Device Monitor Daemon (interval: ${intervalMinutes} min)`);
  const router = createRouterClient();
  const tracker = new DeviceStateTracker({
    stateFile: STATE_FILE,
    onlineConfirmations: ONLINE_CONFIRMATIONS,
    offlineConfirmations: OFFLINE_CONFIRMATIONS,
    logger,
  });
  try {
    await configureRouterRedial(router);
  } catch (err) {
    logger.error(`Router timed redial configuration failed: ${err.message}`);
  }
  const intervalMs = intervalMinutes * 60 * 1000;

  // Wait after each completed collection instead of using setInterval, so a
  // slow router cannot cause overlapping login/query requests.
  while (true) {
    try {
      maybeRotate();
      await collectOnce(local, router, tracker);
    } catch (err) {
      logger.error('Collection failed:', err.message);
      try {
        await pushMonitorHealth('error', { error: err.message });
      } catch (haErr) {
        logger.warn(`Failed to update HA monitor status: ${haErr.message}`);
      }
    }
    logger.info(`Next collection in ${intervalMinutes} minutes`);
    await new Promise((resolve) => setTimeout(resolve, intervalMs));
  }
}

// ---------- Helpers ----------

function formatBytes(bytes) {
  if (bytes < 1024) return `${bytes} B`;
  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
  if (bytes < 1024 * 1024 * 1024)
    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
}

// ---------- Main ----------

async function main() {
  const options = parseArgs();

  if (options.daemon) {
    await runDaemon(options.interval, options.local);
  } else {
    try {
      const tracker = new DeviceStateTracker({
        stateFile: STATE_FILE,
        onlineConfirmations: ONLINE_CONFIRMATIONS,
        offlineConfirmations: OFFLINE_CONFIRMATIONS,
        logger,
      });
      const router = createRouterClient();
      await configureRouterRedial(router);
      const snapshot = await collectOnce(
        options.local,
        router,
        tracker
      );

      logger.divider('-');
      const activeDevices = snapshot.devices.filter((d) => d.active);
      const wifiDevices = activeDevices.filter((d) =>
        ['2.4GHz', '5GHz'].includes(d.frequency)
      );
      const lanDevices = activeDevices.filter(
        (d) => d.interface_type === 'LAN'
      );

      logger.info(`Online devices: ${activeDevices.length}`);
      logger.info(
        `  WiFi: ${wifiDevices.length} (2.4G: ${
          wifiDevices.filter((d) => d.frequency === '2.4GHz').length
        }, 5G: ${wifiDevices.filter((d) => d.frequency === '5GHz').length})`
      );
      logger.info(`  Wired: ${lanDevices.length}`);
      logger.info(
        `Total traffic: TX ${formatBytes(
          activeDevices.reduce((s, d) => s + d.tx_kb, 0) * 1024
        )}, RX ${formatBytes(
          activeDevices.reduce((s, d) => s + d.rx_kb, 0) * 1024
        )}`
      );
    } catch (err) {
      logger.error('Collection failed:', err.message);
      logger.debug(err.stack);
      process.exit(1);
    }
  }
}

if (require.main === module) {
  main().catch((err) => {
    logger.error('Unhandled error:', err.message);
    process.exit(1);
  });
}

module.exports = {
  collectOnce,
  configureRouterRedial,
  haPost,
  pushMonitorHealth,
  pushToHA,
  trackedEntityId,
};

'use strict';

const fs = require('fs');
const path = require('path');

const logDir = process.env.LOG_DIR || path.join(__dirname, '..', 'logs');
const latestFile = path.join(logDir, 'latest.json');
const intervalMinutes = Number.parseInt(process.env.MONITOR_INTERVAL || '5', 10);
const configuredMaxAge = Number.parseInt(
  process.env.HEALTHCHECK_MAX_AGE_MINUTES || '',
  10
);
const maxAgeMinutes =
  Number.isFinite(configuredMaxAge) && configuredMaxAge > 0
    ? configuredMaxAge
    : Math.max(intervalMinutes * 3 + 2, 5);

try {
  const stat = fs.statSync(latestFile);
  const ageMs = Date.now() - stat.mtimeMs;
  if (ageMs > maxAgeMinutes * 60 * 1000) {
    throw new Error(
      `latest.json is ${Math.round(ageMs / 60000)} minutes old (limit: ${maxAgeMinutes})`
    );
  }

  const snapshot = JSON.parse(fs.readFileSync(latestFile, 'utf8'));
  if (!snapshot.timestamp || !Array.isArray(snapshot.devices)) {
    throw new Error('latest.json has an unexpected format');
  }
} catch (err) {
  console.error(`Unhealthy: ${err.message}`);
  process.exit(1);
}

console.log('Healthy');

FROM node:22-alpine

ENV NODE_ENV=production
WORKDIR /app

# The monitor has no runtime dependencies outside Node.js built-ins.
COPY --chown=node:node package.json ./
COPY --chown=node:node lib ./lib
COPY --chown=node:node scripts ./scripts

RUN mkdir -p /app/logs /app/data \
    && chown -R node:node /app

USER node

HEALTHCHECK --interval=1m --timeout=5s --start-period=2m --retries=3 \
  CMD ["node", "scripts/container-healthcheck.js"]

CMD ["node", "scripts/device-monitor.js", "--daemon"]

services:
  huawei-router-monitor:
    build:
      context: .
      dockerfile: Dockerfile
    image: huawei-router-ha:local
    container_name: huawei-router-monitor
    restart: unless-stopped
    env_file:
      - .env
    environment:
      LOG_DIR: /app/logs
      STATE_FILE: /app/data/device-state.json
      TZ: Asia/Shanghai
    network_mode: host
    volumes:
      - router_logs:/app/logs
      - router_state:/app/data
    read_only: true
    tmpfs:
      - /tmp:size=16m,mode=1777
    security_opt:
      - no-new-privileges:true

volumes:
  router_logs:
  router_state:

# Router IP address (default: 192.168.3.1)
ROUTER_HOST=192.168.3.1
ROUTER_PASSWORD=<PASSWORD>
LOG_DIR=./logs

# These devices get individual HA sensors
TRACKED_DEVICES=AA:BB:CC:DD:EE:FF=DEVICE_1,11:22:33:44:55:EB=DEVICE_2

# HA base URL
HA_URL=http://192.168.3.2:8123
HA_TOKEN=ey**************

# Consecutive successful observations required before changing tracked-device
ONLINE_CONFIRMATIONS=1
OFFLINE_CONFIRMATIONS=3

# Collection interval in minutes
MONITOR_INTERVAL=1
STATE_FILE=./data/device-state.json

# Optional: configure the router firmware's native daily PPPoE reconnect.
# Standard 5-field cron is accepted, but this firmware supports one daily time
# only, so day/month/weekday must be '*'. Example: every day at 05:00.
# ROUTER_REDIAL_CRON=0 5 * * *
# Set to "off" to explicitly disable the router's existing timed redial.
ROUTER_REDIAL_CRON=30 3 * * *

{% set attr = trigger.to_state.attributes %}
{% if attr.event_type == 'online' %} IP：{{ attr.ip or '未知' }}
上线时间：{{ attr.access_record or attr.event_time or '未知' }}
频段：{{ attr.frequency or '有线或未知' }}
信号：{% if attr.rssi is not none and attr.rssi != 0 %}{{ attr.rssi }} dBm{% else %}未知{% endif %}
发送流量：{% if attr.tx_mb is not none %}{{ (attr.tx_mb / 1024) | round(2) }} GB{% else %}未知{% endif %}
接收流量：{% if attr.rx_mb is not none %}{{ (attr.rx_mb / 1024) | round(2) }} GB{% else %}未知{% endif %}
状态确认时间：{{ attr.event_time or '未知' }}
{% else %} 最后在线：{{ attr.last_seen or '未知' }}
路由器离线记录：{{ attr.offline_record or '未知' }}
状态确认时间：{{ attr.event_time or '未知' }} {% endif %}

{% set attr = trigger.to_state.attributes %} {% if attr.event_type == 'offline' %}
  [{{ attr.device_label }}] [🔴 Down]
{% else %}
  [{{ attr.device_label }}] [✅ Up]
{% endif %}

华为 SCRAM 登录
    ↓
HostInfo 采集
    ↓
状态解析与 MAC 匹配
    ↓
连续观察防抖
    ↓
状态持久化
    ↓
HA 设备实体与公共事件实体
    ↓
Gotify 通知
    ↓
Docker 长期运行与健康检查