// 登录页逻辑 - 真实登录实现
const app = getApp();
const config = require('../../config/config.js');
const apiClient = require('../../utils/api-client.js');
const systemInfoUtil = require('../../utils/system-info.js');
const redirect = require("../../utils/redirect.js");

Page({
  data: {
    showView: false,
    showAgreeModal: false,
    // 应用信息
    appName: config.appName || 'FindMe',
    appVersion: config.appVersion || '1.0.0',
    // 状态控制
    agreedToTerms: false, // 默认同意条款
    buildWechatPhoneNumber: false, // 当前微信对应的用户是否已经绑定手机号
    // 新增状态
    isLoading: false, // 加载状态
    loginError: '', // 登录错误信息
    retryCount: 0, // 重试次数
    maxRetries: 3, // 最大重试次数
    phoneNumber: '', // 当前绑定的手机号
  },

  // ==================== 页面生命周期方法 ====================
  
  /**
   * 页面加载
   */
  onLoad: async function (options) {
    // 保存来源信息
    this.fromPage = options.from || '';
    this.isFromLogout = options.from === 'logout';

    // 如果是退出登录后的跳转，清除退出标志
    if (this.isFromLogout) {
      setTimeout(() => {
        wx.removeStorageSync('isLoggingOut');
      }, 100);
    }

    // 清除之前的错误状态
    this.clearError();

    // 使用新的屏幕适配器，解决滚动条问题
    try {
      await app.initScreen(this);
      
      // 计算容器高度
      await systemInfoUtil.init();
      const adaptInfo = systemInfoUtil.getSystemAdaptInfo();
      const heightValue = adaptInfo.windowHeight - adaptInfo.navBarHeight;
      this.setData({
        containerHeight: heightValue + 'px'
      });
    } catch (error) {
      console.error('屏幕适配器初始化失败:', error);
      this.showError('页面初始化失败，请刷新重试');
    }

    // 开发环境下自动填充测试数据
    if (config.debug && config.debug.enabled) {
      this.setData({ agreedToTerms: false });
    }

    // 移除自动登录测试，确保微信登录始终需要授权
    this.setData({ buildWechatPhoneNumber: false });
  },

  /**
   * 页面显示时检查登录状态
   */
  onShow: function () {
    // 检查版本更新（优先级最高，防止版本更新后状态不一致）
    const versionManager = require('../../utils/simple-version-manager.js');
    const hasVersionUpdate = versionManager.checkVersionUpdate();
    if (hasVersionUpdate) {
      return;
    }

    // 检查是否是退出登录后的跳转（优先级高于自动登录检查）
    const isLoggingOut = wx.getStorageSync('isLoggingOut');
    const fromLogout = this.options?.from === 'logout';
    if (isLoggingOut || fromLogout) {
      console.log('🔍 检测到退出登录标志，不执行自动跳转');
      setTimeout(() => {
        wx.removeStorageSync('isLoggingOut');
      }, 100);
      return;
    }

    // 清除错误状态
    this.clearError();
    // 重置重试次数
    this.setData({ retryCount: 0 });

    // 严格检查登录状态
    const storageUserInfo = wx.getStorageSync('userInfo');
    const globalUserInfo = app.globalData.userInfo;
    
    // 优先使用存储中的数据（存储是持久化的，更可靠）
    const userInfo = storageUserInfo || globalUserInfo;
    const hasValidToken = userInfo && userInfo.token && userInfo.token.length > 0;
    const isLoggedIn = app.globalData.isLoggedIn;

    // 只有在存储和全局状态都有有效token的情况下才跳转
    if (isLoggedIn && hasValidToken && storageUserInfo && storageUserInfo.token && !isLoggingOut && !fromLogout) {
      redirect.goMain();
    } else {
      // 清理不一致的登录状态
      if (isLoggedIn && (!storageUserInfo || !storageUserInfo.token || !storageUserInfo.token.length)) {
        console.log('🔍 检测到登录状态不一致，清理全局状态');
        app.globalData.isLoggedIn = false;
        app.globalData.userInfo = null;
        app.globalData.nim = null;
        
        if (storageUserInfo) {
          wx.removeStorageSync('userInfo');
        }
        wx.removeStorageSync('token');
      }
    }
  },

  /**
   * 页面隐藏时的处理
   */
  onHide: function () {
    // 隐藏加载状态
    if (this.data.isLoading) {
      this.hideLoading();
    }
  },

  /**
   * 页面卸载时的处理
   */
  onUnload: function () {
    // 清理定时器等资源
    if (this.loginTimer) {
      clearTimeout(this.loginTimer);
      this.loginTimer = null;
    }
    // 清理测试登录数据
    wx.removeStorageSync('testWechatLogin-loginData');
  },

  /**
   * 监听返回按钮
   */
  onBackPress: function() {
    // 如果是从未登录的圈子按钮或消息按钮跳转过来的
    if (this.fromPage === 'circle' || this.fromPage === 'message') {
      wx.switchTab({
        url: '/pages/map/map'
      });
      return true; // 阻止默认返回行为
    }
    return false; // 使用默认返回行为
  },

  // ==================== UI工具方法 ====================

  /**
   * 显示提示信息
   */
  showToast: function (title, icon = 'none', duration = 2000) {
    wx.showToast({
      title: title,
      icon: icon,
      duration: duration
    });
  },

  /**
   * 显示加载状态
   */
  showLoading: function (title = '加载中...', mask = true) {
    this.setData({ isLoading: true });
    wx.showLoading({
      title: title,
      mask: mask
    });
  },

  /**
   * 隐藏加载状态
   */
  hideLoading: function () {
    this.setData({ isLoading: false });
    wx.hideLoading();
  },

  /**
   * 显示错误信息
   */
  showError: function (message) { 
    this.setData({ loginError: message });
    this.showToast(message, 'error');
  },

  /**
   * 清除错误信息
   */
  clearError: function () {
    this.setData({ loginError: '' });
  },

  // ==================== 缓存清理方法 ====================

  /**
   * 清除所有缓存
   */
  clearAllCache: function() {
    try {
      // 清除图片缓存
      const imageCacheManager = require('../../utils/image-cache-manager.js');
      imageCacheManager.clearAllCache();
      
      // 清除网络缓存
      const networkOptimizer = require('../../utils/network-optimizer.js');
      if (networkOptimizer.clearCache) {
        networkOptimizer.clearCache();
      }
      
      // 清除存储缓存
      const storageUtil = require('../../utils/storage.js');
      if (storageUtil.clearCache) {
        storageUtil.clearCache();
      }
      
      // 清除临时数据（可选，保留用户token等重要数据）
      const storageInfo = wx.getStorageInfoSync();
      const cacheKeys = storageInfo.keys.filter(key => 
        key.startsWith('cache_') || 
        key.startsWith('temp_') || 
        key.startsWith('old_')
      );
      cacheKeys.forEach(key => {
        wx.removeStorageSync(key);
      });
      
      console.log('✅ 登录时已清除缓存');
    } catch (error) {
      console.error('清除缓存失败:', error);
    }
  },

  // ==================== 登录相关方法 ====================

  /**
   * 本机号码一键登录
   */
  mphoneLogin: function () {
    if (this.data.isLoading) {
      return;
    }

    if (!this.data.agreedToTerms) {
      this.showToast('请先同意用户协议');
      return;
    }

    this.clearAllCache();
    this.clearError();
    redirect.goMobileLogin();
  },

  /**
   * 微信快捷登录 - 获取手机号授权
   */
  onGetPhoneNumber: async function (e) {
    if (this.data.isLoading) {
      return;
    }

    if (!this.data.agreedToTerms) {
      this.showToast('请先同意用户协议');
      return;
    }

    this.clearAllCache();

    // 用户拒绝授权
    const { errMsg, code } = e.detail;
    if (errMsg === 'getPhoneNumber:fail user deny') {
      this.showToast('请允许获取手机号以完成登录');
      return;
    }

    if (!code) {
      this.showError('未能获取手机号授权码，请重试');
      return;
    }

    this.clearError();
    this.showLoading('登录中...');

    try {
      const wechatCode = await this.getWechatCode();
      const loginResponse = await this.callWechatLoginAPI(wechatCode, code);
      const loginData = loginResponse?.data || loginResponse;
      
      // 统一access_token字段
      if (!loginData.access_token && loginData.token) {
        loginData.access_token = loginData.token;
      }

      await this.loginSuccess(loginData);

      // 保存手机号信息
      const phoneNumber = loginData?.user?.phone || loginData?.phoneNumber || loginData?.phone;
      if (phoneNumber) {
        this.setData({
          buildWechatPhoneNumber: true,
          phoneNumber: phoneNumber
        });
        try {
          wx.setStorageSync('phoneNumber', phoneNumber);
        } catch (storageError) {
          console.warn('缓存手机号失败:', storageError);
        }

        if (app && app.globalData) {
          app.globalData.phoneNumber = phoneNumber;
        }
      }
    } catch (error) {
      console.error('微信登录失败:', error);
      this.showError(error.message || '微信登录失败，请重试');
    } finally {
      this.hideLoading();
    }
  },

  /**
   * 获取微信code
   */
  getWechatCode: function () {
    return new Promise((resolve, reject) => {
      wx.login({
        success: (loginRes) => {
          if (loginRes.code) {
            resolve(loginRes.code);
          } else {
            console.error('获取微信code失败:', loginRes.errMsg);
            reject(new Error(loginRes.errMsg || '获取微信授权码失败'));
          }
        },
        fail: (error) => {
          console.error('微信login调用失败:', error);
          reject(new Error(error.errMsg || '微信登录失败，请检查网络'));
        }
      });
    });
  },

  /**
   * 调用微信登录API
   * @param {string} wechatCode - 微信登录授权代码
   * @param {string} phoneCode - 授权手机号代码（可选）
   */
  callWechatLoginAPI: function (wechatCode, phoneCode = null) {
    return apiClient.wechatLogin(
      wechatCode,
      phoneCode ? { phoneCode } : null
    );
  },

  /**
   * 登录成功处理
   */
  loginSuccess: async function (loginData) {
    redirect.goMain();
    try {
      const success = await app.login(loginData);
      const newUser = loginData?.newUser;

      if (success) {
        this.clearError();
        wx.showToast({
          title: '登录成功',
          icon: 'success',
          duration: 1500
        });

        // 延迟跳转，让用户看到成功提示
        setTimeout(() => {
          if (newUser) {
            // 新用户跳转到用户信息编辑页，传递用户信息用于预填
            this.prepareProfileData(loginData);
            redirect.goProfile();
          } else {
            // 老用户直接跳转到主页
            redirect.goMain();
          }
        }, 1500);
      } else {
        throw new Error('登录信息保存失败');
      }
    } catch (error) {
      console.error('保存登录信息失败:', error);
      this.showError('登录信息保存失败，请重试');
      throw error;
    }
  },

  /**
   * 准备用户资料数据，用于预填到 profile-page
   */
  prepareProfileData: function (loginData) {
    try {
      // 从登录数据中提取用户信息
      const user = loginData?.user || loginData;
      const profileData = {
        nickname: user?.nickname || user?.nickName || '',
        avatar: user?.avatar || user?.avatarUrl || '',
        gender: this.mapGenderToProfileFormat(user?.gender)
      };

      // 保存到全局数据，供 profile-page 使用
      if (app && app.globalData) {
        app.globalData.profilePreFillData = profileData;
      }

      // 同时保存到本地存储作为备用
      wx.setStorageSync('profilePreFillData', profileData);
    } catch (error) {
      console.error('准备用户资料数据失败:', error);
    }
  },

  /**
   * 将后端性别格式转换为 profile-page 需要的格式
   * @param {number|string} gender - 后端返回的性别：0-未知，1-男，2-女，3-其他
   * @returns {string} 'man' 或 'woman'
   */
  mapGenderToProfileFormat: function (gender) {
    if (gender === 1 || gender === '1' || gender === 'man' || gender === 'male') {
      return 'man';
    } else if (gender === 2 || gender === '2' || gender === 'woman' || gender === 'female') {
      return 'woman';
    }
    return 'man'; // 默认返回 'man'
  },

  /**
   * 测试微信是否可以直接登录（用于调试）
   */
  testWechatLogin: async function() {
    try {
      this.showLoading('检查登录状态...');
      wx.removeStorageSync('testWechatLogin-loginData');
      const wechatCode = await this.getWechatCode();
      const loginData = await this.callWechatLoginAPI(wechatCode);

      if (!loginData.access_token) {
        return false;
      }

      wx.setStorageSync('testWechatLogin-loginData', loginData);
      return true;
    } catch (error) {
      console.error('测试微信登录失败:', error);
      return false;
    } finally {
      this.hideLoading();
    }
  },

  /**
   * 处理测试登录数据（用于调试）
   */
  handleTap: async function() {
    if (this.data.isLoading) {
      return;
    }

    if (!this.data.agreedToTerms) {
      this.showToast('请先同意用户协议');
      return;
    }

    this.clearAllCache();
    this.clearError();
    this.showLoading('登录中...');

    try {
      const loginData = wx.getStorageSync('testWechatLogin-loginData');
      if (!loginData) {
        throw new Error('登录数据不存在，请重新授权');
      }
      await this.loginSuccess(loginData);
    } catch (error) {
      console.error('登录失败:', error);
      this.showError(error.message || '登录失败，请重试');
    } finally {
      this.hideLoading();
    }
  },

  // ==================== 协议相关方法 ====================

  /**
   * 切换协议同意状态
   */
  toggleAgreement: function() {
    this.setData({
      agreedToTerms: !this.data.agreedToTerms
    });
    this.clearError();
  },

  /**
   * 打开协议弹窗
   */
  openAgreeModal: function() {
    this.setData({
      showAgreeModal: true
    });
  },

  /**
   * 同意协议
   */
  onAgree: function() {
    this.setData({
      showAgreeModal: false,
      agreedToTerms: true
    });
    this.clearError();
  },

  /**
   * 不同意协议
   */
  onDisagree: function() {
    this.setData({
      showAgreeModal: false
    });
  },
});
