/**
 * 绩效管理模块 API 服务
 * 模块: platform_performance
 */
import apiClient, { PaginatedData, ApiClientError } from '@/lib/api-client';

// ==================== 枚举定义 ====================

/**
 * 绩效周期类型
 */
export enum CycleType {
  ANNUAL = 'ANNUAL',
  SEMI_ANNUAL = 'SEMI_ANNUAL',
  QUARTERLY = 'QUARTERLY',
  MONTHLY = 'MONTHLY',
  CUSTOM = 'CUSTOM',
}

/**
 * 绩效周期状态
 */
export enum CycleStatus {
  DRAFT = 'DRAFT',
  GOAL_SETTING = 'GOAL_SETTING',
  IN_PROGRESS = 'IN_PROGRESS',
  EVALUATING = 'EVALUATING',
  CALIBRATING = 'CALIBRATING',
  CONFIRMING = 'CONFIRMING',
  COMPLETED = 'COMPLETED',
  ARCHIVED = 'ARCHIVED',
}

/**
 * KPI 考核状态
 */
export enum KpiAssessmentStatus {
  PENDING = 'PENDING',
  SELF_EVALUATED = 'SELF_EVALUATED',
  MANAGER_EVALUATED = 'MANAGER_EVALUATED',
  CONFIRMED = 'CONFIRMED',
}

/**
 * KPI 分配审批状态
 */
export enum KpiAssignmentStatus {
  DRAFT = 'DRAFT',
  SUBMITTED = 'SUBMITTED',
  APPROVED = 'APPROVED',
  REJECTED = 'REJECTED',
  PENDING_DEPENDENCY = 'PENDING_DEPENDENCY',
  CONFIRMED = 'CONFIRMED',
}

/**
 * 360 评估状态
 * 与后端 Evaluation360Status 保持一致
 */
export enum Evaluation360Status {
  DRAFT = 'DRAFT',
  IN_PROGRESS = 'IN_PROGRESS',
  COLLECTING = 'COLLECTING',
  COMPLETED = 'COMPLETED',
  RELEASED = 'RELEASED',
  CANCELLED = 'CANCELLED',
}

/**
 * 360 评估关系类型
 * 与后端 RelationType 保持一致
 */
export enum RelationshipType {
  SELF = 'SELF',
  SUPERVISOR = 'SUPERVISOR',
  PEER = 'PEER',
  SUBORDINATE = 'SUBORDINATE',
  CROSS_FUNCTIONAL = 'CROSS_FUNCTIONAL',
}

/**
 * 匿名级别
 */
export enum AnonymityLevel {
  NONE = 'NONE',
  PARTIAL = 'PARTIAL',
  FULL = 'FULL',
}


/**
 * 校准会议状态
 */
export type CalibrationStatus = 'SCHEDULED' | 'IN_PROGRESS' | 'COMPLETED';
export const CalibrationStatus = {
  SCHEDULED: 'SCHEDULED' as CalibrationStatus,
  IN_PROGRESS: 'IN_PROGRESS' as CalibrationStatus,
  COMPLETED: 'COMPLETED' as CalibrationStatus,
};

// ==================== 工具函数 ====================

/**
 * 周期状态中文/英文映射（用于在周期名后追加状态标签）
 */
const CYCLE_STATUS_LABELS: Record<CycleStatus, { zh: string; en: string }> = {
  [CycleStatus.DRAFT]:        { zh: '草稿', en: 'Draft' },
  [CycleStatus.GOAL_SETTING]: { zh: '目标设定中', en: 'Goal Setting' },
  [CycleStatus.IN_PROGRESS]:  { zh: '执行中', en: 'In Progress' },
  [CycleStatus.EVALUATING]:   { zh: '评估中', en: 'Evaluating' },
  [CycleStatus.CALIBRATING]:  { zh: '校准中', en: 'Calibrating' },
  [CycleStatus.CONFIRMING]:   { zh: '结果确认中', en: 'Confirming' },
  [CycleStatus.COMPLETED]:    { zh: '已完成', en: 'Completed' },
  [CycleStatus.ARCHIVED]:     { zh: '已归档', en: 'Archived' },
};

/**
 * 获取带状态后缀的周期显示名
 * 例: "2025 Q3 校准周期 · 校准中"
 */
export function getCycleDisplayName(cycle: { name: string; status: CycleStatus }, locale: string = 'zh'): string {
  const label = CYCLE_STATUS_LABELS[cycle.status];
  const suffix = locale.startsWith('en') ? label?.en : label?.zh;
  return suffix ? `${cycle.name} · ${suffix}` : cycle.name;
}

// ==================== 基础类型 ====================

/**
 * 用户简要信息
 */
export interface UserBrief {
  id: string;
  displayName: string;
  email?: string;
  avatar?: string;
}

/**
 * 部门简要信息
 */
export interface DepartmentBrief {
  id: string;
  name: string;
  code?: string;
}

/**
 * 组织简要信息
 */
export interface OrganizationBrief {
  id: string;
  code: string;
  name: string;
}

// ==================== 周期相关类型 ====================

/**
 * 绩效周期
 * 字段与后端 CycleResponseDto 保持一致
 */
export interface PerformanceCycle {
  id: string;
  name: string;
  type: CycleType;
  status: CycleStatus;
  startDate: string;
  endDate: string;
  gradeConfigId?: string;
  gradeConfig?: GradeConfig;
  resultsPublishedAt?: string;
  resultsPublishedBy?: string;
  /** 组织ID */
  organizationId?: string;
  /** 关联的组织信息 */
  organization?: OrganizationBrief;
  createdBy?: string;
  createdAt: string;
  updatedAt: string;
  /** 父周期ID（子周期指向父周期） */
  parentCycleId?: string | null;
  /** 父周期引用 */
  parentCycle?: PerformanceCycle;
  /** 子周期列表 */
  childCycles?: PerformanceCycle[];
}

/**
 * 创建周期参数
 * 与后端 CreateCycleDto 保持一致
 */
export interface CreateCycleParams {
  name: string;
  type: CycleType;
  startDate: string;
  endDate: string;
  gradeConfigId?: string;
  /** 组织ID（可选，null 表示平台级数据） */
  organizationId?: string;
  /** 父周期ID（创建子周期时指定） */
  parentCycleId?: string;
}

/**
 * 更新周期参数
 */
export interface UpdateCycleParams extends Partial<CreateCycleParams> {}

/**
 * 查询周期参数
 * 与后端 QueryCycleDto 保持一致
 */
export interface QueryCycleParams {
  page?: number;
  pageSize?: number;
  status?: CycleStatus;
  type?: CycleType;
  /** 按组织ID过滤 */
  organizationId?: string;
}

/**
 * 周期统计数据
 */
export interface CycleStatistics {
  totalEmployees: number;
  kpiStats: {
    total: number;
    selfEvaluated: number;
    managerEvaluated: number;
    confirmed: number;
  };
  evaluation360Stats: {
    total: number;
    completed: number;
    pending: number;
  };
}

/**
 * 目标设定进度（管理员概览用）
 */
export interface GoalSettingProgress {
  totalEmployees: number;
  submittedCount: number;
  draftCount: number;
  notStartedCount: number;
  departments: {
    id: string;
    name: string;
    total: number;
    submitted: number;
    draft: number;
    notStarted: number;
  }[];
  pendingEmployees: {
    id: string;
    name: string;
    departmentName: string;
    status: 'draft' | 'not_started';
    kpiCount: number;
  }[];
}

/**
 * 评估进度（管理员概览 — 评估阶段用）
 */
export interface EvaluationProgress {
  totalEmployees: number;
  selfEvalCompleted: number;
  managerEvalCompleted: number;
  e360Total: number;
  e360Completed: number;
  departments: {
    id: string;
    name: string;
    total: number;
    selfCompleted: number;
    managerCompleted: number;
    e360Total: number;
    e360Completed: number;
  }[];
  pendingEmployees: {
    id: string;
    name: string;
    departmentName: string;
    pendingType: 'self' | 'manager' | 'both';
    e360Pending: boolean;
  }[];
}

/**
 * 校准进度（管理员概览 — 校准阶段用）
 */
export interface CalibrationProgress {
  totalEmployees: number;
  calibratedCount: number;
  gradeDistribution: {
    code: string;
    name: string;
    color: string;
    count: number;
  }[];
  departments: {
    id: string;
    name: string;
    total: number;
    calibrated: number;
    grades: { code: string; count: number }[];
  }[];
  pendingEmployees: {
    id: string;
    name: string;
    departmentName: string;
    avgScore: number;
    currentGrade: string;
  }[];
}

/**
 * 周期结果汇总（管理员概览 — 已完成/已归档阶段用）
 */
export interface CycleResultsSummary {
  totalEmployees: number;
  avgScore: number;
  gradeDistribution: {
    code: string;
    name: string;
    color: string;
    count: number;
  }[];
  departments: {
    id: string;
    name: string;
    total: number;
    avgScore: number;
    grades: { code: string; count: number }[];
  }[];
  completionStats: {
    selfEval: { total: number; completed: number };
    managerEval: { total: number; completed: number };
    e360: { total: number; completed: number };
    calibration: { total: number; completed: number };
  };
  total?: number;
  confirmed?: number;
  viewed?: number;
  appealed?: number;
}

// ==================== 等级配置类型 ====================

/**
 * 绩效等级
 */
export interface Grade {
  code: string;
  name: string;
  minScore: number;
  maxScore: number;
  color: string;
  description?: string;
}

/**
 * 等级配置
 */
export interface GradeConfig {
  id: string;
  name: string;
  description?: string;
  grades: Grade[];
  isDefault: boolean;
  /** 组织ID */
  organizationId?: string;
  /** 关联的组织信息 */
  organization?: OrganizationBrief;
  createdAt: string;
  updatedAt: string;
}

/**
 * 创建等级配置参数
 */
export interface CreateGradeConfigParams {
  name: string;
  description?: string;
  grades: Grade[];
  /** 组织ID（可选，null 表示平台级数据） */
  organizationId?: string;
}

/**
 * 查询等级配置参数
 */
export interface QueryGradeConfigParams {
  /** 按组织ID过滤 */
  organizationId?: string;
  isActive?: boolean;
}

// ==================== KPI 相关类型 ====================

/**
 * KPI 分配
 */
export interface KpiAssignment {
  id: string;
  cycleId: string;
  employeeId: string;
  employee: UserBrief;
  name: string;
  weight?: number;
  targetValue?: number;
  assessment?: KpiAssessment;
  parentId?: string | null;
  seq?: number | null;
  children?: KpiAssignment[];
  maturityScore?: number | null;
  /** 基本目标 */
  baseTarget?: string;
  /** 挑战目标 */
  stretchTarget?: string;
  dependentUserId?: string | null;
  dependentAssignmentId?: string | null;
  dependentAssignment?: KpiAssignment | null;
  dependentUser?: { id: string; displayName: string } | null;
  /** A 对依赖人的需求描述 */
  dependencyDescription?: string | null;
  /** 依赖确认状态 */
  dependencyStatus?: 'PENDING' | 'CONFIRMED' | 'REJECTED' | null;
  /** 依赖人拒绝原因 */
  dependencyRejectionReason?: string | null;
  status?: KpiAssignmentStatus;
  rejectionReason?: string | null;
  approvedBy?: string | null;
  approvedAt?: string | null;
  submittedAt?: string | null;
  dependencyConfirmedAt?: string | null;
  createdAt: string;
  updatedAt: string;
  [key: string]: any;
}

/**
 * KPI 考核
 */
export interface KpiAssessment {
  id: string;
  assignmentId: string;
  assignment: KpiAssignment;
  selfScore?: number;
  selfComment?: string;
  managerScore?: number;
  managerComment?: string;
  finalScore?: number;
  status: KpiAssessmentStatus;
  createdAt: string;
  updatedAt: string;
}

/**
 * 自评参数
 */
export interface SelfEvaluateParams {
  selfScore: number;
  selfComment?: string;
}

/**
 * 他评参数
 */
export interface ManagerEvaluateParams {
  managerScore: number;
  managerComment?: string;
}

/**
 * 查询 KPI 分配参数
 */
export interface QueryKpiAssignmentParams {
  page?: number;
  pageSize?: number;
  cycleId?: string;
  employeeId?: string;
}

/**
 * KPI 分配参数
 */
export interface AssignKpiParams {
  cycleId: string;
  employeeId: string;
  name: string;
  weight: number;
  targetValue?: number;
  baseTarget?: string;
  stretchTarget?: string;
  dependentUserId?: string;
  dependencyDescription?: string;
  parentId?: string;
}

// ==================== 360 评估模板类型 ====================

/**
 * 360 评估维度
 */
export interface Evaluation360Dimension {
  id: string;
  name: string;
  nameEn?: string;
  description: string;
  descriptionEn?: string;
}

/**
 * 360 评估模板
 */
export interface TemplateScope {
  scopeType: 'ALL' | 'DEPARTMENT' | 'LEVEL' | 'CUSTOM';
  departmentIds?: string[];
  minLevel?: number;
  userIds?: string[];
}

export interface Evaluation360Template {
  id: string;
  name: string;
  description?: string;
  dimensions: Evaluation360Dimension[];
  relationshipTypes: RelationshipType[];
  isDefault: boolean;
  organizationId?: string;
  cycleId?: string;
  scope?: TemplateScope | null;
  createdAt: string;
  updatedAt: string;
}

// ==================== 360 评估类型 ====================

/**
 * 360 评估任务
 */
export interface EvaluationTask {
  id: string;
  evaluation360Id: string;
  evaluatorId: string;
  evaluator: UserBrief;
  relationship: RelationshipType;
  status: 'PENDING' | 'COMPLETED' | 'SUBMITTED' | 'EXPIRED' | 'CANCELLED';
  score?: number;
  feedback?: string;
  dueDate?: string;
  submittedAt?: string;
  createdAt: string;
  updatedAt: string;
  // 关联的评估信息（在某些查询中包含）
  evaluation?: {
    id: string;
    title?: string;
    targetUser?: UserBrief;
    status: Evaluation360Status;
  };
}

/**
 * 360 评估
 */
export interface Evaluation360 {
  id: string;
  cycleId: string;
  evaluateeId: string;
  evaluatee: UserBrief;
  status: Evaluation360Status;
  anonymityLevel: AnonymityLevel;
  tasks: EvaluationTask[];
  aggregateScore?: number;
  summary?: string;
  startedAt?: string;
  completedAt?: string;
  releasedAt?: string;
  createdAt: string;
  updatedAt: string;
}

/**
 * 创建 360 评估参数
 */
export interface CreateEvaluation360Params {
  cycleId: string;
  evaluateeId: string;
  anonymityLevel?: AnonymityLevel;
}

/**
 * 更新 360 评估参数（对齐后端 UpdateEvaluation360Dto）
 */
export interface UpdateEvaluation360Params {
  deadline?: string;
  templateId?: string;
  minEvaluators?: number;
}

/**
 * 添加评估人参数
 */
export interface AddEvaluatorsParams {
  evaluators: {
    evaluatorId: string;
    relationship: RelationshipType;
  }[];
}

/**
 * 提交反馈参数
 */
export interface SubmitFeedbackParams {
  responses: Array<{
    dimension: string;
    score: number;
    comment?: string;
  }>;
  overallComment?: string;
}

/**
 * 查询 360 评估参数
 */
export interface QueryEvaluation360Params {
  page?: number;
  pageSize?: number;
  cycleId?: string;
  evaluateeId?: string;
  status?: Evaluation360Status;
}

/**
 * 360 评估结果
 */
export interface Evaluation360Result {
  evaluationId: string;
  aggregateScore: number;
  completedCount?: number;
  totalCount?: number;
  scoresByRelationship: {
    relationship: RelationshipType;
    avgScore: number;
    count: number;
  }[];
  dimensionScores?: {
    dimension: string;
    avgScore: number;
    scoresByRelationship: {
      relationship: RelationshipType;
      avgScore: number;
    }[];
  }[];
  feedbackSummary?: string;
}

// ==================== 校准相关类型 ====================

/**
 * 校准参与者
 */
export interface CalibrationParticipant {
  id: string;
  sessionId: string;
  employeeId: string;
  employee: UserBrief;
  originalGrade: string;
  adjustedGrade?: string;
  totalScore: number;
  createdAt: string;
  updatedAt: string;
}

/**
 * 等级调整日志
 */
export interface GradeAdjustmentLog {
  id: string;
  participantId: string;
  fromGrade: string;
  toGrade: string;
  reason: string;
  adjustedBy: UserBrief;
  createdAt: string;
}

/**
 * 等级分布数据
 */
export interface GradeDistribution {
  grade: string;
  gradeName: string;
  count: number;
  percentage: number;
  target?: number;
}

// ==================== 绩效结果类型 ====================

/**
 * 我的绩效结果列表项
 */
/** 结果确认状态 */
export enum ResultConfirmStatus {
  PENDING = 'PENDING',
  CONFIRMED = 'CONFIRMED',
  APPEALED = 'APPEALED',
  APPEAL_RESOLVED = 'APPEAL_RESOLVED',
}

export interface MyResultListItem {
  id: string;
  cycleId: string;
  cycleName: string;
  cycleType: CycleType;
  totalScore: number;
  gradeCode: string;
  gradeName: string;
  gradeColor?: string;
  isPublished: boolean;
  publishedAt?: string;
  viewedByEmployee?: boolean;
  viewedAt?: string;
  confirmStatus?: ResultConfirmStatus;
  confirmedAt?: string;
  appealReason?: string;
  appealedAt?: string;
  appealResolvedAt?: string;
  appealResponse?: string;
}

/**
 * 我的绩效结果详情
 */
export interface MyResultDetail {
  id: string;
  cycleId: string;
  cycleName: string;
  employeeId: string;
  employeeName?: string;
  kpiScore?: number | null;
  kpiWeight?: number | null;
  e360Score?: number | null;
  e360Weight?: number | null;
  totalScore: number;
  /** 校准前原始加权分 (若校准未调整则与 totalScore 相同) */
  originalScore?: number;
  /** 是否经过校准调整 */
  isCalibrated?: boolean;
  gradeCode: string;
  gradeName: string;
  gradeColor?: string;
  scoreBreakdown?: {
    kpiDetails: Array<{
      name: string;
      weight: number;
      selfScore: number;
      managerScore: number;
      finalScore?: number;
      selfComment?: string;
      managerComment?: string;
    }>;
  };
  isPublished: boolean;
  publishedAt?: string;
  remarks?: string | null;
  confirmStatus?: ResultConfirmStatus;
  confirmedAt?: string;
  appealReason?: string;
  appealedAt?: string;
  appealResolvedAt?: string;
  appealResponse?: string;
}

/**
 * 管理视图绩效结果项
 */
export interface ResultListItem {
  id: string;
  employeeId: string;
  employeeName?: string;
  departmentName?: string;
  totalScore: number;
  gradeCode: string;
  gradeName: string;
  isPublished: boolean;
  viewedByEmployee?: boolean;
  confirmStatus?: ResultConfirmStatus;
  appealReason?: string;
}

export interface ResultListSummary {
  totalEmployees: number;
  publishedCount: number;
  viewedCount: number;
  confirmedCount: number;
  appealedCount: number;
}

export interface ResultListResponse {
  items: ResultListItem[];
  pagination: {
    page: number;
    pageSize: number;
    total: number;
    totalPages: number;
  };
  summary: ResultListSummary;
}

export interface MyResultsResponse {
  items: MyResultListItem[];
  total: number;
  page: number;
  pageSize: number;
}

export interface CalculateResultsPayload {
  cycleId: string;
  weights: { kpi: number; e360: number };
  employeeIds?: string[];
}

export interface CalculateResultsResponse {
  cycleId: string;
  calculated: number;
  failed: number;
  failedEmployees: Array<{ employeeId: string; reason: string }>;
}

export interface PublishResultsPayload {
  employeeIds?: string[];
  notifyEmployees?: boolean;
}

export interface PublishResultsResponse {
  cycleId: string;
  published: number;
  alreadyPublished: number;
  notified: number;
}

export interface ExportResultsPayload {
  cycleId: string;
  format?: 'xlsx' | 'csv';
  fields?: string[];
}

export interface ExportResultsResponse {
  downloadUrl: string;
  expiresAt: string;
}

export interface MarkViewedResponse {
  id: string;
  viewedByEmployee: boolean;
  viewedAt: string;
}

/**
 * 查询绩效结果参数
 * 与后端 QueryResultDto 保持一致
 */
export interface QueryResultParams {
  page?: number;
  pageSize?: number;
  cycleId?: string;
  employeeId?: string;
  departmentId?: string;
  gradeCode?: string;
  isPublished?: boolean;
}

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

const BASE_URL = '/performance';
// -------------------- 周期管理 --------------------

/**
 * 获取周期列表
 */
export async function getCycles(params?: QueryCycleParams): Promise<PaginatedData<PerformanceCycle>> {
  return apiClient.get(`${BASE_URL}/cycles`, { params });
}

/**
 * 获取周期详情
 */
export async function getCycleById(id: string): Promise<PerformanceCycle> {
  return apiClient.get(`${BASE_URL}/cycles/${id}`);
}

/**
 * 获取当前活跃周期
 */
export async function getCurrentCycle(organizationId?: string): Promise<PerformanceCycle | null> {
  return apiClient.get(`${BASE_URL}/cycles/active`, { params: { organizationId } });
}

/**
 * 创建周期
 */
export async function createCycle(params: CreateCycleParams): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles`, params);
}

/**
 * 更新周期
 */
export async function updateCycle(id: string, params: UpdateCycleParams): Promise<PerformanceCycle> {
  return apiClient.patch(`${BASE_URL}/cycles/${id}`, params);
}

/**
 * 删除周期
 */
export async function deleteCycle(id: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/cycles/${id}`);
}

/**
 * 发布周期 (DRAFT -> GOAL_SETTING)
 */
export async function publishCycle(id: string): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles/${id}/publish`);
}

/**
 * 开始执行 (GOAL_SETTING -> IN_PROGRESS)
 */
export async function startExecution(id: string): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles/${id}/start-execution`);
}

/**
 * 开始评估 (IN_PROGRESS -> EVALUATING)
 */
export async function startEvaluation(id: string): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles/${id}/start-evaluation`);
}

/**
 * 开始校准 (EVALUATING -> CALIBRATING)
 */
export async function startCalibration(id: string): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles/${id}/start-calibration`);
}

/**
 * 发布结果并进入确认阶段 (CALIBRATING -> CONFIRMING)
 */
export async function startConfirming(id: string): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles/${id}/start-confirming`);
}

/**
 * 完成周期 (CONFIRMING -> COMPLETED)
 */
export async function completeCycle(id: string): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles/${id}/complete`);
}

/**
 * 归档周期 (COMPLETED -> ARCHIVED)
 */
export async function archiveCycle(id: string, options?: { force?: boolean; interviewThreshold?: number }): Promise<PerformanceCycle> {
  return apiClient.post(`${BASE_URL}/cycles/${id}/archive`, options);
}

/**
 * 获取周期统计
 */
export async function getCycleStatistics(id: string): Promise<CycleStatistics> {
  return apiClient.get(`${BASE_URL}/cycles/${id}/statistics`);
}

/**
 * 获取目标设定进度（管理员概览 — 目标设定阶段用）
 */
export async function getGoalSettingProgress(cycleId: string): Promise<GoalSettingProgress> {
  return apiClient.get(`${BASE_URL}/cycles/${cycleId}/goal-setting-progress`);
}

/**
 * 获取评估进度（管理员概览 — 评估阶段用）
 */
export async function getEvaluationProgress(cycleId: string): Promise<EvaluationProgress> {
  return apiClient.get(`${BASE_URL}/cycles/${cycleId}/evaluation-progress`);
}

/**
 * 获取校准进度（管理员概览 — 校准阶段用）
 */
export async function getCalibrationProgress(cycleId: string): Promise<CalibrationProgress> {
  return apiClient.get(`${BASE_URL}/cycles/${cycleId}/calibration-progress`);
}

/**
 * 获取周期结果汇总（管理员概览 — 已完成/已归档阶段用）
 */
export async function getCycleResultsSummary(cycleId: string): Promise<CycleResultsSummary> {
  return apiClient.get(`${BASE_URL}/cycles/${cycleId}/results-summary`);
}

// -------------------- 等级配置 --------------------

/**
 * 获取等级配置列表
 */
export async function getGradeConfigs(params?: QueryGradeConfigParams): Promise<GradeConfig[]> {
  const response = await apiClient.get<any, { items: GradeConfig[] }>(
    `${BASE_URL}/grade-configs`,
    { params }
  );
  return response.items;
}

/**
 * 获取等级配置详情
 */
export async function getGradeConfigById(id: string): Promise<GradeConfig> {
  return apiClient.get(`${BASE_URL}/grade-configs/${id}`);
}

/**
 * 获取默认等级配置
 */
export async function getDefaultGradeConfig(): Promise<GradeConfig> {
  return apiClient.get(`${BASE_URL}/grade-configs/default`);
}

/**
 * 创建等级配置
 */
export async function createGradeConfig(params: CreateGradeConfigParams): Promise<GradeConfig> {
  return apiClient.post(`${BASE_URL}/grade-configs`, params);
}

/**
 * 更新等级配置
 */
export async function updateGradeConfig(id: string, params: Partial<CreateGradeConfigParams>): Promise<GradeConfig> {
  return apiClient.patch(`${BASE_URL}/grade-configs/${id}`, params);
}

/**
 * 删除等级配置
 */
export async function deleteGradeConfig(id: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/grade-configs/${id}`);
}

/**
 * 设为默认等级配置
 */
export async function setDefaultGradeConfig(id: string): Promise<GradeConfig> {
  return apiClient.post(`${BASE_URL}/grade-configs/${id}/set-default`);
}

// -------------------- KPI 管理 --------------------

/**
 * 获取 KPI 分配列表
 */
export async function getKpiAssignments(params?: QueryKpiAssignmentParams): Promise<PaginatedData<KpiAssignment>> {
  return apiClient.get(`${BASE_URL}/kpi/assignments`, { params });
}

/**
 * 获取我的 KPI 分配列表
 */
export async function getMyKpiAssignments(cycleId?: string, organizationId?: string): Promise<KpiAssignment[]> {
  const res = await apiClient.get<any, { items: KpiAssignment[] }>(`${BASE_URL}/kpi/assignments/my`, { params: { cycleId, organizationId } });
  return res.items;
}

/**
 * 分解 KPI 为子期
 */
export async function decomposeKpi(assignmentId: string, periods = 4): Promise<{ parentId: string; children: KpiAssignment[] }> {
  return apiClient.post(`${BASE_URL}/kpi/assignments/${assignmentId}/decompose`, { periods });
}

/**
 * 获取团队 KPI 分配列表
 */
export async function getTeamKpiAssignments(cycleId?: string, organizationId?: string): Promise<{
  items: KpiAssignment[];
  teamSize: number;
  departments: { id: string; name: string }[];
}> {
  return apiClient.get(`${BASE_URL}/kpi/assignments/team`, { params: { cycleId, organizationId } });
}

/**
 * 分配 KPI
 */
export async function assignKpi(params: AssignKpiParams): Promise<KpiAssignment> {
  return apiClient.post(`${BASE_URL}/kpi/assignments`, params);
}

/**
 * 批量分配 KPI
 */
export async function batchAssignKpi(assignments: AssignKpiParams[]): Promise<KpiAssignment[]> {
  return apiClient.post(`${BASE_URL}/kpi/assignments/batch`, { assignments });
}

/**
 * 年度/季度目标分解
 */
export async function updateKpiAssignment(
  assignmentId: string,
  params: {
    weight?: number;
    targetValue?: number;
    baseTarget?: string;
    stretchTarget?: string;
    dependentUserId?: string | null;
    dependencyDescription?: string | null;
  },
): Promise<KpiAssignment> {
  return apiClient.put(`${BASE_URL}/kpi/assignments/${assignmentId}`, params);
}

export async function updateKpiQuarterTargets(
  assignmentId: string,
  params: { targetValue: number; quarterTargets: { Q1: number; Q2: number; Q3: number; Q4: number } }
): Promise<KpiAssignment> {
  return apiClient.post(`${BASE_URL}/kpi/assignments/${assignmentId}/quarter-targets`, params);
}

/**
 * 删除 KPI 指标
 */
export async function deleteKpiAssignment(assignmentId: string): Promise<void> {
  await apiClient.delete(`${BASE_URL}/kpi/assignments/${assignmentId}`);
}

/**
 * 获取 KPI 考核列表
 */
export async function getKpiAssessments(assignmentId: string): Promise<KpiAssessment[]> {
  return apiClient.get(`${BASE_URL}/kpi/assignments/${assignmentId}/assessments`);
}

/**
 * 自评
 */
export async function selfEvaluateKpi(assessmentId: string, params: SelfEvaluateParams): Promise<KpiAssessment> {
  return apiClient.post(`${BASE_URL}/kpi/assessments/${assessmentId}/self-evaluate`, params);
}

/**
 * 他评
 */
export async function managerEvaluateKpi(assessmentId: string, params: ManagerEvaluateParams): Promise<KpiAssessment> {
  return apiClient.post(`${BASE_URL}/kpi/assessments/${assessmentId}/manager-evaluate`, params);
}

// ==================== KPI 目标审批 ====================

/**
 * 员工提交所有 KPI 目标
 */
export async function submitAllKpi(cycleId: string): Promise<{ submitted: number }> {
  return apiClient.post(`${BASE_URL}/kpi/assignments/submit-all`, { cycleId });
}

/**
 * 主管通过 KPI 目标
 */
export async function approveKpiAssignment(assignmentId: string): Promise<{ id: string; status: KpiAssignmentStatus }> {
  return apiClient.post(`${BASE_URL}/kpi/assignments/${assignmentId}/approve`);
}

/**
 * 主管驳回 KPI 目标
 */
export async function rejectKpiAssignment(assignmentId: string, reason: string): Promise<{ id: string; status: KpiAssignmentStatus }> {
  return apiClient.post(`${BASE_URL}/kpi/assignments/${assignmentId}/reject`, { reason });
}

/**
 * 依赖人确认对齐
 */
export async function confirmKpiDependency(dependencyId: string): Promise<any> {
  return apiClient.post(`${BASE_URL}/kpi/dependencies/${dependencyId}/confirm`);
}

/**
 * 依赖人拒绝
 */
export async function rejectKpiDependency(dependencyId: string, reason: string): Promise<any> {
  return apiClient.post(`${BASE_URL}/kpi/dependencies/${dependencyId}/reject`, { reason });
}

/**
 * 获取待当前用户确认依赖的 KPI（别人依赖我的）
 */
export async function getPendingDependencyConfirmations(userId: string, organizationId?: string): Promise<KpiAssignment[]> {
  const res = await apiClient.get<{ items: KpiAssignment[] }>(`${BASE_URL}/kpi/dependencies/pending`);
  return (res as unknown as { items: KpiAssignment[] }).items || [];
}

/**
 * 确认考核
 */
export async function confirmKpiAssessment(assessmentId: string): Promise<KpiAssessment> {
  return apiClient.post(`${BASE_URL}/kpi/assessments/${assessmentId}/confirm`);
}

/**
 * 获取团队 KPI 考核
 */
export async function getTeamKpiAssessments(cycleId?: string): Promise<KpiAssessment[]> {
  return apiClient.get(`${BASE_URL}/kpi/team-assessments`, { params: { cycleId } });
}

// -------------------- 360 评估 --------------------

/**
 * 获取 360 评估列表
 */
export async function getEvaluation360s(params?: QueryEvaluation360Params): Promise<PaginatedData<Evaluation360>> {
  return apiClient.get(`${BASE_URL}/360/evaluations`, { params });
}

/**
 * 获取 360 评估详情
 */
export async function getEvaluation360ById(id: string): Promise<Evaluation360> {
  return apiClient.get(`${BASE_URL}/360/evaluations/${id}`);
}

/**
 * 获取我的 360 评估
 */
export async function getMyEvaluation360(cycleId?: string): Promise<Evaluation360 | null> {
  return apiClient.get(`${BASE_URL}/360/my-evaluation`, { params: { cycleId } });
}

/**
 * 获取我的反馈任务
 */
export async function getMyFeedbackTasks(cycleId?: string): Promise<EvaluationTask[]> {
  return apiClient.get(`${BASE_URL}/360/my-tasks`, { params: { cycleId } });
}

/**
 * 创建 360 评估
 */
export async function createEvaluation360(params: CreateEvaluation360Params): Promise<Evaluation360> {
  return apiClient.post(`${BASE_URL}/360/evaluations`, params);
}

/**
 * 更新 360 评估
 */
export async function updateEvaluation360(id: string, params: UpdateEvaluation360Params): Promise<Evaluation360> {
  return apiClient.patch(`${BASE_URL}/360/evaluations/${id}`, params);
}

/**
 * 删除 360 评估
 */
export async function deleteEvaluation360(id: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/360/evaluations/${id}`);
}

/**
 * 添加评估人
 */
export async function addEvaluators(id: string, params: AddEvaluatorsParams): Promise<Evaluation360> {
  return apiClient.post(`${BASE_URL}/360/evaluations/${id}/evaluators`, params);
}

/**
 * 添加评估人（别名）
 */
export async function addEvaluation360Evaluators(id: string, params: AddEvaluatorsParams): Promise<Evaluation360> {
  return apiClient.post(`${BASE_URL}/360/evaluations/${id}/evaluators`, params);
}

/**
 * 移除评估人
 */
export async function removeEvaluator(id: string, taskId: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/360/evaluations/${id}/evaluators/${taskId}`);
}

/**
 * 移除评估人（别名）
 */
export async function removeEvaluation360Evaluator(id: string, evaluatorId: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/360/evaluations/${id}/evaluators/${evaluatorId}`);
}

/**
 * 启动 360 评估
 */
export async function startEvaluation360(id: string): Promise<Evaluation360> {
  return apiClient.post(`${BASE_URL}/360/evaluations/${id}/start`);
}

/**
 * 完成 360 评估
 */
export async function completeEvaluation360(id: string): Promise<Evaluation360> {
  return apiClient.post(`${BASE_URL}/360/evaluations/${id}/complete`);
}

/**
 * 发布 360 结果
 */
export async function releaseEvaluation360Results(id: string): Promise<Evaluation360> {
  return apiClient.post(`${BASE_URL}/360/evaluations/${id}/release`);
}

/**
 * 提交反馈
 */
export async function submitFeedback(taskId: string, params: SubmitFeedbackParams): Promise<EvaluationTask> {
  return apiClient.post(`${BASE_URL}/360/tasks/${taskId}/submit`, params);
}

/**
 * 提交 360 评估反馈（别名）
 */
export async function submitEvaluation360Feedback(taskId: string, params: SubmitFeedbackParams): Promise<EvaluationTask> {
  return apiClient.post(`${BASE_URL}/360/tasks/${taskId}/submit`, params);
}

/**
 * 获取我的 360 评估任务
 */
export async function getMyEvaluation360Tasks(): Promise<EvaluationTask[]> {
  return apiClient.get(`${BASE_URL}/360/tasks/my`);
}

/**
 * 获取 360 评估结果
 */
export async function getEvaluation360Results(id: string): Promise<Evaluation360Result> {
  return apiClient.get(`${BASE_URL}/360/evaluations/${id}/results`);
}

/**
 * 获取 360 评估列表（别名）
 */
export async function getEvaluations360(params?: QueryEvaluation360Params): Promise<PaginatedData<Evaluation360>> {
  return apiClient.get(`${BASE_URL}/360/evaluations`, { params });
}

/**
 * 获取某员工在某周期的 360 评估摘要（用于 KPI 页面参考）
 */
export async function getEmployee360Summary(cycleId: string, employeeId: string): Promise<Evaluation360Result | null> {
  return apiClient.get(`${BASE_URL}/360/evaluations/summary`, { params: { cycleId, employeeId } });
}

/**
 * 获取某员工在某周期的 360 评估对象（用于查看评估人列表）
 */
export async function getEmployee360Evaluation(cycleId: string, employeeId: string): Promise<Evaluation360 | null> {
  return apiClient.get(`${BASE_URL}/360/evaluations/by-employee`, { params: { cycleId, employeeId } });
}

// -------------------- 绩效结果 --------------------

/**
 * 获取绩效结果列表
 */
export async function getResults(params?: QueryResultParams): Promise<ResultListResponse> {
  return apiClient.get(`${BASE_URL}/results`, { params });
}

/**
 * 获取绩效结果详情
 */
export async function getResultById(id: string): Promise<ResultListItem> {
  return apiClient.get(`${BASE_URL}/results/${id}`);
}

/**
 * 获取我的绩效结果
 */
export async function getMyResults(params?: { page?: number; pageSize?: number }): Promise<MyResultsResponse> {
  return apiClient.get(`${BASE_URL}/results/my`, { params });
}

export async function getMyResultByCycle(cycleId: string): Promise<MyResultDetail> {
  return apiClient.get(`${BASE_URL}/results/my/${cycleId}`);
}

/**
 * 计算绩效结果
 * @param weights 可选的权重配置（kpi, e360，需总和为100）
 */
export async function calculateResults(payload: CalculateResultsPayload): Promise<CalculateResultsResponse> {
  return apiClient.post(`${BASE_URL}/results/calculate`, payload);
}

/**
 * 发布绩效结果
 */
export async function publishResults(
  cycleId: string,
  payload?: PublishResultsPayload,
): Promise<PublishResultsResponse> {
  return apiClient.post(`${BASE_URL}/cycles/${cycleId}/publish-results`, payload || {});
}

/**
 * 标记已查看
 */
export async function markResultAsViewed(id: string): Promise<MarkViewedResponse> {
  return apiClient.post(`${BASE_URL}/results/my/${id}/viewed`);
}

/**
 * 确认绩效结果
 */
export async function confirmResult(id: string): Promise<{ id: string; confirmStatus: ResultConfirmStatus; confirmedAt: string }> {
  return apiClient.post(`${BASE_URL}/results/my/${id}/confirm`);
}

/**
 * 对绩效结果提出申诉
 */
export async function appealResult(id: string, reason: string): Promise<{ id: string; confirmStatus: ResultConfirmStatus; appealedAt: string }> {
  return apiClient.post(`${BASE_URL}/results/my/${id}/appeal`, { reason });
}

/**
 * HR 处理申诉
 */
export async function resolveAppeal(
  resultId: string,
  params: {
    response: string;
    action: 'MAINTAIN' | 'ADJUST';
    adjustedGrade?: string;
    adjustedScore?: number;
  },
): Promise<{ id: string; confirmStatus: ResultConfirmStatus }> {
  return apiClient.post(`${BASE_URL}/results/${resultId}/resolve-appeal`, params);
}

/**
 * 导出绩效结果
 */
export async function exportResults(payload: ExportResultsPayload): Promise<ExportResultsResponse> {
  return apiClient.post(`${BASE_URL}/results/export`, payload);
}

// ==================== 辅助函数 ====================

/**
 * 获取周期状态标签
 */
export function getCycleStatusLabel(status: CycleStatus, t?: any): string {
  const labels: Record<CycleStatus, string> = {
    [CycleStatus.DRAFT]: t?.performance?.cycle?.statuses?.DRAFT || '草稿',
    [CycleStatus.GOAL_SETTING]: t?.performance?.cycle?.statuses?.GOAL_SETTING || '目标设定中',
    [CycleStatus.IN_PROGRESS]: t?.performance?.cycle?.statuses?.IN_PROGRESS || '执行中',
    [CycleStatus.EVALUATING]: t?.performance?.cycle?.statuses?.EVALUATING || '评估中',
    [CycleStatus.CALIBRATING]: t?.performance?.cycle?.statuses?.CALIBRATING || '校准中',
    [CycleStatus.CONFIRMING]: t?.performance?.cycle?.statuses?.CONFIRMING || '结果确认中',
    [CycleStatus.COMPLETED]: t?.performance?.cycle?.statuses?.COMPLETED || '已完成',
    [CycleStatus.ARCHIVED]: t?.performance?.cycle?.statuses?.ARCHIVED || '已归档',
  };
  return labels[status] || status;
}

/**
 * 获取周期状态颜色
 */
export function getCycleStatusColor(status: CycleStatus): { bg: string; text: string; border: string } {
  const colors: Record<CycleStatus, { bg: string; text: string; border: string }> = {
    [CycleStatus.DRAFT]: { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' },
    [CycleStatus.GOAL_SETTING]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
    [CycleStatus.IN_PROGRESS]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [CycleStatus.EVALUATING]: { bg: 'bg-orange-50', text: 'text-orange-600', border: 'border-orange-200' },
    [CycleStatus.CALIBRATING]: { bg: 'bg-purple-50', text: 'text-purple-600', border: 'border-purple-200' },
    [CycleStatus.CONFIRMING]: { bg: 'bg-cyan-50', text: 'text-cyan-600', border: 'border-cyan-200' },
    [CycleStatus.COMPLETED]: { bg: 'bg-green-50', text: 'text-green-600', border: 'border-green-200' },
    [CycleStatus.ARCHIVED]: { bg: 'bg-gray-50', text: 'text-gray-500', border: 'border-gray-200' },
  };
  return colors[status] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 获取 KPI 评估状态标签
 */
export function getKpiAssessmentStatusLabel(status: KpiAssessmentStatus, t?: any): string {
  const labels: Record<KpiAssessmentStatus, string> = {
    [KpiAssessmentStatus.PENDING]: t?.performance?.kpi?.statuses?.PENDING || '待评估',
    [KpiAssessmentStatus.SELF_EVALUATED]: t?.performance?.kpi?.statuses?.SELF_EVALUATED || '已自评',
    [KpiAssessmentStatus.MANAGER_EVALUATED]: t?.performance?.kpi?.statuses?.MANAGER_EVALUATED || '已他评',
    [KpiAssessmentStatus.CONFIRMED]: t?.performance?.kpi?.statuses?.CONFIRMED || '已确认',
  };
  return labels[status] || status;
}

/**
 * 获取 KPI 评估状态颜色
 */
export function getKpiAssessmentStatusColor(status: KpiAssessmentStatus): { bg: string; text: string; border: string } {
  const colors: Record<KpiAssessmentStatus, { bg: string; text: string; border: string }> = {
    [KpiAssessmentStatus.PENDING]: { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' },
    [KpiAssessmentStatus.SELF_EVALUATED]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [KpiAssessmentStatus.MANAGER_EVALUATED]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
    [KpiAssessmentStatus.CONFIRMED]: { bg: 'bg-green-50', text: 'text-green-600', border: 'border-green-200' },
  };
  return colors[status] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 获取周期类型标签
 */
export function getCycleTypeLabel(type: CycleType, t?: any): string {
  const labels: Record<CycleType, string> = {
    [CycleType.ANNUAL]: t?.performance?.cycle?.types?.ANNUAL || '年度',
    [CycleType.SEMI_ANNUAL]: t?.performance?.cycle?.types?.SEMI_ANNUAL || '半年度',
    [CycleType.QUARTERLY]: t?.performance?.cycle?.types?.QUARTERLY || '季度',
    [CycleType.MONTHLY]: t?.performance?.cycle?.types?.MONTHLY || '月度',
    [CycleType.CUSTOM]: t?.performance?.cycle?.types?.CUSTOM || '自定义',
  };
  return labels[type] || type;
}

/**
 * 获取关系类型标签
 */
export function getRelationshipLabel(relationship: RelationshipType, t?: any): string {
  const labels: Record<RelationshipType, string> = {
    [RelationshipType.SELF]: t?.performance?.e360?.relationships?.SELF || '自评',
    [RelationshipType.SUPERVISOR]: t?.performance?.e360?.relationships?.SUPERVISOR || '上级',
    [RelationshipType.PEER]: t?.performance?.e360?.relationships?.PEER || '同事',
    [RelationshipType.SUBORDINATE]: t?.performance?.e360?.relationships?.SUBORDINATE || '下属',
    [RelationshipType.CROSS_FUNCTIONAL]: t?.performance?.e360?.relationships?.CROSS_FUNCTIONAL || '跨部门',
  };
  return labels[relationship] || relationship;
}

/**
 * 获取关系类型标签（别名）
 */
export function getRelationshipTypeLabel(relationship: RelationshipType, t?: any): string {
  return getRelationshipLabel(relationship, t);
}

/**
 * 获取 360 评估状态标签
 */
export function getEvaluation360StatusLabel(status: Evaluation360Status, t?: any): string {
  const labels: Record<Evaluation360Status, string> = {
    [Evaluation360Status.DRAFT]: t?.performance?.e360?.statuses?.DRAFT || '草稿',
    [Evaluation360Status.IN_PROGRESS]: t?.performance?.e360?.statuses?.IN_PROGRESS || '进行中',
    [Evaluation360Status.COLLECTING]: t?.performance?.e360?.statuses?.COLLECTING || '收集中',
    [Evaluation360Status.COMPLETED]: t?.performance?.e360?.statuses?.COMPLETED || '已完成',
    [Evaluation360Status.RELEASED]: t?.performance?.e360?.statuses?.RELEASED || '已发布',
    [Evaluation360Status.CANCELLED]: t?.performance?.e360?.statuses?.CANCELLED || '已取消',
  };
  return labels[status] || status;
}

/**
 * 获取 360 评估状态颜色
 */
export function getEvaluation360StatusColor(status: Evaluation360Status): { bg: string; text: string; border: string } {
  const colors: Record<Evaluation360Status, { bg: string; text: string; border: string }> = {
    [Evaluation360Status.DRAFT]: { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' },
    [Evaluation360Status.IN_PROGRESS]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
    [Evaluation360Status.COLLECTING]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [Evaluation360Status.COMPLETED]: { bg: 'bg-green-50', text: 'text-green-600', border: 'border-green-200' },
    [Evaluation360Status.RELEASED]: { bg: 'bg-purple-50', text: 'text-purple-600', border: 'border-purple-200' },
    [Evaluation360Status.CANCELLED]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
  };
  return colors[status] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 计算进度百分比
 */
export function calculateProgress(current: number, target: number): number {
  if (target === 0) return 0;
  return Math.min(Math.round((current / target) * 100), 100);
}

/**
 * 根据分数获取等级
 */
export function getGradeByScore(score: number, grades: Grade[]): Grade | undefined {
  return grades.find(g => score >= g.minScore && score <= g.maxScore);
}

// ==================== 统计分析类型 ====================

/**
 * 个人绩效概览
 */
export interface PersonalOverview {
  cycleId?: string;
  cycleName?: string;
  kpi: {
    totalIndicators: number;
    selfEvaluated: number;
    managerEvaluated: number;
    avgScore: number;
  };
  evaluation360: {
    pendingTasks: number;
    completedTasks: number;
  };
}

/**
 * 个人历史绩效趋势
 */
export interface PersonalTrendItem {
  cycleId: string;
  cycleName: string;
  cycleType: CycleType;
  startDate: string;
  endDate: string;
  totalScore: number;
  kpiScore: number | null;
  e360Score: number | null;
  grade: string;
  gradeName: string;
}

/**
 * 团队统计
 */
export interface TeamStatistics {
  cycleId?: string;
  cycleName?: string;
  teamSize: number;
  kpiScores: {
    avgScore: number;
    highest: number;
    lowest: number;
  };
  gradeDistribution: Array<{ grade: string; count: number }>;
}

/**
 * 部门报表
 */
export interface DepartmentReport {
  cycleId: string;
  cycleName: string;
  departmentId: string;
  employeeCount: number;
  kpiStats: {
    total: number;
    avgScore: number;
    highest: number;
    lowest: number;
  };
  e360Stats: {
    total: number;
    byStatus: Record<string, number>;
  };
  gradeDistribution: Array<{
    grade: string;
    gradeName: string;
    count: number;
    percentage: string;
  }>;
  scoreDistribution: Array<{ range: string; count: number }>;
}

/**
 * 公司报表
 */
export interface CompanyReport {
  cycleId: string;
  cycleName: string;
  cycleStatus: CycleStatus;
  summary: {
    totalEmployees: number;
    avgScore: number;
    avgKpiScore: number;
    avgE360Score: number;
    highestScore: number;
    lowestScore: number;
  };
  gradeDistribution: Array<{
    grade: string;
    gradeName: string;
    count: number;
    percentage: string;
  }>;
  departmentRanking: Array<{
    departmentId: string;
    departmentName: string;
    employeeCount: number;
    avgScore: number;
  }>;
  completion: {
    kpi: { total: number; evaluated: number; completionRate: string };
    e360: { total: number; completed: number; completionRate: string };
    interview: { total: number; completed: number; completionRate: string };
  };
}

/**
 * 等级分布报表
 */
export interface GradeDistributionReport {
  cycleId: string;
  cycleName: string;
  departmentId?: string;
  total: number;
  distribution: Array<{
    grade: string;
    gradeName: string;
    count: number;
    percentage: number;
  }>;
}

/**
 * 周期对比
 */
export interface CycleComparison {
  cycles: Array<{
    cycleId: string;
    cycleName: string;
    startDate: string;
    endDate: string;
    employeeCount: number;
    avgScore: number;
    avgKpiScore: number;
    avgE360Score: number;
    gradeDistribution: Record<string, number>;
  }>;
  trend: {
    scoreChange: number;
    employeeChange: number;
  };
}

// -------------------- 统计分析 API --------------------

/**
 * 获取个人绩效概览
 */
export async function getPersonalOverview(cycleId?: string): Promise<PersonalOverview> {
  return apiClient.get(`${BASE_URL}/reports/personal`, { params: { cycleId } });
}

/**
 * 获取个人历史绩效趋势
 */
export async function getPersonalTrend(limit?: number): Promise<PersonalTrendItem[]> {
  return apiClient.get(`${BASE_URL}/reports/personal/trend`, { params: { limit } });
}

/**
 * 获取团队绩效统计
 */
export async function getTeamStatistics(cycleId?: string): Promise<TeamStatistics> {
  return apiClient.get(`${BASE_URL}/reports/team`, { params: { cycleId } });
}

/**
 * 获取部门绩效报表
 */
export async function getDepartmentReport(departmentId: string, cycleId: string): Promise<DepartmentReport> {
  return apiClient.get(`${BASE_URL}/reports/department`, { params: { departmentId, cycleId } });
}

/**
 * 获取公司绩效报表
 */
export async function getCompanyReport(cycleId: string): Promise<CompanyReport> {
  return apiClient.get(`${BASE_URL}/reports/company`, { params: { cycleId } });
}

/**
 * 获取等级分布报表
 */
export async function getGradeDistributionReport(cycleId: string, departmentId?: string): Promise<GradeDistributionReport> {
  return apiClient.get(`${BASE_URL}/reports/grade-distribution`, { params: { cycleId, departmentId } });
}

/**
 * 获取周期对比数据
 */
export async function getCycleComparison(cycleIds: string[]): Promise<CycleComparison> {
  return apiClient.get(`${BASE_URL}/reports/cycle-comparison`, { params: { cycleIds: cycleIds.join(',') } });
}

// ==================== 校准概览 ====================

/**
 * 校准概览中的员工条目
 */
export interface CalibrationEmployee {
  employeeId: string;
  employee: UserBrief;
  kpiCount: number;
  selfWeightedScore: number;
  managerWeightedScore: number;
  e360Score: number | null;
  calibrationScore: number | null;
  originalGrade: string;
  calibratedGrade: string | null;
  calibrationNote: string;
  assignments: KpiAssignment[];
}

/**
 * 校准概览（按周期）
 */
export interface CalibrationOverview {
  cycleId: string;
  cycleName: string;
  totalEmployees: number;
  avgManagerScore: number;
  medianManagerScore: number;
  gradeDistribution: Array<{ grade: string; gradeName: string; count: number; percentage: number; targetPercentage?: number }>;
  employees: CalibrationEmployee[];
}

function scoreToGrade(score: number, gradeConfig: GradeConfig): string {
  for (const g of gradeConfig.grades) {
    if (score >= g.minScore && score <= g.maxScore) return g.code;
  }
  return gradeConfig.grades[gradeConfig.grades.length - 1]?.code || 'D';
}

function median(arr: number[]): number {
  if (arr.length === 0) return 0;
  const sorted = [...arr].sort((a, b) => a - b);
  const mid = Math.floor(sorted.length / 2);
  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
}

/**
 * 获取校准概览（按周期聚合所有员工的 KPI 分数）
 */
export async function getCalibrationOverview(cycleId: string): Promise<CalibrationOverview> {
  return apiClient.get(`${BASE_URL}/calibration/overview`, { params: { cycleId } });
}

/**
 * 保存校准调整（单个员工）
 */
export async function saveCalibrationAdjustment(params: {
  cycleId: string;
  employeeId: string;
  calibrationScore?: number;
  calibratedGrade?: string;
  note?: string;
}): Promise<void> {
  return apiClient.post(`${BASE_URL}/calibration/adjust`, params);
}

// ==================== 战略目标类型 ====================

/**
 * 战略目标分配
 */
export interface StrategicObjectiveAssignment {
  id: string;
  objectiveId: string;
  assigneeId: string;
  createdAt: string;
  assignee?: {
    id: string;
    displayName: string;
    username: string;
    avatar?: string;
  };
}

/**
 * 战略目标
 */
export interface StrategicObjective {
  id: string;
  cycleId: string;
  name: string;
  description?: string;
  seq: number;
  departmentId?: string;
  organizationId?: string;
  createdBy: string;
  createdAt: string;
  updatedAt: string;
  assignments: StrategicObjectiveAssignment[];
  cycle?: { id: string; name: string; status: string };
}

export interface CreateStrategicObjectiveParams {
  cycleId: string;
  name: string;
  description?: string;
  seq?: number;
  departmentId?: string;
  assigneeIds?: string[];
}

export interface UpdateStrategicObjectiveParams {
  name?: string;
  description?: string;
  seq?: number;
  departmentId?: string;
}

export interface QueryStrategicObjectiveParams {
  cycleId?: string;
  organizationId?: string;
  page?: number;
  pageSize?: number;
}

// -------------------- 战略目标 API --------------------

export async function getStrategicObjectives(
  params?: QueryStrategicObjectiveParams,
): Promise<PaginatedData<StrategicObjective>> {
  return apiClient.get(`${BASE_URL}/strategic-objectives`, { params });
}

export async function getStrategicObjectiveById(id: string): Promise<StrategicObjective> {
  return apiClient.get(`${BASE_URL}/strategic-objectives/${id}`);
}

export async function createStrategicObjective(
  params: CreateStrategicObjectiveParams,
): Promise<StrategicObjective> {
  return apiClient.post(`${BASE_URL}/strategic-objectives`, params);
}

export async function updateStrategicObjective(
  id: string,
  params: UpdateStrategicObjectiveParams,
): Promise<StrategicObjective> {
  return apiClient.put(`${BASE_URL}/strategic-objectives/${id}`, params);
}

export async function deleteStrategicObjective(id: string): Promise<void> {
  return apiClient.delete(`${BASE_URL}/strategic-objectives/${id}`);
}

export async function assignStrategicObjective(
  id: string,
  assigneeIds: string[],
): Promise<StrategicObjective> {
  return apiClient.post(`${BASE_URL}/strategic-objectives/${id}/assign`, { assigneeIds });
}

// ==================== KpiAssignment 状态辅助函数 ====================

/**
 * 获取 KPI 分配审批状态标签
 */
export function getKpiAssignmentStatusLabel(status: KpiAssignmentStatus, t?: any, _opts?: any): string {
  const labels: Record<KpiAssignmentStatus, string> = {
    [KpiAssignmentStatus.DRAFT]: t?.performance?.kpi?.assignmentStatus?.DRAFT || '草稿',
    [KpiAssignmentStatus.SUBMITTED]: t?.performance?.kpi?.assignmentStatus?.SUBMITTED || '待审批',
    [KpiAssignmentStatus.APPROVED]: t?.performance?.kpi?.assignmentStatus?.APPROVED || '已通过',
    [KpiAssignmentStatus.REJECTED]: t?.performance?.kpi?.assignmentStatus?.REJECTED || '已驳回',
    [KpiAssignmentStatus.PENDING_DEPENDENCY]: t?.performance?.kpi?.assignmentStatus?.PENDING_DEPENDENCY || '待确认',
    [KpiAssignmentStatus.CONFIRMED]: t?.performance?.kpi?.assignmentStatus?.CONFIRMED || '已确认',
  };
  return labels[status] || status;
}

/**
 * 获取 KPI 分配审批状态颜色
 */
export function getKpiAssignmentStatusColor(status: KpiAssignmentStatus, _opts?: any): { bg: string; text: string; border: string } {
  const colors: Record<KpiAssignmentStatus, { bg: string; text: string; border: string }> = {
    [KpiAssignmentStatus.DRAFT]: { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' },
    [KpiAssignmentStatus.SUBMITTED]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
    [KpiAssignmentStatus.APPROVED]: { bg: 'bg-green-50', text: 'text-green-600', border: 'border-green-200' },
    [KpiAssignmentStatus.REJECTED]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
    [KpiAssignmentStatus.PENDING_DEPENDENCY]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [KpiAssignmentStatus.CONFIRMED]: { bg: 'bg-green-50', text: 'text-green-700', border: 'border-green-300' },
  };
  return colors[status] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

// ── 整体评语 API ──

/**
 * 保存整体评语（自评 or 经理评）
 * key = cycleId + userId + role
 */
export async function saveOverallEvalComment(params: {
  cycleId: string;
  userId: string;
  role: 'self' | 'manager';
  comment: string;
}): Promise<void> {
  const payload: Record<string, string> = {
    cycleId: params.cycleId,
    employeeId: params.userId,
  };
  if (params.role === 'self') {
    payload.selfOverallComment = params.comment;
  } else {
    payload.managerOverallComment = params.comment;
  }
  await apiClient.patch(`${BASE_URL}/results/overall-comment`, payload);
}

/**
 * 获取整体评语
 */
export async function getOverallEvalComment(params: {
  cycleId: string;
  userId: string;
  role: 'self' | 'manager';
}): Promise<string> {
  const res = await apiClient.get<{ selfOverallComment?: string; managerOverallComment?: string }>(
    `${BASE_URL}/results/overall-comment`,
    { params: { cycleId: params.cycleId, employeeId: params.userId } },
  );
  const data = res as unknown as { selfOverallComment?: string; managerOverallComment?: string };
  return (params.role === 'self' ? data.selfOverallComment : data.managerOverallComment) || '';
}

// ==================== 360 评估模板 API ====================

export async function get360Templates(params?: { organizationId?: string }): Promise<Evaluation360Template[]> {
  const res = await apiClient.get<Evaluation360Template[]>('/performance/360-templates', { params });
  // apiClient 已解包 response.data.data，res 可能直接是数组
  if (Array.isArray(res)) return res;
  const data = (res as any)?.data ?? (res as any)?.items ?? res;
  return Array.isArray(data) ? data : [];
}

export async function getApplicable360Template(cycleId?: string): Promise<Evaluation360Template | null> {
  try {
    return await apiClient.get('/performance/360-templates/applicable', { params: { cycleId } });
  } catch {
    return null;
  }
}

export async function create360Template(data: {
  name: string;
  description?: string;
  dimensions: Omit<Evaluation360Dimension, 'id'>[];
  relationshipTypes: RelationshipType[];
  organizationId?: string;
  cycleId?: string;
  scope?: TemplateScope;
}): Promise<Evaluation360Template> {
  return apiClient.post('/performance/360-templates', data);
}

export async function update360Template(id: string, data: {
  name?: string;
  description?: string;
  dimensions?: Omit<Evaluation360Dimension, 'id'>[];
  relationshipTypes?: RelationshipType[];
  cycleId?: string | null;
  scope?: TemplateScope | null;
}): Promise<Evaluation360Template> {
  return apiClient.patch(`/performance/360-templates/${id}`, data);
}

export async function delete360Template(id: string): Promise<void> {
  await apiClient.delete(`/performance/360-templates/${id}`);
}

export async function setDefault360Template(id: string): Promise<void> {
  await apiClient.patch(`/performance/360-templates/${id}/set-default`);
}

// 导出错误类
export { ApiClientError };