
// 更新配置
const baseURL = 'http://49.232.154.205:10900/fadapp-update/attractor'

// 匹配第一个出现的数字版本号
function extractVersionNum(str) {
  const match = str.match(/(\d+\.\d+(?:\.\d+)?)/);
  return match ? match[1] : '0.0.0';
}

function compareVersion(v1, v2) {
  v1 = extractVersionNum(v1).split('.').map(Number);
  v2 = extractVersionNum(v2).split('.').map(Number);
  for (let i = 0; i < Math.max(v1.length, v2.length); i++) {
    const n1 = v1[i] || 0;
    const n2 = v2[i] || 0;
    if (n1 > n2) return 1;
    if (n1 < n2) return -1;
  }
  return 0;
}

function clearIgnoredVersion() {
  uni.removeStorageSync('ignoredVersion');
  console.log('已清除忽略的版本设置');
}

function getIgnoredVersion() {
  return uni.getStorageSync('ignoredVersion');
}

function setIgnoredVersion(version) {
  console.log('已设置忽略版本:', version);
}

function checkVersionCompatibility(wgtVersion, baseVersion) {
  console.log('检查版本兼容性:', { wgtVersion, baseVersion });
  const wgtMajor = extractVersionNum(wgtVersion).split('.')[0];
  const baseMajor = extractVersionNum(baseVersion).split('.')[0];
  if (wgtMajor !== baseMajor) {
    console.warn('主版本号不匹配:', { wgtMajor, baseMajor });
    return false;
  }
  if (compareVersion(wgtVersion, baseVersion) <= 0) {
    console.warn('wgt版本不高于基座版本');
    return false;
  }
  return true;
}

function checkStorageSpace() {
  return new Promise((resolve, reject) => {
    // #ifdef APP-PLUS
    if (typeof plus !== 'undefined' && plus.io) {
      plus.io.requestFileSystem(plus.io.PRIVATE_DOC, (fs) => {
        fs.root.getDirectory('temp', { create: true }, (dir) => {
          resolve(true);
        }, (error) => {
          console.error('检查存储空间失败:', error);
          reject(error);
        });
      });
    } else {
      resolve(true);
    }
    // #endif
    // #ifndef APP-PLUS
    resolve(true);
    // #endif
  });
}

function checkUpdate(forceCheck = false) {
  // 1. 准备本地版本信息
  const localVersion = plus.runtime.version; // 基座版本
  const staticVersion = '0.1.0'; // 静态默认版本
	// const localWgtVersion = staticVersion;
  const localWgtVersion = uni.getStorageSync('wgtVersion') || staticVersion; // 本地wgt版本（从存储获取或用默认）
  const currentVersion = compareVersion(localWgtVersion, localVersion) > 0 
    ? localWgtVersion 
    : localVersion; // 当前有效版本（取两者较高者）

  // 2. 请求远程版本信息
  uni.request({
    url: `${baseURL}/version.json?t=${Date.now()}`, // 加时间戳防缓存
    success: handleRemoteVersionSuccess,
    fail: handleCheckFail
  });


  // 处理远程版本请求成功
  function handleRemoteVersionSuccess(res) {
    const remoteVersion = res.data.version;
    const wgtUrl = res.data.wgtUrl;

    console.log(
      '本地基座版本:', localVersion,
      '本地wgt版本:', localWgtVersion,
      '当前对比版本:', currentVersion,
      '远程版本:', remoteVersion
    );

    // 远程版本高于本地wgt版本时才需要处理更新
    if (compareVersion(remoteVersion, localWgtVersion) > 0) {
      handleNeedUpdate(remoteVersion, wgtUrl);
    } else {
      console.log('当前已是最新版本');
    }
  }


  // 处理需要更新的情况
  function handleNeedUpdate(remoteVersion, wgtUrl) {
    // 2.1 先检查版本兼容性
    if (!checkVersionCompatibility(remoteVersion, localWgtVersion)) {
      handleIncompatibleVersion(remoteVersion);
      return;
    }

    // 2.2 检查用户是否忽略过该版本（非强制检查时）
    const ignoredVersion = uni.getStorageSync('ignoredVersion');
    if (!forceCheck && ignoredVersion === remoteVersion) {
      console.log('用户已选择忽略此版本:', remoteVersion);
      return;
    }

    // 2.3 显示更新提示
    showUpdateModal(remoteVersion, wgtUrl);
  }


  // 处理版本不兼容的情况（引导下载完整安装包）
  function handleIncompatibleVersion(remoteVersion) {
    console.warn('版本不兼容，跳转到浏览器下载新版安装包');
    uni.showModal({
      title: '版本不兼容',
      content: `新版本 ${remoteVersion} 与当前基座版本 ${localVersion} 不兼容，请前往官网下载最新安装包。`,
      showCancel: true,
      confirmText: '去下载',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          const downloadUrl = `${baseURL}/klp.apk`;
          // 区分环境打开下载链接
          plus.runtime.openURL(downloadUrl);
        }
      }
    });
  }


  // 显示更新提示模态框
  function showUpdateModal(remoteVersion, wgtUrl) {
    uni.showModal({
      title: '发现新版本',
      content: `检测到新版本（${remoteVersion}），是否立即下载并更新？`,
      confirmText: '立即更新',
      cancelText: '暂不更新',
      showCancel: true,
      success: (modalRes) => {
        if (modalRes.confirm) {
          // 用户确认更新：检查存储空间 -> 下载 -> 安装
          handleConfirmUpdate(wgtUrl, remoteVersion);
        } else {
					// 直接退出
					
          // 用户取消更新：询问是否忽略该版本
          // handleCancelUpdate(remoteVersion);
        }
      }
    });
  }


  // 处理用户确认更新
  function handleConfirmUpdate(wgtUrl, remoteVersion) {
    checkStorageSpace()
      .then(() => {
        // 存储空间充足，开始下载
        uni.showLoading({ title: '正在下载更新包...' });
        console.log('开始下载wgt包:', wgtUrl);

        uni.downloadFile({
          url: wgtUrl,
          success: (downloadResult) => handleDownloadSuccess(downloadResult, remoteVersion),
          fail: handleDownloadFail
        });
      })
      .catch((error) => {
        // 存储空间不足
        console.error('存储空间检查失败:', error);
        uni.showModal({
          title: '存储空间不足',
          content: '设备存储空间不足，无法下载更新包',
          showCancel: false,
          confirmText: '确定'
        });
      });
  }


  // 处理下载成功
  function handleDownloadSuccess(downloadResult, remoteVersion) {
    uni.hideLoading();
    console.log('下载结果:', downloadResult);

    if (downloadResult.statusCode === 200) {
      // 下载成功，开始安装wgt包
      installWgtPackage(downloadResult.tempFilePath, remoteVersion);
    } else {
      // 下载状态码异常
      console.error('下载失败，状态码:', downloadResult.statusCode);
      uni.showModal({
        title: '下载失败',
        content: `服务器返回错误，状态码: ${downloadResult.statusCode}`,
        showCancel: false,
        confirmText: '确定'
      });
    }
  }


  // 安装wgt包
  function installWgtPackage(filePath, remoteVersion) {
    console.log('开始安装wgt包:', filePath);
    
    plus.io.resolveLocalFileSystemURL(filePath, 
      // 文件存在，执行安装
      () => {
        plus.runtime.install(filePath, { force: true }, 
          // 安装成功
          () => {
            console.log('wgt包安装成功');
            uni.setStorageSync('wgtVersion', remoteVersion); // 更新本地wgt版本记录
            showRestartConfirm();
          },
          // 安装失败
          (e) => handleInstallFail(e)
        );
      },
      // 文件不存在/损坏
      (error) => {
        console.error('文件不存在:', error);
        uni.showModal({
          title: '安装失败',
          content: '下载的文件不存在或已损坏',
          showCancel: false,
          confirmText: '确定'
        });
      }
    );
  }


  // 显示重启确认
  function showRestartConfirm() {
    uni.showModal({
      title: '更新完成',
      content: '应用需要重启才能生效，是否立即重启？',
      success: (res) => {
        if (res.confirm) {
          plus.runtime.restart();
        }
      }
    });
  }


  // 处理安装失败
  function handleInstallFail(e) {
    console.error('wgt包安装失败:', e);
    let errorMsg = '安装失败';
    if (e?.message) errorMsg += ': ' + e.message;
    if (e?.code) errorMsg += ' (错误代码: ' + e.code + ')';
    
    uni.showModal({
      title: '安装失败',
      content: `${errorMsg}\n\n可能的原因：\n1. 版本不兼容\n2. 文件损坏\n3. 权限不足\n4. 存储空间不足`,
      showCancel: false,
      confirmText: '确定'
    });
  }


  // 处理下载失败
  function handleDownloadFail(error) {
    uni.hideLoading();
    console.error('下载失败:', error);
    uni.showModal({
      title: '下载失败',
      content: '网络连接异常，请检查网络后重试',
      showCancel: false,
      confirmText: '确定'
    });
  }


  // 处理用户取消更新（询问是否忽略）
  function handleCancelUpdate(remoteVersion) {
    uni.showModal({
      title: '忽略更新',
      content: `是否忽略版本 ${remoteVersion}？忽略后下次启动时将不再提示此版本更新。`,
      confirmText: '忽略此版本',
      cancelText: '下次提醒',
      success: (ignoreRes) => {
        if (ignoreRes.confirm) {
          uni.setStorageSync('ignoredVersion', remoteVersion);
          uni.showToast({ title: '已忽略此版本更新' });
        }
      }
    });
  }


  // 处理检查更新请求失败
  function handleCheckFail(error) {
    console.error('检查更新失败:', error);
    uni.showToast({ title: '网络异常，请稍后重试' });
  }
}

export default {
  checkUpdate,
  clearIgnoredVersion,
  getIgnoredVersion,
  setIgnoredVersion,
  checkVersionCompatibility,
  checkStorageSpace,
  compareVersion,
  extractVersionNum
};
