server.cjs

"use strict";

const os = require("os");
const http = require("http");
const https = require("https");
const path = require("path");
const smartCastApps = require("./apps.json");
const express = require("express");
const cors = require("cors");
const { Client: SsdpClient } = require("node-ssdp");
const VizioSmartCast = require("vizio-smart-cast");
const {
  ensureConfigFileExists,
  ensureConfigFromEnvIfPresent,
  loadConfig,
  saveConfig,
  clearConfig,
} = require("./lib/config");

const PORT = parseInt(process.env.PORT || "3000", 10);
const SMARTCAST_PORT = 7345;
const DISCOVERY_TIMEOUT = parseInt(
  process.env.VIZMOTE_DISCOVERY_TIMEOUT || "4500",
  10,
);
const FAST_DISCOVERY_TIMEOUT = parseInt(
  process.env.VIZMOTE_FAST_DISCOVERY_TIMEOUT || "1800",
  10,
);
const SUBNET_PROBE_TIMEOUT = 900;
const SUBNET_PROBE_CONCURRENCY = 32;
const ASTRO_DIST_DIR = path.join(__dirname, "dist");
const APP_BRAND_METADATA = {
  "Apple TV+": {
    brandColor: "#ffffff",
  },
  "CBS News": {
    brandColor: "#0f4c81",
  },
  DAZN: {
    brandColor: "#f1f1f1",
  },
  "Disney+": {
    brandColor: "#113ccf",
    logoUrl: "https://commons.wikimedia.org/wiki/Special:Redirect/file/Disney%2B_logo.svg",
  },
  "HBO Max": {
    brandColor: "#7f3cff",
  },
  Hulu: {
    brandColor: "#1ce783",
    logoUrl: "https://commons.wikimedia.org/wiki/Special:Redirect/file/Hulu_Logo.svg",
  },
  iHeartRadio: {
    brandColor: "#c6002b",
  },
  Netflix: {
    brandColor: "#e50914",
  },
  NBC: {
    brandColor: "#f5bd00",
  },
  Pandora: {
    brandColor: "#3668ff",
  },
  Peacock: {
    brandColor: "#f5f5f5",
  },
  Paramount: {
    brandColor: "#0057ff",
  },
  "Paramount+": {
    brandColor: "#0057ff",
  },
  PBS: {
    brandColor: "#ffffff",
  },
  "PBS Kids": {
    brandColor: "#7cd220",
  },
  Plex: {
    brandColor: "#e5a00d",
  },
  "Prime Video": {
    brandColor: "#00a8e1",
  },
  TikTok: {
    brandColor: "#25f4ee",
  },
  Tubi: {
    brandColor: "#7c3aed",
  },
  Vudu: {
    brandColor: "#1f7bf2",
  },
  "WatchFree+": {
    brandColor: "#ffd54a",
  },
  XUMO: {
    brandColor: "#6d28d9",
  },
  YouTube: {
    brandColor: "#ff0033",
  },
  "YouTube TV": {
    brandColor: "#ff0000",
  },
  "Haystack TV": {
    brandColor: "#7c3aed",
  },
  "Haystack News": {
    brandColor: "#7c3aed",
  },
  fuboTV: {
    brandColor: "#f8f8f8",
  },
  "discovery+": {
    brandColor: "#3b82f6",
  },
};

const FEATURED_APP_NAMES = [
  "YouTube",
  "Netflix",
  "Hulu",
  "Disney+",
  "Prime Video",
  "Apple TV+",
  "Max",
  "HBO Max",
  "Paramount+",
  "Peacock",
  "Plex",
  "YouTube TV",
  "Tubi",
  "Pluto TV",
  "XUMO",
  "WatchFree+",
  "CBS News",
  "NBC",
  "DAZN",
  "Pandora",
  "PBS",
  "PBS Kids",
  "TikTok",
  "Vudu",
  "fuboTV",
  "discovery+",
  "iHeartRadio",
  "Haystack TV",
];
const EQUIVALENT_APP_NAMESPACES = new Set([2, 4]);

let tv = null;
let currentIp = null;
let pending = {
  tv: null,
  ip: null,
};

function slugifyAppName(value) {
  return String(value || "")
    .trim()
    .toLowerCase()
    .replace(/&/g, " and ")
    .replace(/\+/g, " plus ")
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "");
}

function getAppMessage(value) {
  if (value == null || value === "") return "";
  if (typeof value === "object") return value;

  const text = String(value).trim();
  if (!text) return "";

  if ((text.startsWith("{") && text.endsWith("}")) || (text.startsWith("[") && text.endsWith("]"))) {
    try {
      return JSON.parse(text);
    } catch (error) {
      return text;
    }
  }

  return text;
}

function getAppInitials(name) {
  const words = String(name || "")
    .replace(/\+/g, " + ")
    .split(/[^A-Za-z0-9+]+/)
    .filter(Boolean);

  if (!words.length) return "APP";
  if (words.length === 1) return words[0].slice(0, 3).toUpperCase();
  return words
    .slice(0, 3)
    .map((word) => word[0])
    .join("")
    .toUpperCase();
}

function buildAppDefinitions() {
  const built = [];
  const seen = new Set();

  for (const app of smartCastApps || []) {
    const name = String((app && app.name) || "").trim();
    const config = app && Array.isArray(app.config) ? app.config[0] : null;
    const countries = Array.isArray(app && app.country) ? app.country : [];

    if (!name || !config || !config.APP_ID || seen.has(name)) continue;
    if (countries.length && !countries.includes("*") && !countries.includes("usa")) continue;

    const id = slugifyAppName(name);
    const metadata = APP_BRAND_METADATA[name] || {};
    const message = getAppMessage(config.MESSAGE);

    built.push({
      id,
      name,
      route: `/api/app/${id}`,
      brandColor: metadata.brandColor || "#8f4cff",
      initials: getAppInitials(name),
      logoUrl: metadata.logoUrl || "",
      appId: String(config.APP_ID),
      nameSpace: Number(config.NAME_SPACE),
      message,
      featured: FEATURED_APP_NAMES.includes(name),
    });

    seen.add(name);
  }

  return built.sort((left, right) => {
    const leftFeatured = left.featured ? 0 : 1;
    const rightFeatured = right.featured ? 0 : 1;
    if (leftFeatured !== rightFeatured) return leftFeatured - rightFeatured;
    return left.name.localeCompare(right.name);
  });
}

const APP_DEFINITIONS = buildAppDefinitions();

function requestText(url, timeout = 2500) {
  return new Promise((resolve, reject) => {
    const target = new URL(url);
    const transport = target.protocol === "https:" ? https : http;
    const options = {
      protocol: target.protocol,
      hostname: target.hostname,
      port: target.port,
      path: `${target.pathname}${target.search}`,
      method: "GET",
      timeout,
      headers: {
        Accept: "application/xml,text/xml,application/json,text/plain,*/*",
      },
    };

    if (target.protocol === "https:") {
      options.rejectUnauthorized = false;
    }

    const req = transport.request(options, (res) => {
      if (
        res.statusCode &&
        res.statusCode >= 300 &&
        res.statusCode < 400 &&
        res.headers.location
      ) {
        const nextUrl = new URL(res.headers.location, url).toString();
        res.resume();
        resolve(requestText(nextUrl, timeout));
        return;
      }

      if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
        res.resume();
        reject(new Error(`HTTP ${res.statusCode || "unknown"}`));
        return;
      }

      let body = "";
      res.setEncoding("utf8");
      res.on("data", (chunk) => {
        body += chunk;
      });
      res.on("end", () => resolve(body));
    });

    req.on("timeout", () => {
      req.destroy(new Error("Request timed out"));
    });
    req.on("error", reject);
    req.end();
  });
}

function decodeXmlEntities(value) {
  return String(value || "")
    .replace(/&amp;/g, "&")
    .replace(/&lt;/g, "<")
    .replace(/&gt;/g, ">")
    .replace(/&quot;/g, '"')
    .replace(/&#39;|&apos;/g, "'");
}

function getXmlTag(xml, tagName) {
  const match = String(xml || "").match(
    new RegExp(`<${tagName}(?:\\s[^>]*)?>([\\s\\S]*?)</${tagName}>`, "i"),
  );
  return match ? decodeXmlEntities(match[1].trim()) : "";
}

function normalizeDevice(device, source) {
  if (!device || !device.ip) return null;
  const normalizedModel = String(device.model || "").trim();
  return {
    ip: String(device.ip).trim(),
    name: String(device.name || "Vizio TV").trim() || "Vizio TV",
    model: isGenericModel(normalizedModel) ? "" : normalizedModel,
    manufacturer:
      String(device.manufacturer || "VIZIO").trim().toUpperCase() || "VIZIO",
    source,
  };
}

function isGenericName(value) {
  return !value || /^vizio tv$/i.test(String(value).trim());
}

function isGenericModel(value) {
  return !value || /^unknown model$/i.test(String(value).trim());
}

function mergeDevices(...collections) {
  const merged = new Map();

  for (const collection of collections) {
    for (const rawDevice of collection || []) {
      const device = rawDevice && rawDevice.ip ? rawDevice : null;
      if (!device) continue;

      const existing = merged.get(device.ip);
      if (!existing) {
        merged.set(device.ip, { ...device });
        continue;
      }

      merged.set(device.ip, {
        ...existing,
        name:
          !isGenericName(device.name) || isGenericName(existing.name)
            ? device.name
            : existing.name,
        model:
          !isGenericModel(device.model) || isGenericModel(existing.model)
            ? device.model
            : existing.model,
        manufacturer: device.manufacturer || existing.manufacturer || "VIZIO",
        source:
          existing.source && existing.source !== device.source
            ? `${existing.source},${device.source}`
            : existing.source || device.source,
      });
    }
  }

  return Array.from(merged.values()).sort((a, b) =>
    `${a.name || ""}${a.model || ""}${a.ip || ""}`.localeCompare(
      `${b.name || ""}${b.model || ""}${b.ip || ""}`,
    ),
  );
}

function logServerError(scope, error) {
  const message = error && error.message ? error.message : String(error);
  console.error(`[VizMote] ${scope}: ${message}`);
}

function normalizeCompareValue(value) {
  return String(value || "").trim().toLowerCase();
}

function ensureSmartCastSuccess(response, fallbackMessage) {
  const result =
    response && response.STATUS && response.STATUS.RESULT
      ? String(response.STATUS.RESULT).trim().toUpperCase()
      : "";

  if (result && result !== "SUCCESS") {
    const detail =
      response && response.STATUS && response.STATUS.DETAIL
        ? String(response.STATUS.DETAIL).trim()
        : fallbackMessage;
    throw new Error(detail || fallbackMessage || "SmartCast command failed");
  }

  return response;
}

function getCurrentInputValue(payload) {
  if (!payload || !Array.isArray(payload.ITEMS) || !payload.ITEMS[0]) {
    return "";
  }

  const item = payload.ITEMS[0];
  return String(item.VALUE || item.NAME || item.CNAME || "").trim();
}

function getRequestedInputName(requested) {
  return [requested.customName, requested.label, requested.name, requested.id].find(
    (candidate) => String(candidate || "").trim(),
  ) || "";
}

function mapCurrentInputLabel(currentValue, items) {
  const normalizedCurrent = normalizeCompareValue(currentValue);
  const match = (items || []).find((item) => {
    const builtInName = String((item && item.NAME) || "").trim();
    const customName =
      item &&
      item.VALUE &&
      typeof item.VALUE === "object" &&
      item.VALUE.NAME
        ? String(item.VALUE.NAME).trim()
        : "";
    const id = String((item && item.CNAME) || "").trim();

    return [builtInName, customName, id].some(
      (candidate) =>
        candidate && normalizeCompareValue(candidate) === normalizedCurrent,
    );
  });

  if (!match) {
    return currentValue;
  }

  const customName =
    match.VALUE &&
    typeof match.VALUE === "object" &&
    match.VALUE.NAME
      ? String(match.VALUE.NAME).trim()
      : "";

  return customName || String(match.NAME || "").trim() || currentValue;
}

function normalizeInputCandidateValue(value) {
  return String(value || "").trim();
}

function normalizeInputIdentity(value) {
  return normalizeCompareValue(value).replace(/[^a-z0-9]+/g, "");
}

function getInputAliases(input) {
  const aliases = new Set();
  const candidates = [
    input && input.id,
    input && input.name,
    input && input.label,
    input && input.customName,
    input && input.raw && input.raw.CNAME,
    input && input.raw && input.raw.NAME,
  ];

  if (Array.isArray(input && input.valuesToTry)) {
    candidates.push(...input.valuesToTry);
  }

  for (const candidate of candidates) {
    const normalized = normalizeInputIdentity(candidate);
    if (normalized) aliases.add(normalized);
  }

  return Array.from(aliases);
}

function buildExtendedInputCandidatesFromDevices(payload) {
  const items = getPayloadItems(payload);
  const candidates = [];

  for (const item of items) {
    if (normalizeCompareValue(item && item.CNAME) !== "current_inputs" || !Array.isArray(item && item.VALUE)) {
      continue;
    }

    for (const entry of item.VALUE) {
      const cname = normalizeInputCandidateValue(entry && entry.CNAME);
      const builtInName = normalizeInputCandidateValue(entry && entry.NAME);
      const customName = normalizeInputCandidateValue(entry && entry.CUSTOM_NAME);
      const valuesToTry = [customName, builtInName, cname].filter(Boolean);
      if (!valuesToTry.length) continue;

      candidates.push({
        id: cname || builtInName || customName,
        name: builtInName || customName || cname,
        label: customName || builtInName || cname,
        customName,
        source: "smartcast-current-inputs",
        visible:
          entry && typeof entry.VISIBLE === "boolean"
            ? entry.VISIBLE
            : String(entry && entry.VISIBLE).trim().toUpperCase() === "TRUE",
        enabled:
          entry && typeof entry.ENABLED === "boolean"
            ? entry.ENABLED
            : String(entry && entry.ENABLED).trim().toUpperCase() === "TRUE",
        inputType: entry && entry.INPUT_TYPE != null ? Number(entry.INPUT_TYPE) : null,
        valuesToTry,
        raw: entry,
      });
    }
  }

  return candidates;
}

function getReadableValue(value) {
  if (value == null) return "";
  if (typeof value === "object") {
    if (value.BSSID || value.SSID || value.NAME || value.BAND) {
      return Object.entries(value)
        .filter(([, entryValue]) => entryValue != null && entryValue !== "")
        .slice(0, 4)
        .map(([key, entryValue]) => `${key}: ${getReadableValue(entryValue)}`)
        .join(" · ");
    }
    if (value.NAME) return String(value.NAME).trim();
    if (Array.isArray(value)) return value.map((entry) => getReadableValue(entry)).filter(Boolean).join(", ");

    try {
      return JSON.stringify(value);
    } catch (error) {
      return String(value);
    }
  }

  return String(value).trim();
}

function getPayloadItems(payload) {
  if (!payload || typeof payload !== "object") return [];
  if (Array.isArray(payload.ITEMS)) return payload.ITEMS;
  if (payload.ITEM && typeof payload.ITEM === "object") return [payload.ITEM];
  return [];
}

function getSettingItem(payload, cname) {
  const items = getPayloadItems(payload);
  if (!items.length) return null;
  return items.find(
    (item) => item && normalizeCompareValue(item.CNAME) === normalizeCompareValue(cname),
  ) || null;
}

function summarizeSettingItem(item, pathname = "") {
  if (!item) return null;

  const options = Array.isArray(item.ELEMENTS)
    ? item.ELEMENTS.map((entry) => String(entry).trim()).filter(Boolean)
    : String(item.CNAME || "").trim() === "sleep_timer"
      ? ["Off", "30 minutes", "60 minutes", "90 minutes", "120 minutes", "180 minutes"]
      : String(item.CNAME || "").trim() === "auto_power_off_timer"
        ? ["10 minutes", "Off"]
        : String(item.CNAME || "").trim() === "power_mode"
          ? ["Eco Mode", "Quick Start"]
          : String(item.CNAME || "").trim() === "usb_power"
            ? ["Always On", "Off When TV Off"]
        : [];

  return {
    id: String(item.CNAME || item.NAME || "setting").trim(),
    label: String(item.NAME || item.CNAME || "Setting").trim(),
    value: getReadableValue(item.VALUE || item.NAME || item.CNAME),
    options,
    path: pathname || "",
    type: String(item.TYPE || "").trim(),
    enabled: String(item.ENABLED || "").trim() !== "FALSE",
    hidden: String(item.HIDDEN || "").trim() === "TRUE",
    raw: item.VALUE !== undefined ? item.VALUE : null,
  };
}

function summarizePayloadItems(payload, preferredCnames, limit = 6, pathname = "") {
  const items = getPayloadItems(payload);
  if (!items.length) return [];

  const preferred = (preferredCnames || [])
    .map((cname) => summarizeSettingItem(getSettingItem(payload, cname), pathname))
    .filter(Boolean);

  if (preferred.length) return preferred;

  return items.map((item) => summarizeSettingItem(item, pathname))
    .filter((item) => item && item.value)
    .slice(0, limit);
}

function summarizeSelectableItems(
  payload,
  pathname,
  preferredCnames = [],
  limit = 12,
  excludedCnames = [],
) {
  const items = getPayloadItems(payload);
  if (!items.length) return [];

  const excluded = new Set(
    (excludedCnames || []).map((cname) => normalizeCompareValue(cname)),
  );
  const seen = new Set();
  const orderedItems = [];

  for (const cname of preferredCnames || []) {
    const item = getSettingItem(payload, cname);
    const normalized = normalizeCompareValue(cname);
    if (item && !seen.has(normalized)) {
      orderedItems.push(item);
      seen.add(normalized);
    }
  }

  for (const item of items) {
    const normalized = normalizeCompareValue(item && item.CNAME);
    if (!normalized || seen.has(normalized)) continue;
    orderedItems.push(item);
    seen.add(normalized);
  }

  return orderedItems
    .map((item) => summarizeSettingItem(item, pathname))
    .filter(
      (item) =>
        item &&
        item.enabled &&
        !item.hidden &&
        !excluded.has(normalizeCompareValue(item.id)) &&
        Array.isArray(item.options) &&
        item.options.length,
    )
    .slice(0, limit);
}

function clampVolumeLevel(value) {
  if (!Number.isFinite(value)) return 0;
  return Math.max(0, Math.min(100, Math.round(value)));
}

function getNumericSettingValue(value) {
  if (typeof value === "number" && Number.isFinite(value)) {
    return clampVolumeLevel(value);
  }

  if (typeof value === "string") {
    const parsed = Number.parseFloat(value);
    if (Number.isFinite(parsed)) return clampVolumeLevel(parsed);
  }

  return null;
}

function getBooleanSettingValue(value) {
  if (typeof value === "boolean") return value;
  const normalized = String(value ?? "").trim().toLowerCase();
  if (!normalized) return false;

  return ["true", "on", "yes", "1"].includes(normalized);
}

async function getVolumeStatus() {
  const audioPayload = ensureSmartCastSuccess(
    await retrySmartCastRequest(() => tv.settings.audio.get()),
    "Audio lookup failed",
  );
  const volumeItem = getSettingItem(audioPayload, "volume");
  const muteItem = getSettingItem(audioPayload, "mute");

  return {
    volume: getNumericSettingValue(volumeItem && volumeItem.VALUE),
    muted: getBooleanSettingValue(muteItem && muteItem.VALUE),
  };
}

function summarizeObjectEntries(value, pathname = "", options = {}) {
  if (!value || typeof value !== "object" || Array.isArray(value)) return [];

  const limit = Number.isFinite(options.limit) ? options.limit : 12;
  return Object.entries(value)
    .filter(([, entryValue]) => entryValue != null && entryValue !== "")
    .slice(0, limit)
    .map(([key, entryValue]) => ({
      id: String(key),
      label: String(key)
        .replace(/_/g, " ")
        .replace(/\b\w/g, (char) => char.toUpperCase()),
      value: getReadableValue(entryValue),
      options: [],
      path: pathname,
      type: typeof entryValue,
      raw: entryValue,
    }));
}

function matchesAppNamespace(left, right) {
  const leftValue = Number(left);
  const rightValue = Number(right);
  if (!Number.isFinite(leftValue) || !Number.isFinite(rightValue)) return false;
  return leftValue === rightValue || (EQUIVALENT_APP_NAMESPACES.has(leftValue) && EQUIVALENT_APP_NAMESPACES.has(rightValue));
}

function findAppDefinitionByConfig(appId, nameSpace) {
  const normalizedAppId = String(appId || "").trim();
  if (!normalizedAppId) return null;

  return (
    APP_DEFINITIONS.find(
      (definition) =>
        definition.appId === normalizedAppId && matchesAppNamespace(definition.nameSpace, nameSpace),
    ) || null
  );
}

async function getFirstSuccessfulPayload(pathnames, fallbackMessage) {
  let lastError = null;

  for (const pathname of pathnames) {
    try {
      return ensureSmartCastSuccess(
        await retrySmartCastRequest(() => smartCastJsonRequest("GET", pathname)),
        fallbackMessage,
      );
    } catch (error) {
      lastError = error;
    }
  }

  throw lastError || new Error(fallbackMessage);
}

function getCurrentAppConfigSummary(payload) {
  const item = getPayloadItems(payload)[0] || payload.ITEM || null;
  const value = item && item.VALUE && typeof item.VALUE === "object" ? item.VALUE : null;

  if (!value) {
    return {
      appName: "No app running",
      details: [],
    };
  }

  const appId = String(value.APP_ID || "").trim();
  const nameSpace = Number(value.NAME_SPACE);
  const knownApp = findAppDefinitionByConfig(appId, nameSpace);
  const appName = knownApp ? knownApp.name : appId ? "Unknown app" : "No app running";
  const details = [
    {
      id: "current_app_name",
      label: "Current App",
      value: appName,
      path: "/app/current",
      type: "app",
      raw: value,
    },
    {
      id: "current_app_id",
      label: "App ID",
      value: appId || "Unavailable",
      path: "/app/current",
      type: "app",
      raw: value.APP_ID,
    },
    {
      id: "current_app_namespace",
      label: "Namespace",
      value: Number.isFinite(nameSpace) ? String(nameSpace) : "Unavailable",
      path: "/app/current",
      type: "app",
      raw: value.NAME_SPACE,
    },
  ];

  const message = getReadableValue(value.MESSAGE);
  if (message) {
    details.push({
      id: "current_app_message",
      label: "Launch Message",
      value: message,
      path: "/app/current",
      type: "app",
      raw: value.MESSAGE,
    });
  }

  return {
    appName,
    details,
  };
}

function buildAdvancedGroup(id, title, description, settings) {
  return {
    id,
    title,
    description,
    settings: settings || [],
  };
}

function getFulfilledValue(result, fallbackMessage) {
  if (!result || result.status !== "fulfilled") return null;

  try {
    return ensureSmartCastSuccess(result.value, fallbackMessage);
  } catch (error) {
    return null;
  }
}

function isHttpUrl(value) {
  try {
    const target = new URL(String(value || "").trim());
    return target.protocol === "http:" || target.protocol === "https:";
  } catch (error) {
    return false;
  }
}

async function retrySmartCastRequest(task, attempts = 3, delayMs = 300) {
  let lastError = null;

  for (let attempt = 0; attempt < attempts; attempt++) {
    try {
      return await task();
    } catch (error) {
      lastError = error;
      if (attempt === attempts - 1) break;
      await new Promise((resolve) => setTimeout(resolve, delayMs));
    }
  }

  throw lastError;
}

async function getSystemTimersPayload() {
  return ensureSmartCastSuccess(
    await retrySmartCastRequest(() =>
      smartCastJsonRequest("GET", "/menu_native/dynamic/tv_settings/system/timers"),
    ),
    "Timers lookup failed",
  );
}

async function getSystemTimerPayload(cname) {
  return ensureSmartCastSuccess(
    await retrySmartCastRequest(() =>
      smartCastJsonRequest("GET", `/menu_native/dynamic/tv_settings/system/timers/${cname}`),
    ),
    `${cname} lookup failed`,
  );
}

async function setSystemTimerValue(cname, value, fallbackMessage) {
  const childPath = `/menu_native/dynamic/tv_settings/system/timers/${cname}`;
  const payload = ensureSmartCastSuccess(
    await retrySmartCastRequest(() => smartCastJsonRequest("GET", childPath)),
    fallbackMessage,
  );
  const item = getSettingItem(payload, cname);

  if (!item || !item.HASHVAL) {
    throw new Error("Timer setting unavailable on this TV");
  }

  return ensureSmartCastSuccess(
    await retrySmartCastRequest(() =>
      smartCastJsonRequest("PUT", String(payload.URI || childPath), {
        REQUEST: "MODIFY",
        HASHVAL: item.HASHVAL,
        VALUE: value,
      }),
    ),
    fallbackMessage,
  );
}

async function setChildSettingValue(pathname, cname, value, fallbackMessage) {
  const payload = ensureSmartCastSuccess(
    await retrySmartCastRequest(() => smartCastJsonRequest("GET", pathname)),
    fallbackMessage,
  );
  const item = getSettingItem(payload, cname);

  if (!item || !item.HASHVAL) {
    throw new Error("Setting unavailable on this TV");
  }

  return ensureSmartCastSuccess(
    await retrySmartCastRequest(() =>
      smartCastJsonRequest("PUT", String(payload.URI || pathname), {
        REQUEST: "MODIFY",
        HASHVAL: item.HASHVAL,
        VALUE: value,
      }),
    ),
    fallbackMessage,
  );
}

async function getAdvancedOverview() {
  async function settled(task) {
    try {
      return { status: "fulfilled", value: await task() };
    } catch (error) {
      return { status: "rejected", reason: error };
    }
  }

  const pictureResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.mode.get()));
  const audioResult = await settled(() => retrySmartCastRequest(() => tv.settings.audio.get()));
  const sleepResult = await settled(() => getSystemTimerPayload("sleep_timer"));
  const autoPowerResult = await settled(() => getSystemTimerPayload("auto_power_off_timer"));
  const tvInfoResult = await settled(() => retrySmartCastRequest(() => tv.settings.system.information.tv.get()));
  const networkInfoResult = await settled(() => retrySmartCastRequest(() => tv.settings.system.information.network.get()));
  const castResult = await settled(() => retrySmartCastRequest(() => tv.settings.cast.get()));
  const devicesResult = await settled(() => retrySmartCastRequest(() => tv.settings.devices.get()));
  const pictureMenuResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.get()));
  const systemResult = await settled(() => retrySmartCastRequest(() => tv.settings.system.get()));
  const channelsResult = await settled(() => retrySmartCastRequest(() => tv.settings.channels.get()));
  const networkRootResult = await settled(() => retrySmartCastRequest(() => tv.settings.network.get()));
  const modeEditResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.modeEdit.get()));
  const pictureSizeResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.size.get()));
  const picturePositionResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.position.get()));
  const closedCaptionsResult = await settled(() => retrySmartCastRequest(() => tv.settings.closedCaptions.get()));
  const tunerInfoResult = await settled(() => retrySmartCastRequest(() => tv.settings.system.information.tuner.get()));
  const uliInfoResult = await settled(() => retrySmartCastRequest(() => tv.settings.system.information.uli.get()));
  const mobileDevicesResult = await settled(() => retrySmartCastRequest(() => tv.settings.mobileDevices.get()));
  const colorCalibrationResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.color.calibration.get()));
  const colorTunerResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.color.tuner.get()));
  const calibrationTestsResult = await settled(() => retrySmartCastRequest(() => tv.settings.picture.calibrationTests.get()));
  const deviceInfoResult = await settled(() =>
    getFirstSuccessfulPayload(["/state/device/deviceinfo"], "Device info lookup failed"),
  );
  const currentAppResult = await settled(() =>
    getFirstSuccessfulPayload(["/app/current"], "Current app lookup failed"),
  );
  const versionResult = await settled(() =>
    getFirstSuccessfulPayload(
      [
        "/menu_native/dynamic/tv_settings/system/system_information/tv_information/version",
        "/menu_native/dynamic/tv_settings/admin_and_privacy/system_information/tv_information/version",
      ],
      "Version lookup failed",
    ),
  );
  const esnResult = await settled(() =>
    getFirstSuccessfulPayload(
      [
        "/menu_native/dynamic/tv_settings/system/system_information/uli_information/esn",
        "/menu_native/dynamic/tv_settings/admin_and_privacy/system_information/uli_information/esn",
      ],
      "ESN lookup failed",
    ),
  );
  const serialNumberResult = await settled(() =>
    getFirstSuccessfulPayload(
      [
        "/menu_native/dynamic/tv_settings/system/system_information/tv_information/serial_number",
        "/menu_native/dynamic/tv_settings/admin_and_privacy/system_information/tv_information/serial_number",
      ],
      "Serial lookup failed",
    ),
  );

  const pictureModePayload = getFulfilledValue(pictureResult, "Picture mode lookup failed");
  const audioPayload = getFulfilledValue(audioResult, "Audio lookup failed");
  const sleepPayload = getFulfilledValue(sleepResult, "Sleep timer lookup failed");
  const autoPowerPayload = getFulfilledValue(autoPowerResult, "Auto power off lookup failed");
  const tvInfoPayload = getFulfilledValue(tvInfoResult, "TV info lookup failed");
  const networkInfoPayload = getFulfilledValue(networkInfoResult, "Network info lookup failed");
  const castPayload = getFulfilledValue(castResult, "Cast lookup failed");
  const devicesPayload = getFulfilledValue(devicesResult, "Devices lookup failed");
  const picturePayload = getFulfilledValue(pictureMenuResult, "Picture lookup failed");
  const systemPayload = getFulfilledValue(systemResult, "System lookup failed");
  const channelsPayload = getFulfilledValue(channelsResult, "Channels lookup failed");
  const networkRootPayload = getFulfilledValue(networkRootResult, "Network lookup failed");
  const modeEditPayload = getFulfilledValue(modeEditResult, "Picture mode edit lookup failed");
  const pictureSizePayload = getFulfilledValue(pictureSizeResult, "Picture size lookup failed");
  const picturePositionPayload = getFulfilledValue(picturePositionResult, "Picture position lookup failed");
  const closedCaptionsPayload = getFulfilledValue(closedCaptionsResult, "Closed captions lookup failed");
  const tunerInfoPayload = getFulfilledValue(tunerInfoResult, "Tuner info lookup failed");
  const uliInfoPayload = getFulfilledValue(uliInfoResult, "ULI info lookup failed");
  const mobileDevicesPayload = getFulfilledValue(mobileDevicesResult, "Mobile devices lookup failed");
  const colorCalibrationPayload = getFulfilledValue(colorCalibrationResult, "Color calibration lookup failed");
  const colorTunerPayload = getFulfilledValue(colorTunerResult, "Color tuner lookup failed");
  const calibrationTestsPayload = getFulfilledValue(calibrationTestsResult, "Calibration tests lookup failed");
  const deviceInfoPayload = getFulfilledValue(deviceInfoResult, "Device info lookup failed");
  const currentAppPayload = getFulfilledValue(currentAppResult, "Current app lookup failed");
  const versionPayload = getFulfilledValue(versionResult, "Version lookup failed");
  const esnPayload = getFulfilledValue(esnResult, "ESN lookup failed");
  const serialNumberPayload = getFulfilledValue(serialNumberResult, "Serial lookup failed");
  const currentAppSummary = getCurrentAppConfigSummary(currentAppPayload);
  const deviceInfoValue =
    getPayloadItems(deviceInfoPayload)[0] &&
    getPayloadItems(deviceInfoPayload)[0].VALUE &&
    typeof getPayloadItems(deviceInfoPayload)[0].VALUE === "object"
      ? getPayloadItems(deviceInfoPayload)[0].VALUE
      : null;

  return {
    pictureMode: summarizeSettingItem(
      getSettingItem(pictureModePayload, "picture_mode"),
      "/menu_native/dynamic/tv_settings/picture/picture_mode",
    ),
    sleepTimer:
      summarizeSettingItem(
        getSettingItem(sleepPayload, "sleep_timer"),
        "/menu_native/dynamic/tv_settings/timers/sleep_timer",
      ) || {
        id: "sleep_timer",
        label: "Sleep Timer",
        value: "Unsupported on this TV",
        options: [],
        path: "/menu_native/dynamic/tv_settings/timers/sleep_timer",
        type: "unsupported",
      },
    autoPowerOff: summarizeSettingItem(
      getSettingItem(autoPowerPayload, "auto_power_off_timer"),
      "/menu_native/dynamic/tv_settings/timers/auto_power_off_timer",
    ) || {
      id: "auto_power_off_timer",
      label: "Auto Power Off",
      value: "Unsupported on this TV",
      options: [],
      path: "/menu_native/dynamic/tv_settings/timers/auto_power_off_timer",
      type: "unsupported",
    },
    audio: summarizePayloadItems(
      audioPayload,
      [
        "volume",
        "mute",
        "tv_speakers",
        "surround_sound",
        "volume_leveling",
        "digital_audio_out",
        "analog_audio_out",
        "dialogue_enhancer",
      ],
      8,
      "/menu_native/dynamic/tv_settings/audio",
    ),
    network: summarizePayloadItems(
      networkInfoPayload || networkRootPayload,
      ["connection_type", "current_access_point", "wired_connection", "wifi_networks"],
      6,
      "/menu_native/dynamic/tv_settings/network",
    ),
    cast: summarizePayloadItems(
      castPayload,
      ["cast_name", "availability"],
      4,
      "/menu_native/dynamic/tv_settings/cast",
    ),
    devices: summarizePayloadItems(
      devicesPayload,
      ["current_input", "current_inputs", "hdmi1", "hdmi2", "hdmi3", "comp"],
      6,
      "/menu_native/dynamic/tv_settings/devices",
    ),
    tvInfo: summarizePayloadItems(
      tvInfoPayload || systemPayload,
      ["tv_name", "power_mode", "input_at_power_on", "usb_power", "power_indicator", "country"],
      6,
      "/menu_native/dynamic/tv_settings/system",
    ),
    picture: summarizePayloadItems(
      picturePayload,
      ["backlight", "brightness", "contrast", "color", "sharpness", "color_temperature", "picture_aspect"],
      8,
      "/menu_native/dynamic/tv_settings/picture",
    ),
    channels: summarizePayloadItems(
      channelsPayload,
      ["current_channel", "analog", "digital", "analog_audio", "digital_audio", "percent_complete"],
      6,
      "/menu_native/dynamic/tv_settings/channels",
    ),
    actions: [
      summarizeSettingItem(getSettingItem(channelsPayload, "auto_channel_scan"), "/menu_native/dynamic/tv_settings/channels"),
      summarizeSettingItem(getSettingItem(channelsPayload, "find_new_channel"), "/menu_native/dynamic/tv_settings/channels"),
      summarizeSettingItem(getSettingItem(castPayload, "start_soft_ap"), "/menu_native/dynamic/tv_settings/cast"),
      summarizeSettingItem(getSettingItem(castPayload, "stop_soft_ap"), "/menu_native/dynamic/tv_settings/cast"),
      summarizeSettingItem(getSettingItem(modeEditPayload, "save_picture_mode"), "/menu_native/dynamic/tv_settings/picture/picture_mode_edit"),
      summarizeSettingItem(getSettingItem(modeEditPayload, "reset_picture_mode"), "/menu_native/dynamic/tv_settings/picture/picture_mode_edit"),
    ].filter((item) => item && item.enabled && !item.hidden),
    powerMode: summarizeSettingItem(getSettingItem(systemPayload, "power_mode"), "/menu_native/dynamic/tv_settings/system"),
    inputAtPowerOn: summarizeSettingItem(getSettingItem(systemPayload, "input_at_power_on"), "/menu_native/dynamic/tv_settings/system"),
    usbPower: summarizeSettingItem(getSettingItem(systemPayload, "usb_power"), "/menu_native/dynamic/tv_settings/system"),
    audioOut: summarizeSettingItem(getSettingItem(audioPayload, "tv_speakers"), "/menu_native/dynamic/tv_settings/audio"),
    controlGroups: [
      buildAdvancedGroup(
        "audio-controls",
        "Audio controls",
        "More sound tuning options pulled straight from the TV audio menu.",
        summarizeSelectableItems(
          audioPayload,
          "/menu_native/dynamic/tv_settings/audio",
          [
            "surround_sound",
            "volume_leveling",
            "digital_audio_out",
            "analog_audio_out",
            "dialogue_enhancer",
            "equalizer",
            "balance",
            "lip_sync",
          ],
          12,
          ["tv_speakers"],
        ),
      ),
      buildAdvancedGroup(
        "picture-controls",
        "Picture tuning",
        "Preset-style video controls and processing options beyond the main picture mode switcher.",
        summarizeSelectableItems(
          picturePayload,
          "/menu_native/dynamic/tv_settings/picture",
          [
            "backlight",
            "brightness",
            "contrast",
            "color",
            "tint",
            "sharpness",
            "color_temperature",
            "picture_aspect",
            "reduce_noise",
            "film_mode",
            "color_space",
            "gamma",
          ],
          14,
          ["picture_mode"],
        ),
      ),
      buildAdvancedGroup(
        "picture-size-controls",
        "Picture geometry",
        "Overscan, size, and position controls when your TV exposes them.",
        [
          ...summarizeSelectableItems(
            pictureSizePayload,
            "/menu_native/dynamic/tv_settings/picture/picture_size",
            [],
            6,
          ),
          ...summarizeSelectableItems(
            picturePositionPayload,
            "/menu_native/dynamic/tv_settings/picture/picture_position",
            [],
            6,
          ),
        ],
      ),
      buildAdvancedGroup(
        "closed-captions-controls",
        "Closed captions",
        "Caption language and style controls from the dedicated accessibility menu.",
        summarizeSelectableItems(
          closedCaptionsPayload,
          "/menu_native/dynamic/tv_settings/closed_captions",
          [
            "captions",
            "digital_style",
            "digital_cc",
            "analog_cc",
            "text_size",
            "text_color",
            "background_color",
            "window_color",
          ],
          12,
        ),
      ),
      buildAdvancedGroup(
        "system-controls",
        "System extras",
        "Additional TV behavior toggles that do not fit in the top-level power cards.",
        summarizeSelectableItems(
          systemPayload,
          "/menu_native/dynamic/tv_settings/system",
          ["power_indicator", "menu_language", "timezone", "cec", "wake_on_lan"],
          10,
          ["power_mode", "input_at_power_on", "usb_power"],
        ),
      ),
      buildAdvancedGroup(
        "cast-controls",
        "Cast behavior",
        "Chromecast-facing options and availability controls when your model exposes them.",
        summarizeSelectableItems(
          castPayload,
          "/menu_native/dynamic/tv_settings/cast",
          ["availability", "cast_name"],
          10,
        ),
      ),
      buildAdvancedGroup(
        "network-controls",
        "Network controls",
        "Extra network-facing toggles surfaced by the TV menus, including Wi-Fi and connection behavior when available.",
        summarizeSelectableItems(
          networkRootPayload,
          "/menu_native/dynamic/tv_settings/network",
          ["wifi_networks", "connection_type", "current_access_point", "wired_connection"],
          10,
        ),
      ),
      buildAdvancedGroup(
        "channel-controls",
        "Channel options",
        "Tuner and channel behavior that can be changed without opening the on-screen menus.",
        summarizeSelectableItems(
          channelsPayload,
          "/menu_native/dynamic/tv_settings/channels",
          ["analog_audio", "digital_audio", "channel_input", "air_cable"],
          8,
        ),
      ),
      buildAdvancedGroup(
        "calibration-lab",
        "Calibration lab",
        "Deeper calibration and test menus for displays that expose them through SmartCast.",
        [
          ...summarizeSelectableItems(
            colorCalibrationPayload,
            "/menu_native/dynamic/tv_settings/picture/color_calibration",
            [],
            8,
          ),
          ...summarizeSelectableItems(
            colorTunerPayload,
            "/menu_native/dynamic/tv_settings/picture/color_calibration/color_tuner",
            [],
            8,
          ),
          ...summarizeSelectableItems(
            calibrationTestsPayload,
            "/menu_native/dynamic/tv_settings/picture/color_calibration/calibration_tests",
            [],
            8,
          ),
        ],
      ),
    ].filter((group) => group.settings.length),
    infoGroups: [
      buildAdvancedGroup("tv-info", "TV info", "Model and system state straight from the TV firmware.", summarizePayloadItems(tvInfoPayload || systemPayload, ["tv_name", "power_mode", "input_at_power_on", "usb_power", "power_indicator", "country"], 6, "/menu_native/dynamic/tv_settings/system")),
      buildAdvancedGroup("network-info", "Network", "Connection details, Wi-Fi visibility, and network status.", summarizePayloadItems(networkInfoPayload || networkRootPayload, ["connection_type", "current_access_point", "wired_connection", "wifi_networks"], 6, "/menu_native/dynamic/tv_settings/network")),
      buildAdvancedGroup("audio-info", "Audio", "Current audio state and values reported by the TV.", summarizePayloadItems(audioPayload, ["volume", "mute", "tv_speakers", "surround_sound", "volume_leveling", "digital_audio_out", "analog_audio_out", "dialogue_enhancer"], 8, "/menu_native/dynamic/tv_settings/audio")),
      buildAdvancedGroup("cast-info", "Cast", "Current cast status, device naming, and availability.", summarizePayloadItems(castPayload, ["cast_name", "availability"], 4, "/menu_native/dynamic/tv_settings/cast")),
      buildAdvancedGroup("picture-info", "Picture details", "Live values for current picture settings.", summarizePayloadItems(picturePayload, ["backlight", "brightness", "contrast", "color", "sharpness", "color_temperature", "picture_aspect"], 8, "/menu_native/dynamic/tv_settings/picture")),
      buildAdvancedGroup("channel-info", "Channels", "Current tuner and channel scan state.", summarizePayloadItems(channelsPayload, ["current_channel", "analog", "digital", "analog_audio", "digital_audio", "percent_complete"], 6, "/menu_native/dynamic/tv_settings/channels")),
      buildAdvancedGroup("input-info", "Inputs", "Detected inputs and active source snapshots.", summarizePayloadItems(devicesPayload, ["current_input", "current_inputs", "hdmi1", "hdmi2", "hdmi3", "comp"], 6, "/menu_native/dynamic/tv_settings/devices")),
      buildAdvancedGroup(
        "app-session",
        "App session",
        "Live app identity and launch payload details, similar to the richer app inspection exposed by pyvizio.",
        currentAppSummary.details,
      ),
      buildAdvancedGroup(
        "firmware-identity",
        "Firmware and identity",
        "Firmware version, serial metadata, and low-level device identifiers pulled from pyvizio's endpoint map.",
        [
          ...summarizePayloadItems(versionPayload, [], 2, "/menu_native/dynamic/tv_settings/system/system_information/tv_information/version"),
          ...summarizePayloadItems(esnPayload, [], 2, "/menu_native/dynamic/tv_settings/system/system_information/uli_information/esn"),
          ...summarizePayloadItems(serialNumberPayload, [], 2, "/menu_native/dynamic/tv_settings/system/system_information/tv_information/serial_number"),
          ...summarizeObjectEntries(deviceInfoValue, "/state/device/deviceinfo", { limit: 8 }),
        ],
      ),
      buildAdvancedGroup("tuner-info", "Tuner info", "Extra tuner metadata when exposed by the TV.", summarizePayloadItems(tunerInfoPayload, [], 6, "/menu_native/dynamic/tv_settings/system/system_information/tuner_information")),
      buildAdvancedGroup("uli-info", "ULI info", "Lower-level platform metadata from the system information tree.", summarizePayloadItems(uliInfoPayload, [], 6, "/menu_native/dynamic/tv_settings/system/system_information/uli_information")),
      buildAdvancedGroup("mobile-devices", "Mobile devices", "Companion and paired device data reported by SmartCast.", summarizePayloadItems(mobileDevicesPayload, [], 6, "/menu_native/dynamic/tv_settings/mobile_devices")),
      buildAdvancedGroup("calibration-info", "Calibration data", "Color calibration, tuner, and test values for advanced setups.", [
        ...summarizePayloadItems(colorCalibrationPayload, [], 4, "/menu_native/dynamic/tv_settings/picture/color_calibration"),
        ...summarizePayloadItems(colorTunerPayload, [], 4, "/menu_native/dynamic/tv_settings/picture/color_calibration/color_tuner"),
        ...summarizePayloadItems(calibrationTestsPayload, [], 4, "/menu_native/dynamic/tv_settings/picture/color_calibration/calibration_tests"),
      ]),
    ].filter((group) => group.settings.length),
    urlLaunchSupported: true,
  };
}

function getSmartCastConnection() {
  const cfg = ensureConfigFromEnvIfPresent() || loadConfig();
  const ip = currentIp || (cfg && cfg.ip) || "";
  const token = cfg && cfg.token ? String(cfg.token).trim() : "";

  if (!ip || !token) {
    throw new Error("Not paired");
  }

  return { ip, token };
}

function smartCastJsonRequest(method, pathname, body) {
  const { ip, token } = getSmartCastConnection();

  return new Promise((resolve, reject) => {
    const req = https.request(
      {
        hostname: ip,
        port: SMARTCAST_PORT,
        path: pathname,
        method,
        rejectUnauthorized: false,
        headers: {
          AUTH: token,
          "Content-Type": "application/json",
        },
      },
      (res) => {
        let payload = "";
        res.setEncoding("utf8");
        res.on("data", (chunk) => {
          payload += chunk;
        });
        res.on("end", () => {
          try {
            resolve(JSON.parse(payload || "{}"));
          } catch (error) {
            reject(error);
          }
        });
      },
    );

    req.on("error", reject);
    if (body) {
      req.write(JSON.stringify(body));
    }
    req.end();
  });
}

async function executeActionFromMenu(getter, cname, fallbackMessage) {
  const payload = ensureSmartCastSuccess(await getter(), fallbackMessage);
  const item = getSettingItem(payload, cname);

  if (!item || !item.HASHVAL) {
    throw new Error("Action unavailable on this TV");
  }

  if (String(item.ENABLED || "").trim() === "FALSE" || String(item.HIDDEN || "").trim() === "TRUE") {
    throw new Error("This action is currently unavailable on your TV");
  }

  try {
    const result = ensureSmartCastSuccess(
      await smartCastJsonRequest("PUT", String(payload.URI || ""), {
        REQUEST: "MODIFY",
        HASHVAL: item.HASHVAL,
        VALUE: "T_ACTION_V1",
      }),
      fallbackMessage,
    );

    return {
      item,
      payload,
      result,
    };
  } catch (error) {
    const message = error && error.message ? String(error.message) : String(error);
    if (/type error/i.test(message)) {
      throw new Error("This action is exposed by the TV menu, but your TV rejected the execution request");
    }
    throw error;
  }
}

function buildActionSuccessMessage(actionId, context = {}) {
  const actionLabel = context.item && context.item.NAME ? String(context.item.NAME).trim() : actionId;
  const castName = getReadableValue(
    context.castPayload ? getSettingItem(context.castPayload, "cast_name")?.value : "",
  );
  const tvName = getReadableValue(
    context.systemPayload ? getSettingItem(context.systemPayload, "tv_name")?.value : "",
  );
  const targetName = castName || tvName || currentIp || "your TV";
  const currentInput = getReadableValue(
    context.devicesPayload ? getSettingItem(context.devicesPayload, "current_input")?.value : "",
  );

  if (actionId === "start_soft_ap") {
    return `${actionLabel} started for ${targetName}.`;
  }

  if (actionId === "stop_soft_ap") {
    return `${actionLabel} stopped for ${targetName}.`;
  }

  if (actionId === "auto_channel_scan") {
    return `${actionLabel} started${currentInput ? ` on ${currentInput}` : ""}.`;
  }

  if (actionId === "find_new_channel") {
    return `${actionLabel} triggered${currentInput ? ` on ${currentInput}` : ""}.`;
  }

  if (actionId === "save_picture_mode") {
    return `${actionLabel} saved on ${targetName}.`;
  }

  if (actionId === "reset_picture_mode") {
    return `${actionLabel} reset on ${targetName}.`;
  }

  return `${actionLabel} sent to ${targetName}.`;
}

async function describeSsdpDevice(location, fallbackIp) {
  const xml = await requestText(location, 2500);
  const manufacturer = getXmlTag(xml, "manufacturer");
  if (!manufacturer || manufacturer.toUpperCase() !== "VIZIO") return null;

  const url = new URL(location);
  return normalizeDevice(
    {
      ip: fallbackIp || url.hostname,
      name: getXmlTag(xml, "friendlyName"),
      model: getXmlTag(xml, "modelName"),
      manufacturer,
    },
    "ssdp",
  );
}

function discoverViaLibrary(timeout = DISCOVERY_TIMEOUT) {
  return new Promise((resolve) => {
    const found = new Map();
    let done = false;

    function finish() {
      if (done) return;
      done = true;
      resolve(Array.from(found.values()));
    }

    const timer = setTimeout(finish, timeout + 250);

    try {
      VizioSmartCast.discover(
        (device) => {
          const normalized = normalizeDevice(device, "library");
          if (normalized) {
            found.set(normalized.ip, normalized);
          }
        },
        () => {
          clearTimeout(timer);
          finish();
        },
        timeout,
      );
    } catch (error) {
      clearTimeout(timer);
      logServerError("library discovery failed", error);
      finish();
    }
  });
}

function discoverViaSsdp(timeout = DISCOVERY_TIMEOUT) {
  return new Promise((resolve, reject) => {
    const found = new Map();
    const pendingDescriptions = new Set();
    const client = new SsdpClient({
      explicitSocketBind: true,
      reuseAddr: true,
    });

    let finished = false;

    function addFound(device) {
      const normalized = normalizeDevice(device, "ssdp");
      if (normalized) {
        found.set(normalized.ip, normalized);
      }
    }

    function finish() {
      if (finished) return;
      finished = true;
      clearTimeout(timer);
      try {
        client.stop();
      } catch (error) {
        // Ignore socket shutdown issues during discovery cleanup.
      }
      Promise.allSettled(Array.from(pendingDescriptions)).then(() =>
        resolve(Array.from(found.values())),
      );
    }

    const timer = setTimeout(finish, timeout);

    client.on("error", (error) => {
      clearTimeout(timer);
      reject(error);
    });

    client.on("response", (headers, statusCode, info) => {
      const location = headers.LOCATION || headers.Location || headers.location;
      if (!location) return;

      const task = describeSsdpDevice(location, info && info.address)
        .then((device) => {
          if (device) addFound(device);
        })
        .catch(() => {
          // Ignore malformed or unreachable SSDP responses. Subnet probing
          // below provides a fallback path for powered-on TVs.
        })
        .finally(() => {
          pendingDescriptions.delete(task);
        });

      pendingDescriptions.add(task);
    });

    client.start(
      (error) => {
        if (error) {
          clearTimeout(timer);
          reject(error);
          return;
        }

        try {
          client.search("urn:dial-multiscreen-org:device:dial:1");
          setTimeout(() => {
            try {
              client.search("urn:dial-multiscreen-org:device:dial:1");
            } catch (searchError) {
              // Ignore secondary search failures; the first search may still win.
            }
          }, Math.min(750, Math.max(250, Math.floor(timeout / 3))));
        } catch (searchError) {
          clearTimeout(timer);
          reject(searchError);
        }
      },
    ).catch((error) => {
        clearTimeout(timer);
        reject(error);
      });
  });
}

function ipv4ToInt(ip) {
  return String(ip)
    .split(".")
    .map((part) => parseInt(part, 10))
    .reduce((value, part) => ((value << 8) | (part & 255)) >>> 0, 0);
}

function intToIpv4(value) {
  return [
    (value >>> 24) & 255,
    (value >>> 16) & 255,
    (value >>> 8) & 255,
    value & 255,
  ].join(".");
}

function isLikelyLanIpv4(address) {
  return /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[0-1])\.)/.test(
    String(address || ""),
  );
}

function isVirtualInterface(name) {
  return /(loopback|virtual|vmware|vbox|hyper-v|wsl|docker|tailscale|zerotier)/i.test(
    String(name || ""),
  );
}

function getInterfaceCandidates() {
  const preferred = [];
  const fallback = [];
  const interfaces = os.networkInterfaces();

  for (const [name, addresses] of Object.entries(interfaces)) {
    for (const entry of addresses || []) {
      if (entry.internal || entry.family !== "IPv4" || !entry.netmask) continue;

      const ipInt = ipv4ToInt(entry.address);
      const maskInt = ipv4ToInt(entry.netmask);
      const networkInt = ipInt & maskInt;
      const broadcastInt = networkInt | (~maskInt >>> 0);
      let startInt = networkInt + 1;
      let endInt = broadcastInt - 1;

      if (endInt - startInt + 1 > 512) {
        const local24 = ipInt & ipv4ToInt("255.255.255.0");
        startInt = local24 + 1;
        endInt = local24 + 254;
      }

      const candidate = {
        interfaceName: name,
        address: entry.address,
        startInt,
        endInt,
      };

      if (isLikelyLanIpv4(entry.address) && !isVirtualInterface(name)) {
        preferred.push(candidate);
      } else {
        fallback.push(candidate);
      }
    }
  }

  return preferred.length ? preferred : fallback;
}

async function probeSmartCast(ip, timeout = SUBNET_PROBE_TIMEOUT) {
  try {
    const response = await requestText(
      `https://${ip}:${SMARTCAST_PORT}/state/device/power_mode`,
      timeout,
    );
    const data = JSON.parse(response);
    if (!data || !data.STATUS || data.STATUS.RESULT !== "SUCCESS") return null;

    return normalizeDevice(
      {
        ip,
        name: "Vizio TV",
        model: "Unknown model",
        manufacturer: "VIZIO",
      },
      "subnet",
    );
  } catch (error) {
    return null;
  }
}

async function runWithConcurrency(items, limit, worker) {
  const results = [];
  let index = 0;

  async function next() {
    while (index < items.length) {
      const currentIndex = index++;
      const value = await worker(items[currentIndex], currentIndex);
      if (value) results.push(value);
    }
  }

  const workers = Array.from(
    { length: Math.max(1, Math.min(limit, items.length || 1)) },
    () => next(),
  );

  await Promise.all(workers);
  return results;
}

async function discoverViaSubnetProbe() {
  const candidateIps = new Set();

  for (const candidate of getInterfaceCandidates()) {
    for (let current = candidate.startInt; current <= candidate.endInt; current++) {
      const ip = intToIpv4(current >>> 0);
      if (ip !== candidate.address) {
        candidateIps.add(ip);
      }
    }
  }

  return runWithConcurrency(
    Array.from(candidateIps),
    SUBNET_PROBE_CONCURRENCY,
    (ip) => probeSmartCast(ip),
  );
}

async function discoverTvs(timeout = DISCOVERY_TIMEOUT, options = {}) {
  const includeSubnetProbe = options.includeSubnetProbe !== false;
  const quickTimeout = Math.max(600, Math.min(timeout, FAST_DISCOVERY_TIMEOUT));
  const fastResults = await Promise.allSettled([
    discoverViaLibrary(quickTimeout),
    discoverViaSsdp(quickTimeout),
  ]);

  const fastDevices = mergeDevices(
    ...(fastResults
      .filter((result) => result.status === "fulfilled")
      .map((result) => result.value)),
  );

  if (fastDevices.length) {
    return fastDevices;
  }

  const fallbackTasks = [
    discoverViaLibrary(timeout),
    discoverViaSsdp(timeout),
  ];

  if (includeSubnetProbe) {
    fallbackTasks.push(discoverViaSubnetProbe());
  }

  const fallbackResults = await Promise.allSettled(fallbackTasks);

  return mergeDevices(
    ...(fallbackResults
      .filter((result) => result.status === "fulfilled")
      .map((result) => result.value)),
  );
}

function initFromConfig() {
  const cfg = ensureConfigFromEnvIfPresent() || loadConfig();
  if (cfg && cfg.ip && cfg.token) {
    currentIp = cfg.ip;
    tv = new VizioSmartCast(cfg.ip);
    tv.pairing.useAuthToken(cfg.token);
    return true;
  }
  return false;
}

ensureConfigFileExists();
initFromConfig();

const app = express();
app.use(cors());
app.use(express.json());

async function handle(res, desc, fn) {
  try {
    if (!tv) throw new Error("Not paired");
    ensureSmartCastSuccess(await fn(), `${desc} failed`);
    res.json({
      ok: true,
      desc,
    });
  } catch (e) {
    res.status(String(e.message || e).includes("Not paired") ? 400 : 500).json({
      ok: false,
      desc,
      error: e && e.message ? e.message : String(e),
    });
  }
}

app.get("/api/status", (req, res) => {
  const cfg = loadConfig();
  res.json({
    ok: true,
    paired: !!tv,
    ip: currentIp || (cfg && cfg.ip) || null,
    hasConfig: !!cfg,
  });
});

app.get("/api/discover", async (req, res) => {
  try {
    const mode = String((req.query && req.query.mode) || "fast").trim().toLowerCase();
    let devices = await discoverTvs(DISCOVERY_TIMEOUT, {
      includeSubnetProbe: mode === "deep",
    });

    // If the fast path misses a TV, automatically retry once with the deeper subnet probe.
    if (!devices.length && mode !== "deep") {
      devices = await discoverTvs(DISCOVERY_TIMEOUT, {
        includeSubnetProbe: true,
      });
    }

    res.json({
      ok: true,
      devices,
    });
  } catch (e) {
    logServerError("discover route failed", e);
    res.json({
      ok: true,
      devices: [],
      warning: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/pair/initiate", async (req, res) => {
  try {
    const ip = String((req.body && req.body.ip) || "").trim();
    if (!ip)
      return res.status(400).json({
        ok: false,
        error: "IP is required",
      });
    if (tv)
      return res.status(400).json({
        ok: false,
        error: "Already paired",
      });

    if (!pending.tv || pending.ip !== ip) {
      pending.tv = new VizioSmartCast(ip);
      pending.ip = ip;
    }

    try {
      await pending.tv.pairing.initiate("VizMote", "9727");
    } catch (error) {
      const message = error && error.message ? String(error.message) : String(error);
      if (!/already been initiated/i.test(message)) {
        throw error;
      }
    }

    res.json({
      ok: true,
      ip,
    });
  } catch (e) {
    logServerError("pair initiate failed", e);
    pending = {
      tv: null,
      ip: null,
    };
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/pair/commit", async (req, res) => {
  try {
    const pin = String((req.body && req.body.pin) || "").trim();
    if (!pin)
      return res.status(400).json({
        ok: false,
        error: "PIN is required",
      });
    if (!pending.tv || !pending.ip) {
      return res.status(400).json({
        ok: false,
        error: "No pairing session in progress",
      });
    }

    const response = await pending.tv.pairing.pair(pin);
    const token = response && response.ITEM && response.ITEM.AUTH_TOKEN;
    if (!token)
      return res.status(500).json({
        ok: false,
        error: "Pairing did not return an auth token",
      });

    saveConfig(pending.ip, token);
    currentIp = pending.ip;
    tv = new VizioSmartCast(currentIp);
    tv.pairing.useAuthToken(token);

    pending = {
      tv: null,
      ip: null,
    };

    res.json({
      ok: true,
      ip: currentIp,
    });
  } catch (e) {
    logServerError("pair commit failed", e);
    pending = {
      tv: null,
      ip: null,
    };
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/pair/reset", (req, res) => {
  try {
    pending = {
      tv: null,
      ip: null,
    };
    tv = null;
    currentIp = null;
    clearConfig();
    res.json({
      ok: true,
    });
  } catch (e) {
    logServerError("pair reset failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.get("/api/ping", (req, res) =>
  res.json({
    ok: true,
    ip: currentIp || null,
  }),
);

app.get("/api/info", async (req, res) => {
  try {
    if (!tv)
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    const info = await tv.control.info();
    res.json({
      ok: true,
      info,
    });
  } catch (e) {
    logServerError("info route failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/nav/up", (req, res) =>
  handle(res, "Navigate Up", () => tv.control.navigate.up()),
);
app.post("/api/nav/down", (req, res) =>
  handle(res, "Navigate Down", () => tv.control.navigate.down()),
);
app.post("/api/nav/left", (req, res) =>
  handle(res, "Navigate Left", () => tv.control.navigate.left()),
);
app.post("/api/nav/right", (req, res) =>
  handle(res, "Navigate Right", () => tv.control.navigate.right()),
);
app.post("/api/nav/ok", (req, res) =>
  handle(res, "OK", () => tv.control.navigate.ok()),
);
app.post("/api/nav/back", (req, res) =>
  handle(res, "Back", () => tv.control.navigate.back()),
);

app.post("/api/menu", (req, res) =>
  handle(res, "Settings", () => tv.control.menu()),
);

app.get("/api/volume", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const volumeStatus = await getVolumeStatus();
    res.json({ ok: true, ...volumeStatus });
  } catch (e) {
    logServerError("volume status failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/volume/up", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    ensureSmartCastSuccess(
      await retrySmartCastRequest(() => tv.control.volume.up()),
      "Volume Up failed",
    );
    const volumeStatus = await getVolumeStatus();
    res.json({ ok: true, desc: "Volume Up", ...volumeStatus });
  } catch (e) {
    logServerError("volume up failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/volume/down", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    ensureSmartCastSuccess(
      await retrySmartCastRequest(() => tv.control.volume.down()),
      "Volume Down failed",
    );
    const volumeStatus = await getVolumeStatus();
    res.json({ ok: true, desc: "Volume Down", ...volumeStatus });
  } catch (e) {
    logServerError("volume down failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/volume/set", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const requestedValue = Number((req.body && req.body.value) ?? NaN);
    if (!Number.isFinite(requestedValue)) {
      return res.status(400).json({ ok: false, error: "Volume value is required" });
    }

    const value = clampVolumeLevel(requestedValue);
    ensureSmartCastSuccess(
      await retrySmartCastRequest(() => tv.control.volume.set(value)),
      "Volume set failed",
    );
    const volumeStatus = await getVolumeStatus();
    res.json({ ok: true, ...volumeStatus });
  } catch (e) {
    logServerError("volume set failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/mute/toggle", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    ensureSmartCastSuccess(
      await retrySmartCastRequest(() => tv.control.volume.toggleMute()),
      "Mute Toggle failed",
    );
    const volumeStatus = await getVolumeStatus();
    res.json({ ok: true, desc: "Mute Toggle", ...volumeStatus });
  } catch (e) {
    logServerError("mute toggle failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/power/on", (req, res) =>
  handle(res, "Power On", () => tv.control.power.on()),
);
app.post("/api/power/off", (req, res) =>
  handle(res, "Power Off", () => tv.control.power.off()),
);
app.post("/api/power/toggle", (req, res) =>
  handle(res, "Power Toggle", () => tv.control.power.toggle()),
);

app.post("/api/input/cycle", (req, res) =>
  handle(res, "Input Cycle", () => tv.control.input.cycle()),
);
app.post("/api/channel/up", (req, res) =>
  handle(res, "Channel Up", () => tv.control.channel.up()),
);
app.post("/api/channel/down", (req, res) =>
  handle(res, "Channel Down", () => tv.control.channel.down()),
);
app.post("/api/channel/previous", (req, res) =>
  handle(res, "Previous Channel", () => tv.control.channel.previous()),
);
app.post("/api/info-key", (req, res) =>
  handle(res, "Info", () => tv.control.info()),
);
app.post("/api/nav/exit", (req, res) =>
  handle(res, "Exit", () => tv.control.navigate.exit()),
);
app.post("/api/smartcast", (req, res) =>
  handle(res, "SmartCast", () => tv.control.smartcast()),
);
app.post("/api/media/play", (req, res) =>
  handle(res, "Play", () => tv.control.media.play()),
);
app.post("/api/media/pause", (req, res) =>
  handle(res, "Pause", () => tv.control.media.pause()),
);
app.post("/api/media/seek-forward", (req, res) =>
  handle(res, "Seek Forward", () => tv.control.media.seek.forward()),
);
app.post("/api/media/seek-back", (req, res) =>
  handle(res, "Seek Back", () => tv.control.media.seek.back()),
);
app.post("/api/media/cc", (req, res) =>
  handle(res, "Captions", () => tv.control.media.cc()),
);

app.get("/api/input", async (req, res) => {
  try {
    if (!tv)
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });

    const [list, current, devicesPayload] = await Promise.all([
      tv.input.list(),
      tv.input.current(),
      retrySmartCastRequest(() => tv.settings.devices.get()).catch(() => null),
    ]);
    const items = Array.isArray(list && list.ITEMS) ? list.ITEMS : [];
    const currentValue =
      current &&
      Array.isArray(current.ITEMS) &&
      current.ITEMS[0] &&
      current.ITEMS[0].VALUE
        ? String(current.ITEMS[0].VALUE)
        : "";

    const baseInputs = items.map((item) => {
      const builtInName = item && item.NAME ? String(item.NAME) : "";
      const customName =
        item &&
        item.VALUE &&
        typeof item.VALUE === "object" &&
        item.VALUE.NAME
          ? String(item.VALUE.NAME)
          : "";

      return {
        id: item && item.CNAME ? String(item.CNAME) : builtInName,
        name: builtInName,
        label: customName && customName !== builtInName ? customName : builtInName,
        customName,
        source: "input-list",
        visible: true,
        enabled: true,
        inputType: null,
        raw: item || null,
        selected:
          builtInName.toLowerCase() === currentValue.toLowerCase() ||
          customName.toLowerCase() === currentValue.toLowerCase(),
      };
    });

    const inputs = baseInputs.sort((left, right) =>
      `${left.selected ? "0" : "1"}${left.label || left.name}`.localeCompare(
        `${right.selected ? "0" : "1"}${right.label || right.name}`,
      ),
    );

    res.json({
      ok: true,
      current: currentValue,
      inputs,
    });
  } catch (e) {
    logServerError("input list failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.get("/api/apps", (req, res) => {
  res.json({
    ok: true,
    apps: APP_DEFINITIONS.map(({ appId, nameSpace, message, ...appDefinition }) => appDefinition),
    source: "curated",
  });
});

function getConfiguredApp(appId) {
  return APP_DEFINITIONS.find((appDefinition) => appDefinition.id === appId) || null;
}

function launchConfiguredApp(appId) {
  const appDefinition = getConfiguredApp(appId);
  if (!appDefinition) {
    throw new Error("App not found");
  }

  return tv.app.launch(
    appDefinition.message,
    String(appDefinition.appId),
    appDefinition.nameSpace,
  );
}

app.post("/api/input/set", async (req, res) => {
  try {
    if (!tv)
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });

    const requested = {
      id: String((req.body && req.body.id) || "").trim(),
      name: String((req.body && req.body.name) || "").trim(),
      label: String((req.body && req.body.label) || "").trim(),
      customName: String((req.body && req.body.customName) || "").trim(),
    };

    if (!requested.id && !requested.name && !requested.label && !requested.customName)
      return res.status(400).json({
        ok: false,
        error: "Input selection is required",
      });

    const list = ensureSmartCastSuccess(await tv.input.list(), "Input list failed");
    const items = Array.isArray(list && list.ITEMS) ? list.ITEMS : [];
    const requestedName = getRequestedInputName(requested);

    if (!requestedName) {
      return res.status(400).json({
        ok: false,
        error: "Input selection is required",
      });
    }

    ensureSmartCastSuccess(await tv.input.set(requestedName), "Input switch failed");
    await new Promise((resolve) => setTimeout(resolve, 900));
    const currentValue = mapCurrentInputLabel(
      getCurrentInputValue(
        ensureSmartCastSuccess(await tv.input.current(), "Current input lookup failed"),
      ) || requestedName,
      items,
    );

    res.json({
      ok: true,
      name: requestedName,
      current: currentValue,
    });
  } catch (e) {
    logServerError("input set failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/advanced/picture-mode/cycle", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    }

    const payload = ensureSmartCastSuccess(
      await tv.settings.picture.mode.get(),
      "Picture mode lookup failed",
    );
    const pictureMode = Array.isArray(payload && payload.ITEMS)
      ? payload.ITEMS.find((item) => item && item.CNAME === "picture_mode")
      : null;

    const currentValue = pictureMode && pictureMode.VALUE ? String(pictureMode.VALUE) : "";
    const values = Array.isArray(pictureMode && pictureMode.ELEMENTS)
      ? pictureMode.ELEMENTS.map((value) => String(value))
      : [];

    if (!pictureMode || !values.length) {
      throw new Error("Picture modes unavailable");
    }

    const currentIndex = Math.max(
      0,
      values.findIndex((value) => normalizeCompareValue(value) === normalizeCompareValue(currentValue)),
    );
    const nextValue = values[(currentIndex + 1) % values.length];

    ensureSmartCastSuccess(
      await tv.settings.picture.mode.set(nextValue),
      "Picture mode update failed",
    );

    res.json({
      ok: true,
      current: nextValue,
      values,
    });
  } catch (e) {
    logServerError("picture mode cycle failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.get("/api/advanced/overview", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    }

    const overview = await getAdvancedOverview();
    res.json({
      ok: true,
      ...overview,
    });
  } catch (e) {
    logServerError("advanced overview failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/advanced/open-url", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    }

    const url = String((req.body && req.body.url) || "").trim();
    if (!isHttpUrl(url)) {
      return res.status(400).json({
        ok: false,
        error: "Enter a valid http:// or https:// URL",
      });
    }

    ensureSmartCastSuccess(await tv.app.launch(url), "URL launch failed");
    res.json({
      ok: true,
      url,
    });
  } catch (e) {
    logServerError("advanced open url failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/advanced/picture-mode", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    }

    const value = String((req.body && req.body.value) || "").trim();
    if (!value) {
      return res.status(400).json({
        ok: false,
        error: "Picture mode is required",
      });
    }

    ensureSmartCastSuccess(
      await tv.settings.picture.mode.set(value),
      "Picture mode update failed",
    );
    res.json({
      ok: true,
      current: value,
    });
  } catch (e) {
    logServerError("picture mode set failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/advanced/sleep-timer", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    }

    const value = String((req.body && req.body.value) || "").trim();
    if (!value) {
      return res.status(400).json({
        ok: false,
        error: "Sleep timer value is required",
      });
    }

    await setSystemTimerValue("sleep_timer", value, "Sleep timer update failed");
    res.json({
      ok: true,
      current: value,
    });
  } catch (e) {
    logServerError("sleep timer set failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/advanced/auto-power-off", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    }

    const value = String((req.body && req.body.value) || "").trim();
    if (!value) {
      return res.status(400).json({
        ok: false,
        error: "Auto power off value is required",
      });
    }

    await setSystemTimerValue("auto_power_off_timer", value, "Auto power off update failed");
    res.json({
      ok: true,
      current: value,
    });
  } catch (e) {
    logServerError("auto power off set failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/advanced/system/power-mode", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const value = String((req.body && req.body.value) || "").trim();
    if (!value) {
      return res.status(400).json({ ok: false, error: "Power mode value is required" });
    }

    await setChildSettingValue(
      "/menu_native/dynamic/tv_settings/system/power_mode",
      "power_mode",
      value,
      "Power mode update failed",
    );

    res.json({ ok: true, current: value });
  } catch (e) {
    logServerError("power mode set failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/advanced/system/input-at-power-on", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const value = String((req.body && req.body.value) || "").trim();
    if (!value) {
      return res.status(400).json({ ok: false, error: "Input at power on value is required" });
    }

    await setChildSettingValue(
      "/menu_native/dynamic/tv_settings/system/input_at_power_on",
      "input_at_power_on",
      value,
      "Input at power on update failed",
    );

    res.json({ ok: true, current: value });
  } catch (e) {
    logServerError("input at power on set failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/advanced/system/usb-power", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const value = String((req.body && req.body.value) || "").trim();
    if (!value) {
      return res.status(400).json({ ok: false, error: "USB power value is required" });
    }

    await setChildSettingValue(
      "/menu_native/dynamic/tv_settings/system/usb_power",
      "usb_power",
      value,
      "USB power update failed",
    );

    res.json({ ok: true, current: value });
  } catch (e) {
    logServerError("usb power set failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/advanced/audio/output", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const value = String((req.body && req.body.value) || "").trim();
    if (!value) {
      return res.status(400).json({ ok: false, error: "Audio output value is required" });
    }

    await setChildSettingValue(
      "/menu_native/dynamic/tv_settings/audio/tv_speakers",
      "tv_speakers",
      value,
      "Audio output update failed",
    );

    res.json({ ok: true, current: value });
  } catch (e) {
    logServerError("audio output set failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/advanced/setting", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const pathname = String((req.body && req.body.path) || "").trim();
    const cname = String((req.body && req.body.cname) || "").trim();
    const value = String((req.body && req.body.value) || "").trim();

    if (!pathname.startsWith("/menu_native/dynamic/tv_settings/")) {
      return res.status(400).json({ ok: false, error: "Invalid setting path" });
    }

    if (!cname) {
      return res.status(400).json({ ok: false, error: "Setting id is required" });
    }

    if (!value) {
      return res.status(400).json({ ok: false, error: "Setting value is required" });
    }

    await setChildSettingValue(pathname, cname, value, `${cname} update failed`);
    res.json({ ok: true, path: pathname, cname, current: value });
  } catch (e) {
    logServerError("advanced generic setting update failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/advanced/app-launch", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({ ok: false, error: "Not paired" });
    }

    const appId = String((req.body && req.body.appId) || "").trim();
    const nameSpaceRaw = Number((req.body && req.body.nameSpace) || 4);
    const messageInput = (req.body && req.body.message) || "";

    if (!appId) {
      return res.status(400).json({ ok: false, error: "App ID is required" });
    }

    const message = getAppMessage(messageInput);
    ensureSmartCastSuccess(
      await retrySmartCastRequest(() => tv.app.launch(message, appId, Number.isFinite(nameSpaceRaw) ? nameSpaceRaw : 4)),
      "Advanced app launch failed",
    );

    res.json({ ok: true, appId, nameSpace: Number.isFinite(nameSpaceRaw) ? nameSpaceRaw : 4 });
  } catch (e) {
    logServerError("advanced app launch failed", e);
    res.status(500).json({ ok: false, error: e && e.message ? e.message : String(e) });
  }
});

app.post("/api/advanced/action", async (req, res) => {
  try {
    if (!tv) {
      return res.status(400).json({
        ok: false,
        error: "Not paired",
      });
    }

    const actionId = String((req.body && req.body.actionId) || "").trim();
    if (!actionId) {
      return res.status(400).json({
        ok: false,
        error: "Action is required",
      });
    }

    const actionMap = {
      auto_channel_scan: () =>
        executeActionFromMenu(() => tv.settings.channels.get(), "auto_channel_scan", "Channel scan failed"),
      find_new_channel: () =>
        executeActionFromMenu(() => tv.settings.channels.get(), "find_new_channel", "Find new channels failed"),
      start_soft_ap: () =>
        executeActionFromMenu(() => tv.settings.cast.get(), "start_soft_ap", "Start SoftAP failed"),
      stop_soft_ap: () =>
        executeActionFromMenu(() => tv.settings.cast.get(), "stop_soft_ap", "Stop SoftAP failed"),
      save_picture_mode: () =>
        executeActionFromMenu(
          () => tv.settings.picture.modeEdit.get(),
          "save_picture_mode",
          "Save picture mode failed",
        ),
      reset_picture_mode: () =>
        executeActionFromMenu(
          () => tv.settings.picture.modeEdit.get(),
          "reset_picture_mode",
          "Reset picture mode failed",
        ),
    };

    const handler = actionMap[actionId];
    if (!handler) {
      return res.status(404).json({
        ok: false,
        error: "Action not found",
      });
    }

    const result = await handler();
    const castPayload = actionId === "start_soft_ap" || actionId === "stop_soft_ap"
      ? ensureSmartCastSuccess(await retrySmartCastRequest(() => tv.settings.cast.get()), "Cast lookup failed")
      : null;
    const systemPayload = actionId === "start_soft_ap" || actionId === "stop_soft_ap" || actionId === "save_picture_mode" || actionId === "reset_picture_mode"
      ? ensureSmartCastSuccess(await retrySmartCastRequest(() => tv.settings.system.information.tv.get()), "TV info lookup failed")
      : null;
    const devicesPayload = actionId === "auto_channel_scan" || actionId === "find_new_channel"
      ? ensureSmartCastSuccess(await retrySmartCastRequest(() => tv.settings.devices.get()), "Devices lookup failed")
      : null;

    res.json({
      ok: true,
      actionId,
      label: result && result.item && result.item.NAME ? String(result.item.NAME).trim() : actionId,
      message: buildActionSuccessMessage(actionId, {
        item: result && result.item ? result.item : null,
        castPayload,
        systemPayload,
        devicesPayload,
      }),
    });
  } catch (e) {
    logServerError("advanced action failed", e);
    res.status(500).json({
      ok: false,
      error: e && e.message ? e.message : String(e),
    });
  }
});

app.post("/api/advanced/blank-screen", (req, res) =>
  handle(res, "Blank Screen", () => tv.settings.timers.blankScreen.execute()),
);

app.post("/api/home", (req, res) =>
  handle(res, "Home", () => tv.app.launch("", "1", 4)),
);
app.post("/api/app/:appId", (req, res) => {
  const appDefinition = getConfiguredApp(String(req.params.appId || "").trim());
  if (!appDefinition) {
    return res.status(404).json({
      ok: false,
      error: "App not found",
    });
  }

  return handle(res, `Launch ${appDefinition.name}`, () =>
    launchConfiguredApp(appDefinition.id),
  );
});

app.use(
  "/",
  express.static(ASTRO_DIST_DIR, {
    index: "index.html",
  }),
);

app.listen(PORT, () => {
  console.log(
    `Web UI available at http://localhost:${PORT} ${tv ? `(paired, TV ${currentIp})` : "(not paired — open the Web UI to pair)"}`,
  );
});