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

Page({
  data: {
    // 应用信息
    appName: config.appName || 'FindMe',
    appVersion: config.appVersion || '1.0.0',
    
    // 表单数据
    phoneNumber: '',
    verifyCode: '',
    
    // 状态控制
    canSendCode: false,
    canLogin: false,
    isLogging: false,
    isWechatLogging: false,
    agreedToTerms: true, // 默认同意条款
    
    // 验证码按钮状态
    codeButtonText: '获取验证码',
    codeTimer: null,
    codeCountdown: 0,
    
    // 系统适配信息 - 先设置默认值
    statusBarHeight: 44,
    menuButtonHeight: 32,
    menuButtonTop: 6,
    navBarHeight: 88,
    windowHeight: 667,
    safeAreaBottom: 0
  },

  // 页面加载
  onLoad: function (options) {
    console.log('登录页加载');
    
    // 使用新的屏幕适配器，解决滚动条问题
    this.initScreenAdapter();
    
    // 检查是否已有用户信息（如从启动页跳转过来）
    this.checkAutoFillUserInfo();
    
    // 开发环境下自动填充测试数据
    if (config.debug && config.debug.enabled) {
      this.setData({
        phoneNumber: '15618371121', // 测试手机号
        agreedToTerms: true
      });
      this.validateForm();
    }
  },

  // 初始化屏幕适配器 - 解决滚动条问题
  async initScreenAdapter() {
    try {
      // 初始化新的屏幕适配器
      await screenAdapter.init();
      
      // 应用适配信息到当前页面
      screenAdapter.applyToPage(this);
      
      console.log('登录页面屏幕适配完成');
      
      // 兜底：如果新适配器失败，使用旧方法
    } catch (error) {
      console.error('新屏幕适配器失败，使用兜底方案:', error);
      this.fallbackSystemInfo();
    }
  },

  // 兜底系统信息初始化
  async fallbackSystemInfo() {
    try {
      await systemInfoUtil.init();
      const adaptInfo = systemInfoUtil.getSystemAdaptInfo();
      
      this.setData({
        statusBarHeight: adaptInfo.statusBarHeight,
        menuButtonHeight: adaptInfo.menuButtonHeight,
        menuButtonTop: adaptInfo.menuButtonTop,
        navBarHeight: adaptInfo.navBarHeight,
        windowHeight: adaptInfo.windowHeight,
        safeAreaBottom: adaptInfo.safeAreaBottom
      });
      
      console.log('登录页面兜底适配信息:', adaptInfo);
    } catch (error) {
      console.error('兜底适配也失败，使用硬编码默认值:', error);
      this.setData({
        statusBarHeight: 44,
        menuButtonHeight: 32,
        menuButtonTop: 6,
        navBarHeight: 88,
        windowHeight: 667,
        safeAreaBottom: 0
      });
    }
  },

  // 检查自动填充用户信息
  checkAutoFillUserInfo() {
    try {
      const savedPhone = wx.getStorageSync('lastLoginPhone');
      if (savedPhone) {
        this.setData({
          phoneNumber: savedPhone
        });
        this.validateForm();
      }
    } catch (error) {
      console.log('获取保存的手机号失败:', error);
    }
  },

  // 手机号输入处理
  onPhoneInput: function (e) {
    const value = e.detail.value;
    console.log('手机号输入:', value);
    this.setData({
      phoneNumber: value
    });
    this.validateForm();
  },

  // 验证码输入处理
  onCodeInput: function (e) {
    const value = e.detail.value;
    console.log('验证码输入:', value);
    this.setData({
      verifyCode: value
    });
    this.validateForm();
  },

  // 表单验证
  validateForm: function () {
    const { phoneNumber, verifyCode, agreedToTerms } = this.data;
    
    // 手机号验证（11位数字）
    const phoneValid = /^1[3-9]\d{9}$/.test(phoneNumber);
    
    // 验证码验证（6位数字）
    const codeValid = /^\d{4}$/.test(verifyCode);
    
    // 更新发送验证码按钮状态
    const canSendCode = phoneValid && this.data.codeCountdown === 0;
    
    // 更新登录按钮状态
    const canLogin = phoneValid && codeValid && agreedToTerms;
    
    console.log('表单验证结果:', {
      phoneNumber,
      phoneValid,
      verifyCode,
      codeValid,
      canSendCode,
      canLogin
    });
    
    this.setData({
      canSendCode,
      canLogin
    });
  },

  // 清除手机号
  clearPhone: function () {
    this.setData({
      phoneNumber: ''
    });
    this.validateForm();
  },

  // 发送验证码 - 真实实现
  sendVerifyCode: function () {
    console.log('🔘 获取验证码按钮被点击', { canSendCode: this.data.canSendCode });
    
    if (!this.data.canSendCode) {
      console.log('❌ 发送验证码被阻止 - 按钮不可用');
      return;
    }

    const { phoneNumber } = this.data;
    
    console.log('发送验证码到:', phoneNumber);

    // 显示加载状态
    wx.showLoading({
      title: '发送中...',
      mask: true
    });

    // 调用真实API
    apiClient.sendVerifyCode(phoneNumber)
      .then(response => {
        // 确保隐藏loading
        wx.hideLoading();
        
        console.log('验证码发送成功:', response);
        
        // 开始倒计时
        this.startCodeCountdown();
        
        // 延迟显示成功提示，确保loading完全消失
        setTimeout(() => {
          wx.showToast({
            title: '验证码已发送',
            icon: 'success',
            duration: 2000
          });
        }, 100);
      })
      .catch(error => {
        // 确保隐藏loading
        wx.hideLoading();
        
        console.error('验证码发送失败:', error);
        
        let errorMessage = '发送失败，请重试';
        if (error.message) {
          errorMessage = error.message;
        } else if (error.code === 'PHONE_INVALID') {
          errorMessage = '手机号格式不正确';
        } else if (error.code === 'TOO_FREQUENT') {
          errorMessage = '发送太频繁，请稍后再试';
        }
        
        // 延迟显示错误提示，确保loading完全消失
        setTimeout(() => {
          wx.showToast({
            title: errorMessage,
            icon: 'error',
            duration: 3000
          });
        }, 100);
      })
      .finally(() => {
        // 双重保险：确保loading被隐藏
        setTimeout(() => {
          wx.hideLoading();
        }, 50);
      });
  },

  // 开始验证码倒计时
  startCodeCountdown: function () {
    let countdown = 60;
    
    this.setData({
      codeCountdown: countdown,
      codeButtonText: `${countdown}s后重发`
    });

    const timer = setInterval(() => {
      countdown--;
      
      if (countdown <= 0) {
        clearInterval(timer);
        this.setData({
          codeCountdown: 0,
          codeButtonText: '重新发送',
          codeTimer: null
        });
        this.validateForm();
      } else {
        this.setData({
          codeCountdown: countdown,
          codeButtonText: `${countdown}s后重发`
        });
      }
    }, 1000);

    this.setData({
      codeTimer: timer
    });
  },

  // 处理登录 - 真实实现
  handleLogin: function () {
    console.log('🔘 登录按钮被点击', { 
      canLogin: this.data.canLogin, 
      isLogging: this.data.isLogging 
    });
    
    if (!this.data.canLogin || this.data.isLogging) {
      console.log('❌ 登录被阻止 - 按钮不可用或正在登录');
      return;
    }

    const { phoneNumber, verifyCode } = this.data;
    
    console.log('开始登录:', { phoneNumber, verifyCode });

    this.setData({
      isLogging: true
    });

    // 显示加载状态
    wx.showLoading({
      title: '登录中...',
      mask: true
    });

    // 调用真实登录API
    apiClient.login(phoneNumber, verifyCode)
      .then(response => {
        wx.hideLoading();
        
        console.log('登录成功:', response);
        
        // 处理登录成功
        this.loginSuccess(response.data);
      })
      .catch(error => {
        wx.hideLoading();
        
        console.error('登录失败:', error);
        
        this.setData({
          isLogging: false
        });
        
        let errorMessage = '登录失败，请重试';
        if (error.message) {
          errorMessage = error.message;
        } else if (error.code === 'VERIFY_CODE_INVALID') {
          errorMessage = '验证码错误';
        } else if (error.code === 'VERIFY_CODE_EXPIRED') {
          errorMessage = '验证码已过期，请重新获取';
        } else if (error.code === 'PHONE_NOT_FOUND') {
          errorMessage = '手机号未注册';
        }
        
        wx.showToast({
          title: errorMessage,
          icon: 'error',
          duration: 3000
        });
      });
  },

  // 登录成功处理
  loginSuccess: function (loginData) {
    console.log('处理登录成功:', loginData);

    try {
      // 使用app.js中的登录方法保存用户信息
      const success = app.login(loginData);

      if (success) {
        // 🔥 调试：检查认证状态
        const authManager = require('../../utils/auth.js');
        authManager.debugAuthStatus();

        // 保存最后登录的手机号
        if (this.data.phoneNumber) {
          wx.setStorageSync('lastLoginPhone', this.data.phoneNumber);
        }

        console.log('用户信息保存成功');

        // 🔥 立即检查账号同步状态
        console.log('🔥 准备调用账号同步检查...');
        this.checkAccountSyncAfterLogin(loginData);
        console.log('🔥 账号同步检查调用完成');

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

        // 🔥 使用统一的跳转方法
        setTimeout(() => {
          this.redirectToMain();
        }, 1500);
      } else {
        throw new Error('登录信息保存失败');
      }

    } catch (error) {
      console.error('保存登录信息失败:', error);

      wx.showToast({
        title: '登录信息保存失败',
        icon: 'error',
        duration: 2000
      });
    }
  },

  // 微信登录 - 真实实现
  wechatLogin: function () {
    if (this.data.isWechatLogging) {
      return;
    }

    if (!this.data.agreedToTerms) {
      wx.showToast({
        title: '请先同意用户协议',
        icon: 'none',
        duration: 2000
      });
      return;
    }

    console.log('开始微信登录');

    this.setData({
      isWechatLogging: true
    });

    // 第一步：调用wx.login获取code
    wx.login({
      success: (loginRes) => {
        if (loginRes.code) {
          console.log('获取微信code成功:', loginRes.code);
          
          // 第二步：判断是否需要获取用户信息
          this.handleWechatLoginWithCode(loginRes.code);
          
        } else {
          console.error('获取微信code失败:', loginRes.errMsg);
          this.setData({
            isWechatLogging: false
          });
          
          wx.showToast({
            title: '微信登录失败',
            icon: 'error',
            duration: 2000
          });
        }
      },
      fail: (error) => {
        console.error('微信login调用失败:', error);
        this.setData({
          isWechatLogging: false
        });
        
        wx.showToast({
          title: '微信登录失败',
          icon: 'error',
          duration: 2000
        });
      }
    });
  },

  // 处理微信登录逻辑
  handleWechatLoginWithCode: function(code) {
    // 方案一：仅使用code登录（推荐）
    // 根据微信最新政策，可以直接用code换取用户信息，无需额外授权
    this.callWechatLoginAPI(code, null);
    
    // 方案二：如果需要用户头像昵称，使用getUserProfile（可选）
    // 注释掉，因为大多数场景不需要立即获取用户详细信息
    /*
    wx.getUserProfile({
      desc: '用于完善用户资料',
      success: (profileRes) => {
        console.log('获取用户信息成功:', profileRes.userInfo);
        this.callWechatLoginAPI(code, profileRes.userInfo);
      },
      fail: (error) => {
        console.log('用户拒绝授权，使用code直接登录');
        // 用户拒绝授权时，仍然可以用code登录
        this.callWechatLoginAPI(code, null);
      }
    });
    */
  },

  // 调用微信登录API
  callWechatLoginAPI: function(code, userInfo) {
    console.log('调用微信登录API:', { code, userInfo });
    
    apiClient.wechatLogin(code, userInfo)
      .then(response => {
        console.log('微信登录成功:', response);
        
        // 处理登录成功
        this.loginSuccess(response.data);
      })
      .catch(error => {
        console.error('微信登录失败:', error);
        
        this.setData({
          isWechatLogging: false
        });
        
        let errorMessage = '微信登录失败，请重试';
        if (error.message) {
          errorMessage = error.message;
        } else if (error.code === 'WECHAT_CODE_INVALID') {
          errorMessage = '微信授权码无效';
        } else if (error.code === 'WECHAT_AUTH_FAILED') {
          errorMessage = '微信授权失败';
        }
        
        wx.showToast({
          title: errorMessage,
          icon: 'error',
          duration: 3000
        });
      });
  },

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

  // 🔥 登录成功后检查账号同步状态
  async checkAccountSyncAfterLogin(loginData) {
    console.log('🔥🔥🔥 checkAccountSyncAfterLogin 方法被调用了！');
    try {
      console.log('检查登录后的账号同步状态...', {
        hasUser: !!loginData.user,
        hasPhone: !!(loginData.user && loginData.user.phone),
        phone: loginData.user?.phone
      });

      // 根据文档，优先检查needBindPhone字段，其次检查phone字段
      const needBindPhone = loginData.needBindPhone === true ||
                           (!loginData.user || !loginData.user.phone || loginData.user.phone.trim() === '');

      if (needBindPhone) {
        console.log('用户需要绑定手机号，needBindPhone:', loginData.needBindPhone, 'phone:', loginData.user?.phone);

        // 延迟显示绑定提示，确保登录流程完成
        setTimeout(() => {
          const accountSyncManager = require('../../utils/account-sync.js');
          accountSyncManager.showPhoneBindingModal();
        }, 2000);
      } else {
        console.log('用户已绑定手机号，无需处理');
      }

    } catch (error) {
      console.error('检查账号同步状态失败:', error);
    }
  },

  // 显示用户协议
  showUserAgreement: function () {
    wx.showModal({
      title: '用户协议',
      content: '这里是用户协议的内容...\n\n1. 用户在使用本应用时需要遵守相关法律法规\n2. 用户需要对自己的行为负责\n3. 我们将保护用户的隐私和数据安全\n4. 请仔细阅读完整的用户协议',
      showCancel: false,
      confirmText: '我知道了'
    });
  },

  // 显示隐私政策
  showPrivacyPolicy: function () {
    wx.showModal({
      title: '隐私政策',
      content: '这里是隐私政策的内容...\n\n1. 我们如何收集您的信息\n2. 我们如何使用您的信息\n3. 我们如何保护您的信息\n4. 您的权利和选择\n5. 请查看完整的隐私政策',
      showCancel: false,
      confirmText: '我知道了'
    });
  },

  // 页面卸载清理
  onUnload: function () {
    // 清理倒计时定时器
    if (this.data.codeTimer) {
      clearInterval(this.data.codeTimer);
    }
  },

  // 页面显示时检查登录状态
  onShow: function() {
    console.log('🔍 登录页面显示，检查登录状态...');

    // 🔥 严格检查登录状态
    const userInfo = app.globalData.userInfo || wx.getStorageSync('userInfo');
    const hasValidToken = userInfo && userInfo.token && userInfo.token.length > 0;
    const isLoggedIn = app.globalData.isLoggedIn;

    console.log('🔍 登录状态检查:', {
      isLoggedIn,
      hasUserInfo: !!userInfo,
      hasValidToken,
      tokenLength: userInfo?.token?.length || 0
    });

    // 只有在确实有有效token的情况下才跳转
    if (isLoggedIn && hasValidToken) {
      console.log('✅ 用户已登录且有有效token，跳转到主页');
      this.redirectToMain();
    } else {
      console.log('❌ 用户未登录或token无效，停留在登录页');
      // 🔥 清理无效的登录状态
      if (isLoggedIn && !hasValidToken) {
        console.log('🧹 清理无效的登录状态');
        app.globalData.isLoggedIn = false;
        app.globalData.userInfo = null;
        wx.removeStorageSync('userInfo');
        wx.removeStorageSync('token');
      }
    }
  },

  // 🔥 统一的主页跳转方法 - 避免跳转冲突和超时
  redirectToMain() {
    // 防止重复跳转
    if (this.redirecting) {
      console.log('⚠️ 正在跳转中，忽略重复跳转请求');
      return;
    }

    this.redirecting = true;
    console.log('🔄 执行跳转到主页...');

    // 延迟执行，确保页面状态稳定
    setTimeout(() => {
      wx.reLaunch({
        url: '/pages/map/map',
        success: () => {
          console.log('✅ 跳转到主页成功');
          this.redirecting = false;
        },
        fail: (error) => {
          console.error('❌ 跳转到主页失败:', error);
          this.redirecting = false;
          // 备用方案
          wx.redirectTo({
            url: '/pages/map/map',
            fail: (error2) => {
              console.error('❌ redirectTo也失败:', error2);
              wx.showToast({
                title: '跳转失败，请重试',
                icon: 'none'
              });
            }
          });
        }
      });
    }, 200); // 200ms延迟，确保页面状态稳定
  }
});