import crypto from "crypto";
import os from "os";
import { execSync } from "child_process";
import fs from "fs";
import { databaseLogger } from "./logger.js";

interface HardwareInfo {
  cpuId?: string;
  motherboardUuid?: string;
  diskSerial?: string;
  biosSerial?: string;
  tpmInfo?: string;
  macAddresses?: string[];
}

/**
 * 硬件指纹生成器 - 使用真实硬件特征生成稳定的设备指纹
 * 相比软件环境指纹，硬件指纹在虚拟化和容器环境中更加稳定
 */
class HardwareFingerprint {
  private static readonly CACHE_KEY = "cached_hardware_fingerprint";
  private static cachedFingerprint: string | null = null;

  /**
   * 生成硬件指纹
   * 优先级：缓存 > 环境变量 > 硬件检测
   */
  static generate(): string {
    try {
      if (this.cachedFingerprint) {
        return this.cachedFingerprint;
      }

      const envFingerprint = process.env.TERMIX_HARDWARE_SEED;
      if (envFingerprint && envFingerprint.length >= 32) {
        databaseLogger.info("Using hardware seed from environment variable", {
          operation: "hardware_fingerprint_env",
        });
        this.cachedFingerprint = this.hashFingerprint(envFingerprint);
        return this.cachedFingerprint;
      }

      const hwInfo = this.detectHardwareInfo();
      const fingerprint = this.generateFromHardware(hwInfo);

      this.cachedFingerprint = fingerprint;

      return fingerprint;
    } catch (error) {
      databaseLogger.error("Hardware fingerprint generation failed", error, {
        operation: "hardware_fingerprint_failed",
      });

      return this.generateFallbackFingerprint();
    }
  }

  /**
   * 检测硬件信息
   */
  private static detectHardwareInfo(): HardwareInfo {
    const platform = os.platform();
    const hwInfo: HardwareInfo = {};

    try {
      switch (platform) {
        case "linux":
          hwInfo.cpuId = this.getLinuxCpuId();
          hwInfo.motherboardUuid = this.getLinuxMotherboardUuid();
          hwInfo.diskSerial = this.getLinuxDiskSerial();
          hwInfo.biosSerial = this.getLinuxBiosSerial();
          break;

        case "win32":
          hwInfo.cpuId = this.getWindowsCpuId();
          hwInfo.motherboardUuid = this.getWindowsMotherboardUuid();
          hwInfo.diskSerial = this.getWindowsDiskSerial();
          hwInfo.biosSerial = this.getWindowsBiosSerial();
          break;

        case "darwin":
          hwInfo.cpuId = this.getMacOSCpuId();
          hwInfo.motherboardUuid = this.getMacOSMotherboardUuid();
          hwInfo.diskSerial = this.getMacOSDiskSerial();
          hwInfo.biosSerial = this.getMacOSBiosSerial();
          break;
      }

      // 所有平台都尝试获取MAC地址
      hwInfo.macAddresses = this.getStableMacAddresses();
    } catch (error) {
      databaseLogger.error("Some hardware detection failed", error, {
        operation: "hardware_detection_partial_failure",
        platform,
      });
    }

    return hwInfo;
  }

  /**
   * Linux平台硬件信息获取
   */
  private static getLinuxCpuId(): string | undefined {
    try {
      // 尝试多种方法获取CPU信息
      const methods = [
        () =>
          fs
            .readFileSync("/proc/cpuinfo", "utf8")
            .match(/processor\s*:\s*(\d+)/)?.[1],
        () =>
          execSync('dmidecode -t processor | grep "ID:" | head -1', {
            encoding: "utf8",
          }).trim(),
        () =>
          execSync(
            'cat /proc/cpuinfo | grep "cpu family\\|model\\|stepping" | md5sum',
            { encoding: "utf8" },
          ).split(" ")[0],
      ];

      for (const method of methods) {
        try {
          const result = method();
          if (result && result.length > 0) return result;
        } catch {
          /* 继续尝试下一种方法 */
        }
      }
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getLinuxMotherboardUuid(): string | undefined {
    try {
      // 尝试多种方法获取主板UUID
      const methods = [
        () => fs.readFileSync("/sys/class/dmi/id/product_uuid", "utf8").trim(),
        () => fs.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim(),
        () => execSync("dmidecode -s system-uuid", { encoding: "utf8" }).trim(),
      ];

      for (const method of methods) {
        try {
          const result = method();
          if (result && result.length > 0 && result !== "Not Settable")
            return result;
        } catch {
          /* 继续尝试下一种方法 */
        }
      }
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getLinuxDiskSerial(): string | undefined {
    try {
      // 获取根分区所在磁盘的序列号
      const rootDisk = execSync(
        "df / | tail -1 | awk '{print $1}' | sed 's/[0-9]*$//'",
        { encoding: "utf8" },
      ).trim();
      if (rootDisk) {
        const serial = execSync(
          `udevadm info --name=${rootDisk} | grep ID_SERIAL= | cut -d= -f2`,
          { encoding: "utf8" },
        ).trim();
        if (serial && serial.length > 0) return serial;
      }
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getLinuxBiosSerial(): string | undefined {
    try {
      const methods = [
        () => fs.readFileSync("/sys/class/dmi/id/board_serial", "utf8").trim(),
        () =>
          execSync("dmidecode -s baseboard-serial-number", {
            encoding: "utf8",
          }).trim(),
      ];

      for (const method of methods) {
        try {
          const result = method();
          if (result && result.length > 0 && result !== "Not Specified")
            return result;
        } catch {
          /* 继续尝试下一种方法 */
        }
      }
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  /**
   * Windows平台硬件信息获取
   */
  private static getWindowsCpuId(): string | undefined {
    try {
      const result = execSync("wmic cpu get ProcessorId /value", {
        encoding: "utf8",
      });
      const match = result.match(/ProcessorId=(.+)/);
      return match?.[1]?.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getWindowsMotherboardUuid(): string | undefined {
    try {
      const result = execSync("wmic csproduct get UUID /value", {
        encoding: "utf8",
      });
      const match = result.match(/UUID=(.+)/);
      return match?.[1]?.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getWindowsDiskSerial(): string | undefined {
    try {
      const result = execSync("wmic diskdrive get SerialNumber /value", {
        encoding: "utf8",
      });
      const match = result.match(/SerialNumber=(.+)/);
      return match?.[1]?.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getWindowsBiosSerial(): string | undefined {
    try {
      const result = execSync("wmic baseboard get SerialNumber /value", {
        encoding: "utf8",
      });
      const match = result.match(/SerialNumber=(.+)/);
      return match?.[1]?.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  /**
   * macOS平台硬件信息获取
   */
  private static getMacOSCpuId(): string | undefined {
    try {
      const result = execSync("sysctl -n machdep.cpu.brand_string", {
        encoding: "utf8",
      });
      return result.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getMacOSMotherboardUuid(): string | undefined {
    try {
      const result = execSync(
        'system_profiler SPHardwareDataType | grep "Hardware UUID"',
        { encoding: "utf8" },
      );
      const match = result.match(/Hardware UUID:\s*(.+)/);
      return match?.[1]?.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getMacOSDiskSerial(): string | undefined {
    try {
      const result = execSync(
        'system_profiler SPStorageDataType | grep "Serial Number"',
        { encoding: "utf8" },
      );
      const match = result.match(/Serial Number:\s*(.+)/);
      return match?.[1]?.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  private static getMacOSBiosSerial(): string | undefined {
    try {
      const result = execSync(
        'system_profiler SPHardwareDataType | grep "Serial Number"',
        { encoding: "utf8" },
      );
      const match = result.match(/Serial Number \(system\):\s*(.+)/);
      return match?.[1]?.trim();
    } catch {
      /* 忽略错误 */
    }
    return undefined;
  }

  /**
   * 获取稳定的MAC地址
   * 排除虚拟接口和临时接口
   */
  private static getStableMacAddresses(): string[] {
    try {
      const networkInterfaces = os.networkInterfaces();
      const macAddresses: string[] = [];

      for (const [interfaceName, interfaces] of Object.entries(
        networkInterfaces,
      )) {
        if (!interfaces) continue;

        // 排除虚拟接口和Docker接口
        if (interfaceName.match(/^(lo|docker|veth|br-|virbr)/)) continue;

        for (const iface of interfaces) {
          if (
            !iface.internal &&
            iface.mac &&
            iface.mac !== "00:00:00:00:00:00" &&
            !iface.mac.startsWith("02:42:")
          ) {
            // Docker接口特征
            macAddresses.push(iface.mac);
          }
        }
      }

      return macAddresses.sort(); // 排序确保一致性
    } catch {
      return [];
    }
  }

  /**
   * 从硬件信息生成指纹
   */
  private static generateFromHardware(hwInfo: HardwareInfo): string {
    const components = [
      hwInfo.motherboardUuid, // 最稳定的标识符
      hwInfo.cpuId,
      hwInfo.biosSerial,
      hwInfo.diskSerial,
      hwInfo.macAddresses?.join(","),
      os.platform(), // 操作系统平台
      os.arch(), // CPU架构
    ].filter(Boolean); // 过滤空值

    if (components.length === 0) {
      throw new Error("No hardware identifiers found");
    }

    return this.hashFingerprint(components.join("|"));
  }

  /**
   * 生成回退指纹（当硬件检测失败时）
   */
  private static generateFallbackFingerprint(): string {
    const fallbackComponents = [
      os.hostname(),
      os.platform(),
      os.arch(),
      process.cwd(),
      "fallback-mode",
    ];

    databaseLogger.warn(
      "Using fallback fingerprint due to hardware detection failure",
      {
        operation: "hardware_fingerprint_fallback",
      },
    );

    return this.hashFingerprint(fallbackComponents.join("|"));
  }

  /**
   * 标准化指纹哈希
   */
  private static hashFingerprint(data: string): string {
    return crypto.createHash("sha256").update(data).digest("hex");
  }

  /**
   * 获取硬件指纹信息（用于调试和显示）
   */
  static getHardwareInfo(): HardwareInfo & { fingerprint: string } {
    const hwInfo = this.detectHardwareInfo();
    return {
      ...hwInfo,
      fingerprint: this.generate().substring(0, 16),
    };
  }

  /**
   * 验证当前硬件指纹
   */
  static validateFingerprint(expectedFingerprint: string): boolean {
    try {
      const currentFingerprint = this.generate();
      return currentFingerprint === expectedFingerprint;
    } catch {
      return false;
    }
  }

  /**
   * 清除缓存（用于测试）
   */
  static clearCache(): void {
    this.cachedFingerprint = null;
  }
}

export { HardwareFingerprint };
export type { HardwareInfo };