import request from '@/utils/request';

// 需求统计数据类型定义
export interface UserDemandStat {
  userId: number;
  userName: string;
  realName?: string;  // 真实姓名
  deptName: string;
  totalDemands: number;
  completedDemands: number;
  pendingDemands: number;
  totalScore: number;
  avgScore: number;
  completionRate: number;
  satisfactionRate: number;
}

export interface DeptDemandStat {
  deptId: number;
  deptName: string;
  totalDemands: number;
  completedDemands: number;
  pendingDemands: number;
  totalScore: number;
  remainingScore: number;
  dailyLimit: number;
  weeklyLimit: number;
  monthlyLimit: number;
  dailyUsed: number;
  weeklyUsed: number;
  monthlyUsed: number;
  utilizationRate: number;
  alertLevel: string;
}

export interface TrendData {
  date: string;
  demandCount: number;
  completedCount: number;
  scoreUsed: number;
}

export interface TypeDistribution {
  typeName: string;
  count: number;
  percentage: number;
  totalScore: number;
}

export interface OverviewData {
  totalDemands: number;
  todayDemands: number;
  weekDemands: number;
  monthDemands: number;
  completedDemands: number;
  pendingDemands: number;
  canceledDemands: number;
  totalScoreUsed: number;
  todayScoreUsed: number;
  weekScoreUsed: number;
  monthScoreUsed: number;
  avgCompletionTime: number;
  avgSatisfaction: number;
}

export interface DemandStatistics {
  userStats: UserDemandStat[];
  deptStats: DeptDemandStat[];
  trendData: TrendData[];
  typeDistribution: TypeDistribution[];
  overview: OverviewData;
}

// ==================== 设计师绩效类型 ====================

export interface DesignerStat {
  userId: number;
  userName: string;
  realName: string;
  deptName: string;
  deptId: number;
  receivedCount: number;
  completedCount: number;
  inProgressCount: number;
  completionRate: number;
  onTimeRate: number;
  onTimeCount: number;
  overdueCount: number;
  avgProcessTime: number;
  avgRating: number;
  fiveStarCount: number;
  satisfactionRate: number;
  totalScore: number;
  deductionScore?: number;
  netScore?: number;
  targetScore?: number;
  targetCompletionRate?: number;
  weekCompletedCount: number;
  monthCompletedCount: number;
}

export interface WorkloadStat {
  userId: number;
  userName: string;
  realName: string;
  deptName: string;
  currentLoad: number;
  loadLevel: string;
  earliestDeadline: string;
  avgDailyTasks: number;
}

export interface DesignerPerformanceSummary {
  totalDesigners: number;
  totalReceived: number;
  totalCompleted: number;
  avgCompletionRate: number;
  avgOnTimeRate: number;
  avgProcessTime: number;
  avgSatisfaction: number;
  overloadCount: number;
}

export interface DesignerPerformance {
  designerStats: DesignerStat[];
  workloadStats: WorkloadStat[];
  summary: DesignerPerformanceSummary;
}

// ==================== 流程效率类型 ====================

export interface StageTimeStats {
  demandApprovalTime: number;
  receivingApprovalTime: number;
  grabWaitTime: number;
  processTime: number;
  totalCycleTime: number;
  bottleneckStage: string;
  bottleneckPercentage: number;
}

export interface EfficiencyMetrics {
  weekDemandApprovalTime: number;
  weekReceivingApprovalTime: number;
  weekGrabWaitTime: number;
  weekProcessTime: number;
  weekFirstPassRate: number;
  lastWeekDemandApprovalTime: number;
  lastWeekReceivingApprovalTime: number;
  lastWeekGrabWaitTime: number;
  lastWeekProcessTime: number;
  lastWeekFirstPassRate: number;
  monthDemandApprovalTime: number;
  monthReceivingApprovalTime: number;
  monthGrabWaitTime: number;
  monthProcessTime: number;
  monthFirstPassRate: number;
  totalRejected: number;
  rejectionRate: number;
}

export interface StageDistribution {
  stageName: string;
  avgTime: number;
  percentage: number;
}

export interface ProcessEfficiency {
  stageTimeStats: StageTimeStats;
  efficiencyMetrics: EfficiencyMetrics;
  approvalTrend: TrendData[];
  stageDistribution: StageDistribution[];
}

// ==================== 预警任务类型 ====================

export interface WarningTask {
  taskId: number;
  taskNo: string;
  taskTitle: string;
  status: string;
  statusText: string;
  warningLevel: string;
  warningType: string;
  warningReason: string;
  receiverId: number | null;
  receiverName: string | null;
  receiverDeptName: string | null;
  publisherName: string | null;
  estimatedHours: number | null;
  deadline: string | null;
  createTime: string;
  startTime: string | null;
  hoursInfo: number;
  score: number;
}

// ==================== API函数 ====================

/**
 * 获取需求统计数据
 */
export const getDemandStatistics = async (
  dateRange: string = 'month',
  deptId?: number,
  userId?: number,
  month?: string
): Promise<DemandStatistics> => {
  const params: any = { dateRange };
  if (deptId) params.deptId = deptId;
  if (userId) params.userId = userId;
  if (month) params.month = month;

  const response = await request.get('/analytics/demand-statistics', { params });
  
  if (response && typeof response === 'object') {
    if ('data' in response && response.data !== undefined && response.data !== null) {
      return response.data as DemandStatistics;
    }
    if ('overview' in response || 'trendData' in response) {
      return response as unknown as DemandStatistics;
    }
  }
  
  return {
    overview: {
      totalDemands: 0,
      todayDemands: 0,
      weekDemands: 0,
      monthDemands: 0,
      completedDemands: 0,
      pendingDemands: 0,
      canceledDemands: 0,
      totalScoreUsed: 0,
      todayScoreUsed: 0,
      weekScoreUsed: 0,
      monthScoreUsed: 0,
      avgCompletionTime: 0,
      avgSatisfaction: 0
    },
    trendData: [],
    typeDistribution: [],
    userStats: [],
    deptStats: []
  };
};

/**
 * 获取设计师绩效数据
 */
export const getDesignerPerformance = async (
  month?: string,
  deptId?: number
): Promise<DesignerPerformance> => {
  const params: any = {};
  if (month) params.month = month;
  if (deptId) params.deptId = deptId;

  const response = await request.get('/analytics/designer-performance', { params });
  
  if (response && typeof response === 'object') {
    if ('data' in response && response.data !== undefined && response.data !== null) {
      return response.data as DesignerPerformance;
    }
    if ('designerStats' in response || 'summary' in response) {
      return response as unknown as DesignerPerformance;
    }
  }
  
  return {
    designerStats: [],
    workloadStats: [],
    summary: {
      totalDesigners: 0,
      totalReceived: 0,
      totalCompleted: 0,
      avgCompletionRate: 0,
      avgOnTimeRate: 0,
      avgProcessTime: 0,
      avgSatisfaction: 0,
      overloadCount: 0
    }
  };
};

/**
 * 获取流程效率数据
 */
export const getProcessEfficiency = async (
  month?: string
): Promise<ProcessEfficiency> => {
  const params: any = {};
  if (month) params.month = month;

  const response = await request.get('/analytics/process-efficiency', { params });
  
  if (response && typeof response === 'object') {
    if ('data' in response && response.data !== undefined && response.data !== null) {
      return response.data as ProcessEfficiency;
    }
    if ('stageTimeStats' in response || 'efficiencyMetrics' in response) {
      return response as unknown as ProcessEfficiency;
    }
  }
  
  return {
    stageTimeStats: {
      demandApprovalTime: 0,
      receivingApprovalTime: 0,
      grabWaitTime: 0,
      processTime: 0,
      totalCycleTime: 0,
      bottleneckStage: '',
      bottleneckPercentage: 0
    },
    efficiencyMetrics: {
      weekDemandApprovalTime: 0,
      weekReceivingApprovalTime: 0,
      weekGrabWaitTime: 0,
      weekProcessTime: 0,
      weekFirstPassRate: 0,
      lastWeekDemandApprovalTime: 0,
      lastWeekReceivingApprovalTime: 0,
      lastWeekGrabWaitTime: 0,
      lastWeekProcessTime: 0,
      lastWeekFirstPassRate: 0,
      monthDemandApprovalTime: 0,
      monthReceivingApprovalTime: 0,
      monthGrabWaitTime: 0,
      monthProcessTime: 0,
      monthFirstPassRate: 0,
      totalRejected: 0,
      rejectionRate: 0
    },
    approvalTrend: [],
    stageDistribution: []
  };
};

/**
 * 获取预警任务列表
 */
export const getWarningTasks = async (): Promise<WarningTask[]> => {
  const response = await request.get('/analytics/warnings');
  
  if (response && typeof response === 'object') {
    if ('data' in response && Array.isArray(response.data)) {
      return response.data as WarningTask[];
    }
    if (Array.isArray(response)) {
      return response as WarningTask[];
    }
  }
  
  return [];
};

// ==================== 扣分明细类型 ====================

export interface DelayDeductionItem {
  taskId: number;
  taskNo: string;
  taskTitle: string;
  taskScore: number;
  deadline: string;
  actualEndTime: string;
  overdueHours: number;
  deductionScore: number;
  deductionReason: string;
}

export interface ProgressDeductionItem {
  taskId: number;
  taskNo: string;
  taskTitle: string;
  deductionDate: string;
  deductionScore: number;
  reason: string;
}

export interface DeductionDetail {
  totalDeduction: number;
  delayDeductions: DelayDeductionItem[];
  progressDeductions: ProgressDeductionItem[];
}

/**
 * 获取设计师扣分明细
 */
export const getDesignerDeductionDetails = async (
  userId: number,
  month?: string
): Promise<DeductionDetail> => {
  const params: any = { userId };
  if (month) params.month = month;

  const response = await request.get('/analytics/designer-deduction-details', { params });
  
  if (response && typeof response === 'object') {
    if ('data' in response && response.data !== undefined && response.data !== null) {
      return response.data as DeductionDetail;
    }
    if ('totalDeduction' in response || 'delayDeductions' in response) {
      return response as unknown as DeductionDetail;
    }
  }
  
  return {
    totalDeduction: 0,
    delayDeductions: [],
    progressDeductions: []
  };
};