/**
 * 投递配置状态管理
 */
export default {
  namespaced: true,
  state: {
    deliveryStats: {
      todayCount: 0,
      weekCount: 0,
      monthCount: 0,
      totalCount: 0,
      successCount: 0,
      failedCount: 0,
      pendingCount: 0,
      interviewCount: 0,
      successRate: 0,
      interviewRate: 0
    },
    deliveryConfig: {
      autoDelivery: false,
      interval: 30,
      minSalary: 15000,
      maxSalary: 30000,
      scrollPages: 3,
      maxPerBatch: 10,
      filterKeywords: '',
      excludeKeywords: '',
      startTime: '09:00',
      endTime: '18:00',
      workdaysOnly: true
    }
  },
  mutations: {
    SET_DELIVERY_STATS(state, stats) {
      state.deliveryStats = { ...state.deliveryStats, ...stats };
    },
    SET_DELIVERY_CONFIG(state, config) {
      state.deliveryConfig = { ...state.deliveryConfig, ...config };
    },
    UPDATE_DELIVERY_CONFIG(state, { key, value }) {
      state.deliveryConfig[key] = value;
    }
  },
  actions: {
    updateDeliveryStats({ commit }, stats) {
      commit('SET_DELIVERY_STATS', stats);
    },
    async loadDeliveryStats({ commit, rootState }) {
      try {
        const snCode = rootState.auth.snCode;
        if (!snCode) {
          console.warn('[Delivery Store] 没有 snCode，无法加载统计数据');
          return { success: false, error: '请先登录' };
        }

        // 动态导入 API
        const applyRecordsAPI = (await import('../../api/apply_records.js')).default;
        const result = await applyRecordsAPI.getStatistics(snCode);

        // 后端返回格式：{ code: 0, data: {...} }
        if (result && result.code === 0 && result.data) {
          commit('SET_DELIVERY_STATS', result.data);
          return { success: true };
        } else {
          const errorMsg = result?.message || '加载统计失败';
          console.error('[Delivery Store] 加载统计失败:', result);
          return { success: false, error: errorMsg };
        }
      } catch (error) {
        console.error('[Delivery Store] 加载统计失败:', error);
        return { success: false, error: error.message || '加载统计失败' };
      }
    },
    updateDeliveryConfig({ commit }, { key, value }) {
      commit('UPDATE_DELIVERY_CONFIG', { key, value });
    },
    setDeliveryConfig({ commit }, config) {
      commit('SET_DELIVERY_CONFIG', config);
    },
    async saveDeliveryConfig({ state, rootState }) {
      try {
        const snCode = rootState.auth.snCode;
        if (!snCode) {
          return { success: false, error: '请先登录' };
        }

        // 将前端配置格式转换为后端格式
        const deliverConfig = {
          auto_delivery: state.deliveryConfig.autoDelivery || false,
          interval: state.deliveryConfig.interval || 30,
          min_salary: state.deliveryConfig.minSalary || 0,
          max_salary: state.deliveryConfig.maxSalary || 0,
          scroll_pages: state.deliveryConfig.scrollPages || 3,
          max_per_batch: state.deliveryConfig.maxPerBatch || 10,
          filter_keywords: state.deliveryConfig.filterKeywords || '',
          exclude_keywords: state.deliveryConfig.excludeKeywords || '',
          start_time: state.deliveryConfig.startTime || '09:00',
          end_time: state.deliveryConfig.endTime || '18:00',
          // 将布尔值转换为数字 1/0，后端期望数字类型
          workdays_only: state.deliveryConfig.workdaysOnly ? 1 : 0
        };

        // 动态导入 API
        const deliveryConfigAPI = (await import('../../api/delivery_config.js')).default;
        const result = await deliveryConfigAPI.saveConfig(snCode, deliverConfig);

        // 后端返回格式：{ code: 0, message: 'success', data: {...} }
        // 或者：{ success: true, ... }
        if (result && (result.code === 0 || result.success === true)) {
          return { success: true };
        } else {
          const errorMsg = result?.message || result?.error || '保存失败';
          console.error('[Delivery Store] 保存配置失败:', result);
          return { success: false, error: errorMsg };
        }
      } catch (error) {
        console.error('[Delivery Store] 保存配置失败:', error);
        return { success: false, error: error.message || '保存配置失败' };
      }
    },
    async loadDeliveryConfig({ commit, rootState }) {
      try {
        const snCode = rootState.auth.snCode;
        if (!snCode) {
          // 如果没有登录，使用默认配置
          return { success: true };
        }

        // 动态导入 API
        const deliveryConfigAPI = (await import('../../api/delivery_config.js')).default;
        const result = await deliveryConfigAPI.getConfig(snCode);

        // 后端返回格式：{ code: 0, data: { deliver_config: {...} } }
        if (result && result.data && result.data.deliver_config) {
          const deliverConfig = result.data.deliver_config;
          // 将后端格式转换为前端格式
          const frontendConfig = {
            autoDelivery: deliverConfig.auto_delivery || false,
            interval: deliverConfig.interval || 30,
            minSalary: deliverConfig.min_salary || 0,
            maxSalary: deliverConfig.max_salary || 0,
            scrollPages: deliverConfig.scroll_pages || 3,
            maxPerBatch: deliverConfig.max_per_batch || 10,
            filterKeywords: deliverConfig.filter_keywords || '',
            excludeKeywords: deliverConfig.exclude_keywords || '',
            startTime: deliverConfig.start_time || '09:00',
            endTime: deliverConfig.end_time || '18:00',
            // 将数字 1/0 转换为布尔值，前端使用布尔值
            workdaysOnly: deliverConfig.workdays_only === 1 || deliverConfig.workdays_only === true
          };
          commit('SET_DELIVERY_CONFIG', frontendConfig);
          return { success: true };
        } else {
          // 如果获取失败，使用默认配置
          return { success: true };
        }
      } catch (error) {
        console.error('[Delivery Store] 加载配置失败:', error);
        // 如果加载失败，使用默认配置
        return { success: true };
      }
    }
  }
};