import type { VersionInfo } from "@/api/types";
import { App } from "@capacitor/app";
import { alertController } from "@ionic/vue";
import { client } from "@/api";
import { i18n } from "@/locales";

/**
 * 版本比较函数
 * @param version1 版本号1，如 "1.2.3"
 * @param version2 版本号2，如 "1.2.4"
 * @returns 如果 version1 < version2 返回 -1，相等返回 0，大于返回 1
 */
function compareVersion(version1: string, version2: string): number {
  const v1Parts = version1.split(".").map(Number);
  const v2Parts = version2.split(".").map(Number);
  const maxLength = Math.max(v1Parts.length, v2Parts.length);

  for (let i = 0; i < maxLength; i++) {
    const v1Part = v1Parts[i] || 0;
    const v2Part = v2Parts[i] || 0;

    if (v1Part < v2Part)
      return -1;
    if (v1Part > v2Part)
      return 1;
  }

  return 0;
}

const updateUrls = {
  ios: "https://apps.apple.com/app/id123456789",
  android: "https://play.google.com/store/apps/details?id=riwa.ionic.app",
  browser: "",
} as const;

/**
 * 应用更新检查
 */
export function useAppUpdate() {
  const state = reactive({
    isChecking: false,
    hasUpdate: false,
    latestVersion: "",
    currentVersion: "",
    forceUpdate: false,
    updateMessage: "",
    updateUrl: "",
  });
  const platform = usePlatform();

  /**
   * 获取当前应用版本
   */
  async function getCurrentVersion(): Promise<string> {
    try {
      // 在原生平台使用 Capacitor App API
      if (platform !== "browser") {
        const appInfo = await App.getInfo();
        return appInfo.version;
      }

      // Web 平台从编译时注入的全局变量获取（来自 package.json）
      return __APP_VERSION__;
    }
    catch (error) {
      console.error("获取当前版本失败:", error);
      return "0.0.1";
    }
  }

  /**
   * 检查是否有新版本
   */
  async function checkForUpdate(): Promise<{
    hasUpdate: boolean;
    currentVersion: string;
    latestVersion?: string;
    forceUpdate?: boolean;
    updateMessage?: string;
    updateUrl?: string;
  }> {
    state.isChecking = true;
    try {
      // 1. 获取当前版本
      const current = await getCurrentVersion();
      state.currentVersion = current;
      // 2. 从服务器检查最新版本
      // TODO: 后端接口实现后替换为真实 API 调用
      // const response = await client.api.app.version.get({
      //   query: {
      //     platform: platform === 'ios' ? 'ios' : platform === 'android' ? 'android' : 'web',
      //     currentVersion: current,
      //   },
      // })

      // 模拟后端返回数据（开发阶段）
      await new Promise(resolve => setTimeout(resolve, 500));
      const versionInfo: VersionInfo = {
        version: "0.0.2", // 模拟有新版本
        forceUpdate: false,
        updateMessage: "修复了一些问题并优化了性能",
        updateUrl: updateUrls[platform] || "",
        minSupportVersion: "0.0.1",
      };

      // 真实 API 调用后的逻辑
      // if (response.error) {
      //   console.error('检查更新失败:', response.error)
      //   return {
      //     hasUpdate: false,
      //     currentVersion: current,
      //   }
      // }
      // const versionInfo = response.data as VersionInfo

      // 3. 版本比较
      const isNewVersion = compareVersion(current, versionInfo.version) < 0;

      // 更新状态
      state.latestVersion = versionInfo.version;
      state.hasUpdate = isNewVersion;
      state.forceUpdate = versionInfo.forceUpdate || false;
      state.updateMessage = versionInfo.updateMessage || "";
      state.updateUrl = versionInfo.updateUrl || "";
      // 4. 检查是否低于最低支持版本（强制更新）
      if (versionInfo.minSupportVersion) {
        const isBelowMinVersion = compareVersion(current, versionInfo.minSupportVersion) < 0;
        if (isBelowMinVersion) {
          state.forceUpdate = true;
        }
      }

      return {
        hasUpdate: isNewVersion,
        currentVersion: current,
        latestVersion: versionInfo.version,
        forceUpdate: state.forceUpdate,
        updateMessage: state.updateMessage,
        updateUrl: state.updateUrl,
      };
    }
    catch (error) {
      console.error("检查更新失败:", error);
      const current = state.currentVersion || await getCurrentVersion();
      return {
        hasUpdate: false,
        currentVersion: current,
      };
    }
    finally {
      state.isChecking = false;
    }
  }

  /**
   * 打开应用商店更新页面
   */
  async function openStoreUpdate(): Promise<void> {
    if (!state.updateUrl) {
      console.warn("没有提供更新链接");
      return;
    }

    // 在原生平台打开外部链接
    if (platform !== "browser") {
      window.open(state.updateUrl, "_system");
    }
    else {
      // Web 平台直接打开链接
      window.open(state.updateUrl, "_blank");
    }
  }

  /**
   * 显示更新提示对话框
   */
  async function showUpdateDialog(): Promise<void> {
    const alert = await alertController.create({
      header: i18n.global.t("app.update.title"),
      message: state.updateMessage || i18n.global.t("app.update.message"),
      backdropDismiss: !state.forceUpdate, // 强制更新时不允许关闭
      buttons: state.forceUpdate
        ? [
            {
              text: i18n.global.t("app.update.now"),
              role: "confirm",
              handler: () => {
                openStoreUpdate();
              },
            },
          ]
        : [
            {
              text: i18n.global.t("app.update.later"),
              role: "cancel",
            },
            {
              text: i18n.global.t("app.update.now"),
              role: "confirm",
              handler: () => {
                openStoreUpdate();
              },
            },
          ],
    });

    await alert.present();
  }

  /**
   * 应用更新（重新加载应用或打开商店）
   */
  async function applyUpdate(): Promise<void> {
    // 如果是原生应用且有更新链接，打开应用商店
    if (platform !== "browser" && state.updateUrl) {
      await openStoreUpdate();
      return;
    }

    // Web 应用检查 Service Worker 更新
    if ("serviceWorker" in navigator) {
      const registration = await navigator.serviceWorker.getRegistration();
      if (registration?.waiting) {
        // 通知 Service Worker 跳过等待，立即激活
        registration.waiting.postMessage({ type: "SKIP_WAITING" });

        // 等待 Service Worker 激活后重新加载页面
        navigator.serviceWorker.addEventListener("controllerchange", () => {
          window.location.reload();
        });
        return;
      }
    }

    // 如果没有 Service Worker，直接重新加载
    window.location.reload();
  }

  /**
   * 强制刷新应用（清除缓存后重新加载）
   */
  async function forceReload(): Promise<void> {
    if ("caches" in window) {
      const cacheNames = await caches.keys();
      await Promise.all(cacheNames.map(name => caches.delete(name)));
    }
    window.location.reload();
  }

  /**
   * 自动检查更新并显示提示
   */
  async function checkAndPromptUpdate(): Promise<void> {
    const result = await checkForUpdate();

    if (result.hasUpdate) {
      await showUpdateDialog();
    }
  }

  return {
    ...toRefs(state),
    checkForUpdate,
    applyUpdate,
    forceReload,
    openStoreUpdate,
    showUpdateDialog,
    checkAndPromptUpdate,
    getCurrentVersion,
  };
}
