/* eslint-disable no-param-reassign */
import { fetchDeliveryAddressList, deleteAddress, setDefaultAddress } from '../../../../services/address/fetchAddress';
import Toast from 'tdesign-miniprogram/toast/index';
import { resolveAddress, rejectAddress } from '../../../../services/address/list';
import { getAddressPromise } from '../../../../services/address/edit';

// 添加日志工具
const logger = {
  info: (module, message, data = {}) => {
    console.log(`[${new Date().toISOString()}] [INFO] [${module}] ${message}`, data);
  },
  debug: (module, message, data = {}) => {
    console.log(`[${new Date().toISOString()}] [DEBUG] [${module}] ${message}`, data);
  },
  error: (module, message, data = {}) => {
    console.error(`[${new Date().toISOString()}] [ERROR] [${module}] ${message}`, data);
  },
  warn: (module, message, data = {}) => {
    console.warn(`[${new Date().toISOString()}] [WARN] [${module}] ${message}`, data);
  }
};

Page({
  data: {
    addressList: [],
    deleteID: '',
    showDeleteConfirm: false,
    isOrderSure: false,
  },

  /** 选择模式 */
  selectMode: false,
  /** 是否已经选择地址，不置为true的话页面离开时会触发取消选择行为 */
  hasSelect: false,
  
  addressUpdated: false, // 标记地址是否被更新

  onLoad(query) {
    logger.info('ADDRESS_LIST_PAGE', '地址列表页面加载', { query });
    
    const { selectMode = '', isOrderSure = '', id = '' } = query;
    this.setData({
      isOrderSure: !!isOrderSure,
      id,
    });
    this.selectMode = !!selectMode;
    this.addressUpdated = false; // 重置地址更新标记
    
    logger.debug('ADDRESS_LIST_PAGE', '页面参数设置完成', {
      selectMode: this.selectMode,
      isOrderSure: !!isOrderSure,
      id
    });
    
    this.init();
    this.waitForNewAddress();
  },

  init() {
    logger.info('ADDRESS_LIST_PAGE', '初始化地址列表页面');
    this.getAddressList();
  },

  onShow() {
    logger.info('ADDRESS_LIST_PAGE', '页面显示，刷新地址列表');
    // 每次页面显示时都重新获取地址列表，确保数据是最新的
    this.getAddressList();
  },
  onUnload() {
    if (this.selectMode && !this.hasSelect) {
      logger.info('ADDRESS_LIST_PAGE', '页面卸载，检查是否需要传递更新后的地址');
      
      // 检查是否有默认地址，如果有则传递给订单确认页面
      const defaultAddress = this.data.addressList.find(addr => addr.isDefault === 1);
      if (defaultAddress && this.addressUpdated) {
        logger.info('ADDRESS_LIST_PAGE', '传递更新后的默认地址给订单确认页面', {
          addressId: defaultAddress.addressId,
          name: defaultAddress.name
        });
        
        // 将默认地址存储到本地存储，供订单确认页面的onShow方法使用
        wx.setStorageSync('selectedAddress', defaultAddress);
        return; // 不调用rejectAddress，让订单确认页面通过onShow处理
      }
      
      rejectAddress();
    }
  },
  getAddressList() {
    logger.info('ADDRESS_LIST_PAGE', '开始获取地址列表');
    
    const { id } = this.data;
    fetchDeliveryAddressList().then((addressList) => {
      logger.info('ADDRESS_LIST_PAGE', '获取地址列表成功', {
        count: addressList.length,
        addressIds: addressList.map(addr => addr.id)
      });
      
      // 转换API数据格式为前端期望的格式
      const formattedList = addressList.map((address) => {
        const formatted = {
          id: address.id,
          addressId: address.id,
          name: address.name,
          phoneNumber: address.phone,
          address: `${address.province_name || ''}${address.city_name || ''}${address.district_name || ''}${address.detail_address || ''}`,
          provinceName: address.province_name,
          cityName: address.city_name,
          districtName: address.district_name,
          detailAddress: address.detail_address,
          isDefault: address.is_default ? 1 : 0,
          tag: address.address_tag || '',
        };
        
        logger.debug('ADDRESS_LIST_PAGE', '格式化地址数据', {
          originalId: address.id,
          formattedId: formatted.id,
          name: formatted.name,
          isDefault: formatted.isDefault
        });
        
        return formatted;
      });

      this.setData({
        addressList: formattedList,
      });
      
      logger.info('ADDRESS_LIST_PAGE', '地址列表数据设置完成', {
        totalCount: formattedList.length,
        defaultCount: formattedList.filter(addr => addr.isDefault === 1).length
      });
    }).catch((err) => {
      logger.error('ADDRESS_LIST_PAGE', '获取地址列表失败', { error: err.message || err });
      
      Toast({
        context: this,
        selector: '#t-toast',
        message: '获取地址列表失败',
        icon: '',
        duration: 1000,
      });
    });
  },
  getWXAddressHandle() {
    console.log('[地址列表-微信导入] 开始获取微信地址');
    
    wx.chooseAddress({
      success: (res) => {
        console.log('[地址列表-微信导入] wx.chooseAddress成功回调');
        console.log('[地址列表-微信导入] 微信返回的原始数据:', res);
        console.log('[地址列表-微信导入] errMsg:', res.errMsg);
        
        if (res.errMsg.indexOf('ok') === -1) {
          console.log('[地址列表-微信导入] errMsg检查失败，显示错误信息');
          Toast({
            context: this,
            selector: '#t-toast',
            message: res.errMsg,
            icon: '',
            duration: 1000,
          });
          return;
        }
        
        console.log('[地址列表-微信导入] errMsg检查通过，开始处理地址数据');
        
        const { length: len } = this.data.addressList;
        console.log('[地址列表-微信导入] 当前地址列表长度:', len);
        
        const newAddress = {
          name: res.userName,
          phoneNumber: res.telNumber,
          address: `${res.provinceName}${res.cityName}${res.countryName}${res.detailInfo}`,
          isDefault: 0,
          tag: '微信地址',
          id: len,
        };
        
        console.log('[地址列表-微信导入] 构建的新地址对象:', newAddress);
        
        this.setData({
          [`addressList[${len}]`]: newAddress,
        });
        
        console.log('[地址列表-微信导入] 地址已添加到列表，新列表长度:', len + 1);
        
        Toast({
          context: this,
          selector: '#t-toast',
          message: '添加成功',
          icon: '',
          duration: 1000,
        });
        
        console.log('[地址列表-微信导入] 微信地址导入完成');
      },
      fail: (err) => {
        console.error('[地址列表-微信导入] wx.chooseAddress失败:', err);
        console.log('[地址列表-微信导入] 失败原因:', err.errMsg);
      },
      complete: () => {
        console.log('[地址列表-微信导入] wx.chooseAddress调用完成');
      }
    });
  },
  confirmDeleteHandle({ detail }) {
    const { id } = detail || {};
    if (id !== undefined) {
      this.setData({ deleteID: id, showDeleteConfirm: true });
      Toast({
        context: this,
        selector: '#t-toast',
        message: '地址删除成功',
        theme: 'success',
        duration: 1000,
      });
    } else {
      Toast({
        context: this,
        selector: '#t-toast',
        message: '需要组件库发新版才能拿到地址ID',
        icon: '',
        duration: 1000,
      });
    }
  },
  deleteAddressHandle(e) {
    const { id } = e.currentTarget.dataset;
    
    logger.info('ADDRESS_LIST_PAGE', '开始删除地址', { addressId: id });
    
    // 调用API删除地址
    deleteAddress(id).then(() => {
      logger.info('ADDRESS_LIST_PAGE', '删除地址成功', { addressId: id });
      
      // 删除成功后从列表中移除
      this.setData({
        addressList: this.data.addressList.filter((address) => address.id !== id),
        deleteID: '',
        showDeleteConfirm: false,
      });
      
      Toast({
        context: this,
        selector: '#t-toast',
        message: '地址删除成功',
        theme: 'success',
        duration: 1000,
      });
    }).catch((err) => {
      logger.error('ADDRESS_LIST_PAGE', '删除地址失败', { 
        addressId: id, 
        error: err.message || err 
      });
      
      console.error('删除地址失败:', err);
      Toast({
        context: this,
        selector: '#t-toast',
        message: '删除地址失败',
        icon: '',
        duration: 1000,
      });
      
      // 关闭确认对话框
      this.setData({
        deleteID: '',
        showDeleteConfirm: false,
      });
    });
  },
  editAddressHandle({ detail }) {
    logger.info('ADDRESS_LIST_PAGE', '编辑地址', { addressDetail: detail });
    
    this.waitForNewAddress();

    const { id } = detail || {};
    wx.navigateTo({ url: `/pages/user/address/edit/index?id=${id}` });
  },
  selectHandle({ detail }) {
    logger.info('ADDRESS_LIST_PAGE', '选择地址', { 
      selectMode: this.selectMode, 
      addressDetail: detail 
    });
    
    if (this.selectMode) {
      this.hasSelect = true;
      
      // 将选择的地址存储到本地存储中，供订单确认页面使用
      wx.setStorageSync('selectedAddress', detail);
      logger.info('ADDRESS_LIST_PAGE', '地址已存储到本地存储', { selectedAddress: detail });
      
      resolveAddress(detail);
      wx.navigateBack({ delta: 1 });
    } else {
      this.editAddressHandle({ detail });
    }
  },
  createHandle() {
    logger.info('ADDRESS_LIST_PAGE', '创建新地址');
    
    this.waitForNewAddress();
    wx.navigateTo({ url: '/pages/user/address/edit/index' });
  },

  setDefaultAddressHandle({ detail }) {
    logger.info('ADDRESS_LIST_PAGE', '设置默认地址', { addressDetail: detail });
    
    const addressId = parseInt(detail.id || detail.addressId);
    
    if (!addressId) {
      logger.error('ADDRESS_LIST_PAGE', '地址ID无效', { detail });
      Toast({
        context: this,
        selector: '#t-toast',
        message: '地址ID无效',
        icon: '',
        duration: 1000,
      });
      return;
    }
    
    // 调用设置默认地址API
    setDefaultAddress(addressId)
      .then(() => {
        logger.info('ADDRESS_LIST_PAGE', '设置默认地址成功', { addressId });
        
        Toast({
          context: this,
          selector: '#t-toast',
          message: '设置默认地址成功',
          icon: '',
          duration: 1000,
        });
        
        // 更新本地地址列表
        const addressList = this.data.addressList.map(address => ({
          ...address,
          isDefault: (parseInt(address.id) === addressId || parseInt(address.addressId) === addressId) ? 1 : 0
        }));
        
        // 重新排序，默认地址排在前面
        addressList.sort((prevAddress, nextAddress) => {
          if (prevAddress.isDefault && !nextAddress.isDefault) {
            return -1;
          }
          if (!prevAddress.isDefault && nextAddress.isDefault) {
            return 1;
          }
          return 0;
        });
        
        this.setData({
          addressList: addressList,
        });
        
        logger.info('ADDRESS_LIST_PAGE', '地址列表已更新', {
          totalCount: addressList.length,
          defaultAddressId: addressId
        });
      })
      .catch((err) => {
        logger.error('ADDRESS_LIST_PAGE', '设置默认地址失败', { 
          addressId, 
          error: err.message || err 
        });
        
        Toast({
          context: this,
          selector: '#t-toast',
          message: '设置默认地址失败',
          icon: '',
          duration: 1000,
        });
      });
  },

  waitForNewAddress() {
    logger.debug('ADDRESS_LIST_PAGE', '等待新地址返回');
    
    getAddressPromise()
      .then((newAddress) => {
        logger.info('ADDRESS_LIST_PAGE', '收到新地址数据', { 
          addressId: newAddress.addressId,
          name: newAddress.name,
          isEdit: newAddress.isEdit
        });
        
        let addressList = [...this.data.addressList];

        newAddress.phoneNumber = newAddress.phone;
        newAddress.address = `${newAddress.provinceName}${newAddress.cityName}${newAddress.districtName}${newAddress.detailAddress}`;
        newAddress.tag = newAddress.addressTag;

        if (!newAddress.addressId) {
          logger.debug('ADDRESS_LIST_PAGE', '添加新地址到列表');
          
          newAddress.id = `${addressList.length}`;
          newAddress.addressId = `${addressList.length}`;

          if (newAddress.isDefault === 1) {
            logger.debug('ADDRESS_LIST_PAGE', '新地址设为默认，清除其他默认地址');
            addressList = addressList.map((address) => {
              address.isDefault = 0;
              return address;
            });
          } else {
            newAddress.isDefault = 0;
          }

          addressList.push(newAddress);
        } else {
          logger.debug('ADDRESS_LIST_PAGE', '更新现有地址');
          
          addressList = addressList.map((address) => {
            if (address.addressId === newAddress.addressId) {
              return newAddress;
            }
            return address;
          });
        }

        addressList.sort((prevAddress, nextAddress) => {
          if (prevAddress.isDefault && !nextAddress.isDefault) {
            return -1;
          }
          if (!prevAddress.isDefault && nextAddress.isDefault) {
            return 1;
          }
          return 0;
        });

        this.setData({
          addressList: addressList,
        });
        
        // 标记地址已被更新
        this.addressUpdated = true;
        
        logger.info('ADDRESS_LIST_PAGE', '地址列表更新完成', {
          totalCount: addressList.length,
          defaultCount: addressList.filter(addr => addr.isDefault === 1).length,
          addressUpdated: true
        });
      })
      .catch((e) => {
        if (e.message !== 'cancel') {
          logger.error('ADDRESS_LIST_PAGE', '地址编辑发生错误', { error: e.message || e });
          
          Toast({
            context: this,
            selector: '#t-toast',
            message: '地址编辑发生错误',
            icon: '',
            duration: 1000,
          });
        } else {
          logger.info('ADDRESS_LIST_PAGE', '用户取消地址编辑');
        }
      });
  },
});