import {
  ActivityDataResponseData,
  MissionInfo,
  MissionActivityVO,
  MissionTabType
} from '../types/mission';
import {
  isMissionActivityActive,
  isAwardActivityActive,
  filterVisibleMissions,
  getMissionTimeRemaining,
  formatTimeRemaining
} from '../utils/mission-helpers';
import { MissionActivity } from '../classes/MissionActivity';
import { AwardActivity } from '../classes/AwardActivity';
import { UserInfo } from '../classes/UserInfo';
import { ProcessedActivityResult } from '../classes/ProcessedActivityResult';
import { MissionItem, MissionItemFactory, MissionExecutionContext } from '../classes/MissionItem';

/**
 * 预处理后的Tab数据接口
 */
export interface ProcessedTab {
  /** tab名称 */
  tabName: string;
  /** tab备注 */
  tabDesc: string;
  /** tab类型 */
  tabType: MissionTabType;
  /** 预处理后的任务列表 */
  missions: MissionItem[];
  /** 总任务数 */
  totalCount: number;
  /** 可领取任务数 */
  claimableCount: number;
  /** 已完成任务数 */
  completedCount: number;
  /** 是否有可领取的任务 */
  hasClaimableMissions: boolean;
}

/**
 * 预处理后的活动数据接口
 * @deprecated 使用 ProcessedActivityResult 类替代 - 保留用于向后兼容
 */
export interface ProcessedActivityData {
  /** 任务活动信息 */
  missionActivity: {
    /** 任务活动code */
    missionActivityCode: string;
    /** 活动开始时间 */
    activityStartTime: number;
    /** 活动结束时间 */
    activityEndTime: number;
    /** 是否进行中 */
    isActive: boolean;
    /** 剩余时间（毫秒） */
    timeRemaining: number;
    /** 格式化的剩余时间 */
    timeRemainingText: string;
    /** 预处理后的Tab列表 */
    tabList: ProcessedTab[];
  };
  /** 奖励活动信息 */
  awardActivity: {
    /** 兑换活动code */
    activityCode: string;
    /** 活动开始时间 */
    startTime: number;
    /** 活动结束时间 */
    endTime: number;
    /** 是否进行中 */
    isActive: boolean;
    /** 可兑换奖品数 */
    availablePrizesCount: number;
    /** 奖品列表 */
    items: any[];
  };
  /** 用户信息 */
  userInfo: {
    /** 用户积分数 */
    points: number;
    /** 积分图标 */
    pointsIcon: string;
    /** 是否有可领取任务 */
    hasClaimableMissions: boolean;
    /** 用户昵称 */
    nickname: string;
    /** 用户头像 */
    avatar: string;
    /** 用户ID */
    blogId?: number;
  };
}

/**
 * 任务处理器类
 */
export class MissionProcessor {
  /**
   * 处理单个任务信息，返回 MissionItem 实例
   * @param mission 任务信息
   * @param activityCode 活动code
   * @param missionActivityCode 任务活动code
   */
  static processMission(
    mission: MissionInfo,
    activityCode: string,
    missionActivityCode: string
  ): MissionItem {
    return MissionItemFactory.createProcessedMissionItem(mission, activityCode, missionActivityCode);
  }

  /**
   * 处理Tab数据
   * @param tab Tab数据
   * @param activityCode 活动code
   * @param missionActivityCode 任务活动code
   */
  static processTab(
    tab: MissionActivityVO['tabList'][0],
    activityCode: string,
    missionActivityCode: string
  ): ProcessedTab {
    console.log(`处理 Tab: ${tab.tabName}，原始任务数量：`, tab.missionInfoList?.length || 0);

    // 过滤并处理任务
    const visibleMissions = filterVisibleMissions(tab.missionInfoList);
    console.log(`Tab "${tab.tabName}" 过滤后的可见任务数量：`, visibleMissions.length);

    const processedMissions = visibleMissions.map(mission =>
      this.processMission(mission, activityCode, missionActivityCode)
    );

    const claimableCount = processedMissions.filter(m => m.isClaimable).length;
    const completedCount = processedMissions.filter(m => m.isCompleted).length;

    console.log(`Tab "${tab.tabName}" 最终任务数量：`, processedMissions.length);

    return {
      tabName: tab.tabName,
      tabDesc: tab.tabDesc,
      tabType: tab.tabType,
      missions: processedMissions,
      totalCount: processedMissions.length,
      claimableCount,
      completedCount,
      hasClaimableMissions: claimableCount > 0
    };
  }

  /**
   * 处理完整的活动数据（新版本 - 返回类实例）
   */
  static processActivityData(data: ActivityDataResponseData): ProcessedActivityResult {
    const { missionActivity, awardActivity, points, pointsIcon, blogInfo } = data.data;

    // 数据映射：将 missions 字段映射为 missionInfoList（兼容接口数据结构）
    const normalizedMissionActivity = {
      ...missionActivity,
      tabList: missionActivity.tabList.map(tab => ({
        ...tab,
        missionInfoList: (tab as any).missions || tab.missionInfoList || []
      }))
    };

    // 处理任务活动
    const timeRemaining = getMissionTimeRemaining(normalizedMissionActivity);
    const processedTabs = normalizedMissionActivity.tabList.map(tab =>
      this.processTab(tab, awardActivity.activityCode, normalizedMissionActivity.missionActivityCode)
    );

    // 检查是否有可领取任务
    const hasClaimableMissionsFlag = processedTabs.some(tab => tab.hasClaimableMissions);

    // 处理奖励活动
    const availablePrizesCount = awardActivity.items.filter(item => item.userStatus === 0).length;

    // 创建三个类实例
    const missionActivityInstance = new MissionActivity({
      missionActivityCode: normalizedMissionActivity.missionActivityCode,
      activityStartTime: normalizedMissionActivity.activityStartTime,
      activityEndTime: normalizedMissionActivity.activityEndTime,
      isActive: isMissionActivityActive(normalizedMissionActivity),
      timeRemaining,
      timeRemainingText: formatTimeRemaining(timeRemaining),
      tabList: processedTabs
    });

    const awardActivityInstance = new AwardActivity({
      activityCode: awardActivity.activityCode,
      startTime: awardActivity.startTime,
      endTime: awardActivity.endTime,
      isActive: isAwardActivityActive(awardActivity),
      availablePrizesCount,
      items: awardActivity.items
    });

    const userInfoInstance = new UserInfo({
      points,
      pointsIcon,
      hasClaimableMissions: hasClaimableMissionsFlag,
      nickname: blogInfo.blogNickName,
      avatar: blogInfo.headImage,
      blogId: blogInfo.blogId
    });

    return new ProcessedActivityResult(
      missionActivityInstance,
      awardActivityInstance,
      userInfoInstance
    );
  }

  /**
   * 根据showMissionType执行不同的任务逻辑
   * @deprecated 建议直接使用 MissionItem.executeTask() 方法
   * @param context 执行上下文
   * @param showMissionType 显示任务类型
   */
  static async executeByShowMissionType(
    context: MissionExecutionContext,
    showMissionType: number
  ): Promise<any> {
    // 创建临时的 MissionItem 来执行任务
    const tempMissionInfo: MissionInfo = {
      code: context.missionCode,
      showMissionType: showMissionType as any,
      // 必需字段
      awardName: '',
      awardNum: 0,
      title: '',
      subTitle: '',
      missionType: 1,
      missionStatus: 0,
      currentProgress: 0,
      totalProgress: 1,
      show: true,
      channelShow: true,
      showStatus: 0,
      actionCopyWriting: '',
      actionLinkUrl: '',
      awardIcon: '',
      highlightWords: [],
      stepRewardList: []
    };

    const missionItem = new MissionItem(tempMissionInfo, context);
    return await missionItem.executeTask();
  }
}