// pages/login/mobile-login-page.js
const app = getApp();
const config = require('../../config/config.js');
const apiClient = require('../../utils/api-client.js');
const systemInfoUtil = require('../../utils/system-info.js');
const versionHelper = require('../../utils/version-helper.js');
// const screenAdapter = require('../../utils/screen-adapter.js');
const redirect = require("../../utils/redirect.js");


Page({

    /**
     * 页面的初始数据
     */
    data: {
      // 应用信息
      appName: config.appName || 'FindMe',
      appVersion: config.appVersion || '1.0.0',
      // 表单数据
      phoneNumber: '',
      phoneError: '',
      verifyCode: ['', '', '', ''],
      verifyCodeError: '',
      verifyCodeComplete: false,
      focusIndex: -1, // 当前应该聚焦的输入框索引，-1表示无焦点
      phoneFocus: false, // 手机号输入框焦点状态
      phoneValid:false,
      codeValid: false,
      isnickNameError:'',
      canLogin: false,
      isLogging: false,
      isWechatLogging: false,
    // 验证码按钮状态
    codeButtonText: '获取验证码',
    codeTimer: null,
    codeCountdown: 0,
  
    // 系统适配信息 - 先设置默认值
    statusBarHeight: 44,
    menuButtonHeight: 32,
    menuButtonTop: 6,
    navBarHeight: 88,
    windowHeight: 667,
    safeAreaBottom: 0,

    // 新增：单一输入框方案
    realCode: '', // 真实输入框的值
    isCodeInputFocused: false, // 控制伪光标显示
    cursorPosition: 0, // 光标位置
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad : async function(options) {
      console.log('页面加载，options:', options);

      // 应用屏幕适配到页面的数据
      await app.initScreen(this)

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

    },
  // 表单验证
  // 表单验证 
  validateForm: function () {
    const { phoneNumber, verifyCode } = this.data
    const phone = (phoneNumber || '').trim()
    const verifyCodeString = Array.isArray(verifyCode) ? verifyCode.join('') : (verifyCode || '').trim()
    const phoneReg = /^1[3-9]\d{9}$/;
    const verifyCodeReg = /^\d{4}$/;
    let isPhoneError = '';
    let isVerifyCodeError = '';
    let canSendCode = '';
    let isnickNameError = ''
    if (!phoneReg.test(phone) && phone) {
      isPhoneError = '请输入有效的11位数手机号码'
      isnickNameError= true

    } else {
      canSendCode = phoneReg.test(phone) && this.data.codeCountdown === 0;
    }
    if (!verifyCodeReg.test(verifyCodeString) && verifyCodeString) {
      isVerifyCodeError = '请输入有效的4位数验证码'
    }
    this.setData({
      phoneNumber: phone,
      phoneError: isPhoneError,
      verifyCodeError: isVerifyCodeError,
      canSendCode: canSendCode,
      isnickNameError:isnickNameError
    })
  },


  // 手机号输入过程中的处理
  onPhoneInputChange: function (e) {
    const value = e.detail.value;

    this.setData({
      phoneNumber: value
    });
    this.validateForm();
  },

  // 手机号获得焦点时的处理
  onPhoneFocus: function (e) {

    this.setData({
      phoneFocus: true
    });
  },

  // 手机号失去焦点时的处理
  onPhoneInput: function (e) {

    this.setData({
      phoneFocus: false // 失去焦点时设置为false
    });
  },

  // 新增：点击特定格子聚焦到对应位置
  focusOnCodePosition: function(e) {
    const index = parseInt(e.currentTarget.dataset.index);
    
    this.setData({
      isCodeInputFocused: true,
      cursorPosition: index
    });
    
    // 延迟聚焦到真实输入框
    wx.nextTick(() => {
      const query = wx.createSelectorQuery().in(this);
      query.select('#real-code-input').node().exec((res) => {
        if (res[0] && res[0].node) {
          res[0].node.focus();
          // 设置光标位置
          res[0].node.setSelectionRange(index, index);
        }
      });
    });
  },

  // 新增：点击验证码容器时聚焦
  focusOnCodeInput: function() {
    this.setData({
      isCodeInputFocused: true,
      cursorPosition: this.data.realCode.length // 设置光标到字符串末尾
    });
    
    wx.nextTick(() => {
      const query = wx.createSelectorQuery().in(this);
      query.select('#real-code-input').node().exec((res) => {
        if (res[0] && res[0].node) {
          res[0].node.focus();
          // 设置光标到字符串末尾
          const cursorPos = this.data.realCode.length;
          res[0].node.setSelectionRange(cursorPos, cursorPos);
        }
      });
    });
  },

  // 新增：真实输入框的键盘事件处理
  onRealCodeKeyDown: function(e) {
    const keyCode = e.detail.keyCode;
    const value = e.detail.value;
    
    // 处理删除键 - 根据光标位置删除
    if (keyCode === 8) { // Backspace
      if (this.data.cursorPosition > 0) {
        const currentCode = this.data.realCode;
        const newCode = currentCode.slice(0, this.data.cursorPosition - 1) + currentCode.slice(this.data.cursorPosition);
        const newPosition = this.data.cursorPosition - 1;
        
        // 创建新的验证码数组
        const newVerifyCode = ['', '', '', ''];
        for (let i = 0; i < newCode.length; i++) {
          newVerifyCode[i] = newCode[i];
        }
        
        this.setData({
          realCode: newCode,
          verifyCode: newVerifyCode,
          cursorPosition: newPosition,
          verifyCodeComplete: newCode.length >= 4
        });
        
        // 同步输入框状态
        wx.nextTick(() => {
          const query = wx.createSelectorQuery().in(this);
          query.select('#real-code-input').node().exec((res) => {
            if (res[0] && res[0].node) {
              res[0].node.value = newCode;
              res[0].node.setSelectionRange(newPosition, newPosition);
            }
          });
        });
      }
    }
    // 处理方向键
    else if (keyCode === 37) { // 左箭头
      if (this.data.cursorPosition > 0) {
        this.setData({
          cursorPosition: this.data.cursorPosition - 1
        });
      }
    }
    else if (keyCode === 39) { // 右箭头
      if (this.data.cursorPosition < this.data.realCode.length) {
        this.setData({
          cursorPosition: this.data.cursorPosition + 1
        });
      }
    }
  },


  // 新增：真实输入框的输入事件
  onRealCodeInput: function(e) {
    const value = e.detail.value;
    const digits = value.replace(/\D/g, '').slice(0, 4); // 只保留数字，最多4位
    
    // 创建新的验证码数组
    const newVerifyCode = ['', '', '', ''];
    for (let i = 0; i < digits.length; i++) {
      newVerifyCode[i] = digits[i];
    }
    
    // 计算光标位置
    let newCursorPosition = digits.length;
    
    // 如果输入了新的字符，光标位置等于字符串长度
    // 如果删除了字符，保持当前光标位置
    if (digits.length > this.data.realCode.length) {
      // 输入操作：光标在末尾
      newCursorPosition = digits.length;
    } else if (digits.length < this.data.realCode.length) {
      // 删除操作：保持当前光标位置
      newCursorPosition = Math.min(this.data.cursorPosition, digits.length);
    }
    
    this.setData({
      realCode: digits,
      verifyCode: newVerifyCode,
      cursorPosition: newCursorPosition
    });

    if (digits.length >= 4) {
      this.setData({
        verifyCodeComplete: true
      });
      this.validateForm();
      // 可以在这里触发登录
    } else {
      this.setData({
        verifyCodeComplete: false
      });
    }
  },

  // 键盘确认按钮处理 - 当用户点击键盘上的"确定"时触发
  onCodeConfirm: function(e) {
    const { verifyCode, phoneNumber } = this.data;
    const verifyCodeString = Array.isArray(verifyCode) ? verifyCode.join('') : verifyCode;
    
    // 如果验证码已输入4位，自动执行登录
    if (verifyCodeString && verifyCodeString.length === 4 && phoneNumber) {
      // 延迟一小段时间，确保输入框的值已更新
      setTimeout(() => {
        this.handleLogin();
      }, 100);
    } else if (!verifyCodeString || verifyCodeString.length < 4) {
      // 验证码未填满时，提示用户
      wx.showToast({
        title: '请输入完整的4位验证码',
        icon: 'none',
        duration: 1500
      });
    } else if (!phoneNumber) {
      // 手机号未填写时，提示用户
      wx.showToast({
        title: '请输入手机号码',
        icon: 'none',
        duration: 1500
      });
    }
  },

  // 验证码输入处理 - 统一处理输入和删除
  onCodeInput: function (e) {
    const value = e.detail.value;
    const index = parseInt(e.currentTarget.dataset.index);
    const oldCode = [...this.data.verifyCode];
    const oldValue = oldCode[index];
    const isAllFilled = oldCode.every(code => code !== '');

    // 提取数字字符
    const digits = value.replace(/\D/g, '');

    // 处理多位输入（粘贴场景）
    if (digits.length > 1) {
      this.handlePastedCode(digits, index);
      return;
    }

    // 获取新的数字值
    const newDigit = digits.slice(0, 1);
    const newCode = [...oldCode];
    newCode[index] = newDigit;

    // 判断操作类型
    const isDelete = oldValue && !newDigit; // 有值变无值 = 删除
    const isInput = !oldValue && newDigit;  // 无值变有值 = 输入
    const isReplace = oldValue && newDigit && oldValue !== newDigit; // 替换

    // 更新数据
    this.setData({
      verifyCode: newCode,
      verifyCodeComplete: this.checkCodeComplete(newCode)
    });

    // 处理焦点逻辑
    if (isDelete) {
      // 删除操作：回退到上一个输入框
      this.handleDeleteOperation(index);
    } else if (isInput || isReplace) {
      // 输入或替换操作：根据是否全部填满决定焦点移动
      this.handleInputOperation(index, isAllFilled);
    }
    
    this.validateForm();
  },

  // 处理删除操作的焦点移动
  handleDeleteOperation: function(currentIndex) {
    if (currentIndex > 0) {
      // 使用requestAnimationFrame确保在下一帧执行，减少跳动
      wx.nextTick(() => {
        this.setData({
          focusIndex: currentIndex - 1
        });
      }, 50); // 延迟确保UI更新
    }
  },

  // 处理输入操作的焦点移动
  handleInputOperation: function(currentIndex, wasAllFilled) {
    const isAllFilled = this.data.verifyCode.every(code => code !== '');
    
    if (currentIndex < 3 && !isAllFilled) {
      // 只有在不是全部填满的情况下才前进到下一个输入框
      wx.nextTick(() => {
        this.setData({
          focusIndex: currentIndex + 1
        });
      }, 50); // 延迟确保UI更新
    }
  },

  // 处理粘贴的验证码
  handlePastedCode: function (pastedValue, currentIndex = 0) {
    const digits = pastedValue.replace(/\D/g, '').slice(0, 4);

    if (digits.length === 0) return;

    const newCode = [...this.data.verifyCode];
    const digitsArray = digits.split('');

    // 从当前位置开始填充
    for (let i = 0; i < digitsArray.length && (currentIndex + i) < 4; i++) {
      newCode[currentIndex + i] = digitsArray[i];
    }

    // 计算最终焦点位置
    const finalIndex = Math.min(currentIndex + digits.length - 1, 3);
    const isComplete = this.checkCodeComplete(newCode);

    this.setData({
      verifyCode: newCode,
      focusIndex: isComplete ? -1 : finalIndex, // 完成时取消焦点
      verifyCodeComplete: isComplete
    });

    this.validateForm();
  },

  // 验证码按键处理 - 备用删除键处理
  onCodeKeyDown: function (e) {
    const index = parseInt(e.currentTarget.dataset.index);
    const keyCode = e.detail.keyCode;

    // 备用删除键处理（如果onCodeInput处理不了的情况）
    if (keyCode === 8) {
      const currentValue = this.data.verifyCode[index];

      // 如果当前位置无值且在onCodeInput中没有处理到，则手动回退
      if (!currentValue && index > 0) {
        const newCode = [...this.data.verifyCode];
        newCode[index - 1] = '';

        setTimeout(() => {
          this.setData({
            verifyCode: newCode,
            focusIndex: index - 1,
            verifyCodeComplete: false
          });
          this.validateForm();
        }, 10);
      }
    }
  },

  // 验证码输入框获得焦点
  onCodeFocus: function (e) {
    this.setData({
      isCodeInputFocused: true,
      verifyCodeError: '' // 清除错误提示
    });
  },

  // 验证码输入框失去焦点
  onCodeBlur: function (e) {
    this.setData({
      isCodeInputFocused: false
    });
    this.validateForm();
  },

  // 兜底系统信息初始化
  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
      });
      
    } 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) {

    }
  },
    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {
      // 页面渲染完成后设置手机号输入框焦点
      setTimeout(() => {
        this.setData({
          phoneFocus: true
        });
      }, 100);
    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {
      // 🔥 优先检查版本更新
      const hasVersionUpdate = versionHelper.checkVersionOnShow();
      if (hasVersionUpdate) {

        return; // 如果有版本更新，停止后续初始化
      }

      // 页面显示时确保手机号输入框获得焦点
      setTimeout(() => {
        this.setData({
          phoneFocus: true
        });
      }, 150);
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {
      // 清理验证码倒计时定时器
      if (this.data.codeTimer) {
        clearInterval(this.data.codeTimer);
      }
    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {

    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {

    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {

    },

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

  // 发送验证码 - 真实实现
  sendVerifyCode: function () {

    this.validateForm();
  const { phoneNumber, codeCountdown } = this.data;
    if (codeCountdown > 0) {

      return;
    }
    
    if (!this.data.canSendCode) {
      wx.showToast({
        title: '请输入正确手机号',
        icon: 'error',
        duration: 2000
      });

      return;
    }

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

    // 调用真实API
    apiClient.sendVerifyCode(phoneNumber)
      .then(response => {
        // 确保隐藏loading
        wx.hideLoading();
        
        // 开始倒计时
        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 () {
    this.validateForm();

    const { phoneNumber, verifyCode } = this.data; 
    const verifyCodeString = Array.isArray(verifyCode) ? verifyCode.join('') : verifyCode;

  
    if (!this.data.phoneNumber) {
      wx.showToast({
        title: '请输入手机号码',
        icon: 'error'
      })
      return
    } 
    if (!verifyCodeString) {
      wx.showToast({
        title: '请输入验证码',
        icon: 'error'
      })
      return
    };
    
    // if (!this.data.canLogin || this.data.isLogging) {
    //   console.log('❌ 登录被阻止 - 按钮不可用或正在登录');
    //   wx.showToast({
    //     title: '请输入正确验证码',
    //     icon: 'error',
    //     duration: 2000
    //   })
    //   return;
    // }


    

    this.setData({
      isLogging: true
    });

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

    // 调用真实登录API
    apiClient.login(phoneNumber, verifyCodeString)
      .then(response => {
        wx.hideLoading();
        
        // 处理登录成功
        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) {

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

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

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

        // 🔥 立即检查账号同步状态

        this.checkAccountSyncAfterLogin(loginData);

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

        // 🔥 使用统一的跳转方法
        setTimeout(() => {

          if(newUser){ // @TODO  判断用户是否是第一次登陆，如果不是则不需要编辑用户信息
            redirect.goProfile()
          }else{//  需要编辑的情况下，跳转到用户信息编辑页
            redirect.goMain();
          }
        }, 1500);
      } else {
        throw new Error('登录信息保存失败');
      }

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

      wx.showToast({
        title: '登录信息保存失败',
        icon: 'error',
        duration: 2000
      });
    }
  },
// 🔥 登录成功后检查账号同步状态
async checkAccountSyncAfterLogin(loginData) {

  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) {

      // 延迟显示绑定提示，确保登录流程完成
      setTimeout(() => {
        const accountSyncManager = require('../../utils/account-sync.js');
        accountSyncManager.showPhoneBindingModal();
      }, 2000);
    } else {

    }

  } catch (error) {
    console.error('检查账号同步状态失败:', error);
  }
},
checkAccountSyncStatus: async function() {
    try {
      const syncStatus = await accountSync.getSyncStatus();
      this.setData({
        isAccountSynced: syncStatus.isSynced
      });
  } catch (error) {
    console.error('检查账号同步状态失败:', error);
  }
}
});
