import { ConfigStore } from "./ConfigStore";
import { exec } from "child_process";
import { promisify } from "util";
import {
  existsSync,
  mkdirSync,
  readdirSync,
  rmSync,
  unlinkSync,
  renameSync,
} from "fs";
import { join } from "path";
import https from "https";
import http from "http";
import { createWriteStream } from "fs";
import unzipper from "unzipper";
import { sendDownloadProgress } from "../main";

const execAsync = promisify(exec);

interface GoVersion {
  version: string;
  path: string;
  isActive: boolean;
}

interface AvailableGoVersion {
  version: string;
  stable: boolean;
  downloadUrl: string;
  filename: string;
}

export class GoManager {
  private configStore: ConfigStore;
  private versionsCache: AvailableGoVersion[] = [];
  private cacheTime: number = 0;
  private readonly CACHE_DURATION = 5 * 60 * 1000; // 5 分钟缓存

  constructor(configStore: ConfigStore) {
    this.configStore = configStore;
  }

  /**
   * 获取已安装的 Go 版本
   */
  async getInstalledVersions(): Promise<GoVersion[]> {
    const versions: GoVersion[] = [];
    const goPath = this.configStore.getGoPath();
    const activeVersion = this.configStore.get("activeGoVersion") || "";

    if (!existsSync(goPath)) {
      return versions;
    }

    const dirs = readdirSync(goPath, { withFileTypes: true });
    for (const dir of dirs) {
      if (dir.isDirectory() && dir.name.startsWith("go-")) {
        const versionDir = join(goPath, dir.name);
        const goExe = join(versionDir, "bin", "go.exe");

        if (existsSync(goExe)) {
          const version = dir.name.replace("go-", "");
          versions.push({
            version,
            path: versionDir,
            isActive: version === activeVersion,
          });
        }
      }
    }

    versions.sort((a, b) => {
      const aParts = a.version.replace("go", "").split(".").map(Number);
      const bParts = b.version.replace("go", "").split(".").map(Number);
      for (let i = 0; i < 3; i++) {
        if (aParts[i] !== bParts[i]) return bParts[i] - aParts[i];
      }
      return 0;
    });

    return versions;
  }

  /**
   * 从 go.dev 获取可用版本列表
   */
  async getAvailableVersions(): Promise<AvailableGoVersion[]> {
    if (
      this.versionsCache.length > 0 &&
      Date.now() - this.cacheTime < this.CACHE_DURATION
    ) {
      return this.versionsCache;
    }

    try {
      const versions = await this.fetchVersionsFromGoDev();
      if (versions.length > 0) {
        this.versionsCache = versions;
        this.cacheTime = Date.now();
        return versions;
      }
    } catch (error) {
      console.error("[Go] Failed to fetch versions:", error);
    }

    return this.getFallbackVersions();
  }

  /**
   * 从 go.dev/dl API 获取版本列表
   */
  private async fetchVersionsFromGoDev(): Promise<AvailableGoVersion[]> {
    return new Promise((resolve, reject) => {
      const url = "https://go.dev/dl/?mode=json";

      https
        .get(
          url,
          {
            headers: { "User-Agent": "PHPer-Dev-Manager/1.0" },
            timeout: 30000,
          },
          (res) => {
            let data = "";
            res.on("data", (chunk) => (data += chunk));
            res.on("end", () => {
              try {
                const releases = JSON.parse(data);
                const versions: AvailableGoVersion[] = [];

                for (const rel of releases) {
                  const winZip = rel.files?.find(
                    (f: any) =>
                      f.os === "windows" &&
                      f.arch === "amd64" &&
                      f.filename?.endsWith(".zip"),
                  );
                  if (winZip) {
                    versions.push({
                      version: rel.version,
                      stable: rel.stable ?? true,
                      downloadUrl: `https://go.dev/dl/${winZip.filename}`,
                      filename: winZip.filename,
                    });
                  }
                }

                resolve(versions.slice(0, 30));
              } catch (e) {
                reject(e);
              }
            });
          },
        )
        .on("error", reject)
        .on("timeout", () => reject(new Error("Request timeout")));
    });
  }

  /**
   * 安装 Go 版本
   */
  async install(
    version: string,
    downloadUrl: string,
  ): Promise<{ success: boolean; message: string }> {
    try {
      const goPath = this.configStore.getGoPath();
      const tempPath = this.configStore.getTempPath();
      const zipPath = join(tempPath, `go-${version}.zip`);
      const extractDir = join(tempPath, `go-extract-${version}`);
      const versionDir = join(goPath, `go-${version}`);

      if (!existsSync(goPath)) mkdirSync(goPath, { recursive: true });
      if (!existsSync(tempPath)) mkdirSync(tempPath, { recursive: true });

      if (
        existsSync(versionDir) &&
        existsSync(join(versionDir, "bin", "go.exe"))
      ) {
        return { success: false, message: `Go ${version} 已安装` };
      }

      console.log(`[Go] Downloading ${version}...`);
      await this.downloadFile(downloadUrl, zipPath, `go-${version}`);

      console.log(`[Go] Extracting ${version}...`);
      await this.extractZip(zipPath, extractDir);

      // Go zip 解压后根目录是 "go" 文件夹，需要重命名为 go-version
      const innerGoDir = join(extractDir, "go");
      if (existsSync(innerGoDir)) {
        renameSync(innerGoDir, versionDir);
      } else {
        return { success: false, message: "解压失败：未找到 go 目录" };
      }

      try {
        unlinkSync(zipPath);
        rmSync(extractDir, { recursive: true, force: true });
      } catch (e) {
        // 忽略清理错误
      }

      if (!existsSync(join(versionDir, "bin", "go.exe"))) {
        return { success: false, message: "安装失败：go.exe 不存在" };
      }

      const goVersions = this.configStore.get("goVersions") || [];
      if (!goVersions.includes(version)) {
        goVersions.push(version);
        this.configStore.set("goVersions", goVersions);
      }

      if (goVersions.length === 1) {
        await this.setActive(version);
      }

      return { success: true, message: `Go ${version} 安装成功` };
    } catch (error: any) {
      return { success: false, message: `安装失败: ${error.message}` };
    }
  }

  /**
   * 卸载 Go 版本
   */
  async uninstall(
    version: string,
  ): Promise<{ success: boolean; message: string }> {
    try {
      const goPath = this.configStore.getGoPath();
      const versionDir = join(goPath, `go-${version}`);

      if (!existsSync(versionDir)) {
        return { success: false, message: `Go ${version} 未安装` };
      }

      const activeVersion = this.configStore.get("activeGoVersion");
      if (activeVersion === version) {
        this.configStore.set("activeGoVersion", "");
      }

      rmSync(versionDir, { recursive: true, force: true });

      const goVersions = this.configStore.get("goVersions") || [];
      const index = goVersions.indexOf(version);
      if (index > -1) {
        goVersions.splice(index, 1);
        this.configStore.set("goVersions", goVersions);
      }

      return { success: true, message: `Go ${version} 已卸载` };
    } catch (error: any) {
      return { success: false, message: `卸载失败: ${error.message}` };
    }
  }

  /**
   * 设置活动的 Go 版本
   */
  async setActive(
    version: string,
  ): Promise<{ success: boolean; message: string }> {
    try {
      const goPath = this.configStore.getGoPath();
      const versionDir = join(goPath, `go-${version}`);

      if (!existsSync(join(versionDir, "bin", "go.exe"))) {
        return { success: false, message: `Go ${version} 未安装` };
      }

      await this.addToPath(versionDir);

      this.configStore.set("activeGoVersion", version);

      return { success: true, message: `已将 Go ${version} 设为默认版本` };
    } catch (error: any) {
      return { success: false, message: `设置失败: ${error.message}` };
    }
  }

  /**
   * 获取 Go 信息
   */
  async getGoInfo(
    version: string,
  ): Promise<{ goVersion: string; path: string } | null> {
    const goPath = this.configStore.getGoPath();
    const versionDir = join(goPath, `go-${version}`);
    const goExe = join(versionDir, "bin", "go.exe");

    if (!existsSync(goExe)) return null;

    try {
      const { stdout } = await execAsync(`"${goExe}" version`, {
        timeout: 5000,
      });
      return {
        goVersion: stdout.trim(),
        path: versionDir,
      };
    } catch {
      return null;
    }
  }

  private async downloadFile(
    url: string,
    dest: string,
    name: string,
  ): Promise<void> {
    return new Promise((resolve, reject) => {
      const protocol = url.startsWith("https") ? https : http;

      const request = protocol.get(
        url,
        {
          headers: { "User-Agent": "PHPer-Dev-Manager/1.0" },
          timeout: 600000,
        },
        (response) => {
          if (response.statusCode === 301 || response.statusCode === 302) {
            const redirectUrl = response.headers.location;
            if (redirectUrl) {
              this.downloadFile(redirectUrl, dest, name)
                .then(resolve)
                .catch(reject);
              return;
            }
          }

          if (response.statusCode !== 200) {
            reject(new Error(`Download failed: HTTP ${response.statusCode}`));
            return;
          }

          const totalSize = parseInt(
            response.headers["content-length"] || "0",
            10,
          );
          let downloadedSize = 0;
          let lastProgressTime = 0;

          const file = createWriteStream(dest);

          response.on("data", (chunk) => {
            downloadedSize += chunk.length;
            const now = Date.now();
            if (now - lastProgressTime > 500) {
              const progress =
                totalSize > 0
                  ? Math.round((downloadedSize / totalSize) * 100)
                  : 0;
              sendDownloadProgress("go", progress, downloadedSize, totalSize);
              lastProgressTime = now;
            }
          });

          response.pipe(file);

          file.on("finish", () => {
            file.close();
            sendDownloadProgress("go", 100, totalSize, totalSize);
            resolve();
          });

          file.on("error", (err) => {
            unlinkSync(dest);
            reject(err);
          });
        },
      );

      request.on("error", reject);
      request.on("timeout", () => {
        request.destroy();
        reject(new Error("Download timeout"));
      });
    });
  }

  private async extractZip(zipPath: string, destDir: string): Promise<void> {
    return new Promise((resolve, reject) => {
      const { createReadStream } = require("fs");
      createReadStream(zipPath)
        .pipe(unzipper.Extract({ path: destDir }))
        .on("close", resolve)
        .on("error", reject);
    });
  }

  private async addToPath(goPath: string): Promise<void> {
    const binPath = join(goPath, "bin");
    const psScript = `
$ErrorActionPreference = 'Stop'
$newPath = '${binPath.replace(/\\/g, "\\\\")}'

$currentPath = [Environment]::GetEnvironmentVariable('Path', 'User')
$pathArray = $currentPath -split ';' | Where-Object { $_ -ne '' }

$filteredPaths = $pathArray | Where-Object {
  $p = $_.ToLower()
  -not ($p -like '*\\\\go-*\\\\bin*' -or $p -like '*\\\\go\\\\bin*' -or $p -like '*phper*go*')
}

$newPathArray = @($newPath) + $filteredPaths
$finalPath = ($newPathArray | Select-Object -Unique) -join ';'
[Environment]::SetEnvironmentVariable('Path', $finalPath, 'User')
Write-Output "PATH updated"
`;

    const tempPs1 = join(this.configStore.getTempPath(), "update_go_path.ps1");
    const { writeFileSync } = require("fs");
    writeFileSync(tempPs1, psScript, "utf-8");

    try {
      await execAsync(`powershell -ExecutionPolicy Bypass -File "${tempPs1}"`, {
        timeout: 30000,
      });
    } finally {
      try {
        unlinkSync(tempPs1);
      } catch (e) {}
    }
  }

  private getFallbackVersions(): AvailableGoVersion[] {
    return [
      {
        version: "go1.25.7",
        stable: true,
        downloadUrl: "https://go.dev/dl/go1.25.7.windows-amd64.zip",
        filename: "go1.25.7.windows-amd64.zip",
      },
      {
        version: "go1.24.13",
        stable: true,
        downloadUrl: "https://go.dev/dl/go1.24.13.windows-amd64.zip",
        filename: "go1.24.13.windows-amd64.zip",
      },
      {
        version: "go1.23.5",
        stable: true,
        downloadUrl: "https://go.dev/dl/go1.23.5.windows-amd64.zip",
        filename: "go1.23.5.windows-amd64.zip",
      },
      {
        version: "go1.22.14",
        stable: true,
        downloadUrl: "https://go.dev/dl/go1.22.14.windows-amd64.zip",
        filename: "go1.22.14.windows-amd64.zip",
      },
    ];
  }
}