activityLink/src/views/choujiang/lottery/dataManager.js

import { reactive } from 'vue';
import { getPrizeListApi, getUserListApi } from '../../../api/API';
export function useDataManager() {
  const state = reactive({
    basicData: {
      prizes: [],
      users: [],
      luckyUsers: {},
      leftUsers: []
    },
    currentPrizeIndex: 0,
    currentPrize: null,
    currentLuckys: [],
    isLotting: false,
    // 新增：轮次管理
    currentRound: 1,
    config: {
      prizes: [],
      EACH_COUNT: [],
      COMPANY: '',
      HIGHLIGHT_CELL: [],
      Resolution: 1,
      ROW_COUNT: 7,
      COLUMN_COUNT: 20
    }
  });

  async function getBasicData() {
    // 获取奖品列表
    const prizeList = await getPrizeListApi();
    const fakePrizes = prizeList.data.map((item, index) => ({
      type: index, // 使用索引作为type
      title: item.gradeName,
      text: item.prizeName,
      count: item.amount,
      img: item.imageUrl,
      gradeId: item.gradeId,
      prizeId: item.prizeId,
      remainNum: item.remainNum,
      perWin:  item.perWin
    }));

    const fakeEachCount = prizeList.data.map(item => item.perWin);
    console.log("fakeEachCount", fakeEachCount);
    const fakeCompany = '前端假公司';
    const fakeLuckyData = {};
    fakePrizes.forEach((prize, index) => {
      fakeLuckyData[index] = [];
    });
    
    // 获取真实用户数据
    const userListResponse = await getUserListApi();
    console.log("dataManager调用一次接口", userListResponse);
    console.log("userList", userListResponse);
    
    // 将后端返回的用户数据转换为兼容格式
    const realUsers = userListResponse.data.map(item => ({
      jwcode: item.jwcode,
      username: item.username,
      company: fakeCompany // 使用默认公司名称
    }));
    
    state.config.prizes = fakePrizes;
    state.config.EACH_COUNT = fakeEachCount;
    state.config.COMPANY = fakeCompany;
    state.config.HIGHLIGHT_CELL = [];
    state.basicData.prizes = fakePrizes;
    state.basicData.users = realUsers; // 使用真实用户数据
    state.basicData.leftUsers = realUsers.slice(); // 初始化剩余用户为所有用户
    state.basicData.luckyUsers = fakeLuckyData;
    determineCurrentPrize();
    return Promise.resolve({
      cfgData: {
        prizes: fakePrizes,
        EACH_COUNT: fakeEachCount,
        COMPANY: fakeCompany
      },
      leftUsers: realUsers.slice(),
      luckyData: fakeLuckyData
    });
  }

  async function getUsers() {
    const userList = await getUserListApi();
    console.log("userList", userList);
    
    // 将后端返回的用户数据转换为兼容格式
    const realUsers = userList.data.map(item => ({
      jwcode: item.jwcode,
      username: item.username,
      company: state.config.COMPANY || '前端假公司'
    }));
    
    state.basicData.users = realUsers;
    return Promise.resolve(userList);
  }

  function determineCurrentPrize() {
    let prizeIndex = state.basicData.prizes.length - 1;
    for (; prizeIndex > -1; prizeIndex--) {
      if (
        state.basicData.luckyUsers[prizeIndex] &&
        state.basicData.luckyUsers[prizeIndex].length >=
          state.basicData.prizes[prizeIndex].count
      ) {
        continue;
      }
      state.currentPrizeIndex = prizeIndex;
      state.currentPrize = state.basicData.prizes[state.currentPrizeIndex];
      break;
    }
  }

  async function saveData(type, data) {
    return Promise.resolve();
  }
  async function setErrorData(data) { return Promise.resolve(); }
  async function exportData() { alert('导出功能为假数据模式，无实际导出。'); return Promise.resolve(); }
  async function resetData() { return Promise.resolve(); }

  function getTotalCards() {
    return state.config.ROW_COUNT * state.config.COLUMN_COUNT || 50;
  }
  function setLotteryStatus(status = false) { state.isLotting = status; }
  function resetAllData() {
    state.basicData.luckyUsers = {};
    state.basicData.leftUsers = state.basicData.users.slice();
    state.currentLuckys = [];
    determineCurrentPrize();
  }
  function updateCurrentPrize() { determineCurrentPrize(); }

  // 新增：计算当前奖品的总轮次
  function getTotalRounds(prizeIndex) {
    const prize = state.basicData.prizes[prizeIndex];
    const eachCount = state.config.EACH_COUNT[prizeIndex];
    if (!prize || !eachCount) return 0;
    return Math.ceil(prize.count / eachCount);
  }

  // 新增：计算当前轮次
  function getCurrentRound(prizeIndex) {
    const luckyUsers = state.basicData.luckyUsers[prizeIndex] || [];
    const eachCount = state.config.EACH_COUNT[prizeIndex];
    if (!eachCount) return 1;
    return Math.floor(luckyUsers.length / eachCount) + 1;
  }

  // 新增：计算剩余数量
  function getLeftCount(prizeIndex) {
    const prize = state.basicData.prizes[prizeIndex];
    const luckyUsers = state.basicData.luckyUsers[prizeIndex] || [];
    if (!prize) return 0;
    return prize.count - luckyUsers.length;
  }

  // 新增：更新当前轮次
  function updateCurrentRound() {
    state.currentRound = getCurrentRound(state.currentPrizeIndex);
  }

  // 新增：更新奖品列表数据
  async function updatePrizeList() {
    try {
      console.log('开始更新奖品列表数据...');
      const prizeList = await getPrizeListApi();
      const fakePrizes = prizeList.data.map((item, index) => ({
        type: index, // 使用索引作为type
        title: item.gradeName,
        text: item.prizeName,
        count: item.amount,
        img: item.imageUrl,
        gradeId: item.gradeId,
        prizeId: item.prizeId,
        remainNum: item.remainNum,
        perWin: item.perWin
      }));

      const fakeEachCount = prizeList.data.map(item => item.perWin);
      console.log("更新后的奖品列表:", fakePrizes);
      console.log("更新后的每轮数量:", fakeEachCount);
      
      // 更新配置数据
      state.config.prizes = fakePrizes;
      state.config.EACH_COUNT = fakeEachCount;
      state.basicData.prizes = fakePrizes;
      
      // 重新确定当前奖品
      determineCurrentPrize();
      
      console.log('奖品列表数据更新完成');
      return Promise.resolve(fakePrizes);
    } catch (error) {
      console.error('更新奖品列表失败:', error);
      return Promise.reject(error);
    }
  }

  return {
    state,
    getBasicData,
    getUsers,
    saveData,
    setErrorData,
    exportData,
    resetData,
    getTotalCards,
    setLotteryStatus,
    resetAllData,
    updateCurrentPrize,
    getTotalRounds,
    getCurrentRound,
    getLeftCount,
    updateCurrentRound,
    updatePrizeList
  };
}