prop-ai-hr/frontend/src/api/aihr/practice.ts

import request from '@/utils/request';

type ApiResult<T> = {
  code: number;
  msg: string;
  data: T;
};

export type PracticeStartRequest = {
  extPartyId: string;
  scenarioId: string;
  mode: string;
};

export type PracticeScenarioResponse = {
  id: string;
  name: string;
  position: string;
  scenarioType: string;
  projectType: string;
  growthLevel: string;
  competencyCode: string;
  collaborationPositions: string;
  reviewStatus: string;
  riskLevel: '待评估' | '常规' | '高风险';
  requiresDualReview: boolean;
  curriculumVersion: string;
  reviewer?: string;
  reviewedTime?: string;
  secondReviewer?: string;
  secondReviewedTime?: string;
  difficulty: number;
  customerPersona: string;
  openingText: string;
  explicitNeed: string;
  hiddenNeed: string;
  irritants: string;
  delights: string;
  sopRefs: string;
  successCriteria: string;
  strategy: string;
  goal: string;
  enabled: boolean;
  rounds: PracticeScenarioRound[];
  contentVersion: string;
  contentHash: string;
  rubric?: {
    code: string;
    name: string;
    version: string;
    dimensions: Array<{ code: string; name: string; weight: number; description: string }>;
  };
};

export type PracticeScenarioRound = {
  customer: string;
  coachHint: string;
  emotion: number;
  trust: number;
};

export type PracticeScenarioEnabledRequest = {
  enabled: boolean;
};

export type PracticeScenarioSaveRequest = {
  id?: string;
  name: string;
  position: string;
  scenarioType: string;
  projectType: string;
  growthLevel: string;
  competencyCode: string;
  collaborationPositions: string;
  riskLevel: '待评估' | '常规' | '高风险';
  curriculumVersion: string;
  difficulty: number;
  customerPersona: string;
  openingText: string;
  explicitNeed: string;
  hiddenNeed: string;
  irritants: string;
  delights: string;
  sopRefs: string;
  successCriteria: string;
  strategy: string;
  goal: string;
  enabled: boolean;
  rounds: PracticeScenarioRound[];
  expectedContentVersion?: string;
  expectedContentHash?: string;
};

export type PracticeScenarioReviewStatusRequest = {
  reviewStatus: '草稿' | '待业务审核' | '已发布' | '已下线';
};

export type PracticeScenarioReviewStatusResponse = {
  reviewStatus: '草稿' | '待业务审核' | '已发布' | '已下线';
  awaitingSecondReview: boolean;
  message: string;
};

export type PracticeCurriculumCapability = {
  position: string;
  growthLevel: string;
  code: string;
  name: string;
};

export type PracticeCurriculumMatrixRow = {
  position: string;
  growthLevel: string;
  competencyCode: string;
  competencyName: string;
  publishedCount: number;
  pendingReviewCount: number;
  draftCount: number;
  offlineCount: number;
  coverageStatus: string;
};

export type PracticeRubricDimension = {
  code: string;
  name: string;
  weight: number;
  description: string;
};

export type PracticeRubricAdmin = {
  code: string;
  scenarioCode: string;
  scenarioName: string;
  name: string;
  version: string;
  enabled: boolean;
  description: string;
  dimensions: PracticeRubricDimension[];
};

export type PracticeRubricSaveRequest = Omit<PracticeRubricAdmin, 'scenarioName'>;

export type PracticeQuestion = {
  code: string;
  scenarioCode: string;
  scenarioName: string;
  positionCode: string;
  type: 'daily' | 'special';
  question: string;
  referenceAnswer: string;
  contentVersion: string;
  contentHash: string;
  enabled: boolean;
  sortOrder: number;
  examFormat?: 'single' | 'multiple' | 'judge' | 'short' | '';
  examOptions?: string[];
  examAnswers?: string[];
  examExplanation?: string;
  examEnabled?: boolean;
  reviewStatus?: 'DRAFT' | 'APPROVED' | 'REJECTED';
  reviewedBy?: string;
  reviewedTime?: string;
};

export type PracticeQuestionSaveRequest = Pick<
  PracticeQuestion,
  | 'code'
  | 'scenarioCode'
  | 'positionCode'
  | 'type'
  | 'question'
  | 'referenceAnswer'
  | 'enabled'
  | 'sortOrder'
  | 'examFormat'
  | 'examOptions'
  | 'examAnswers'
  | 'examExplanation'
  | 'examEnabled'
>;

export type ManagedPracticeAssignment = {
  id: number;
  extPartyId: string;
  traineeName: string;
  scenarioId: string;
  scenarioName: string;
  source: string;
  reason: string;
  status: string;
  createTime: string;
  dueDate?: string;
  contentVersion?: string;
  contentHash?: string;
  question?: string;
  referenceAnswer?: string;
};

export type ManagedPracticeAssignmentBatchRequest = {
  requestId: string;
  targets: Array<{ extPartyId: string; traineeName?: string }>;
  scenarioId: string;
  reason: string;
  dueDate: string;
};

export type ManagedPracticeAssignmentBatchResponse = {
  requestId: string;
  total: number;
  created: number;
  duplicate: number;
  failed: number;
  results: Array<{ extPartyId: string; traineeName: string; status: string; message: string }>;
};

export type ManagedLearningTask = {
  id: number;
  extPartyId: string;
  traineeName: string;
  projectCode: string;
  positionCode: string;
  taskType: string;
  status: string;
  materialType: 'DOCUMENT' | 'VIDEO' | 'COURSE' | 'SOP';
  materialAttachmentId: number;
  materialTitle: string;
  materialVersion: string;
  progressPercent: number;
  completionRule: 'MANUAL_CONFIRM' | 'EXAM_PASS';
  examId?: number | null;
  examTitle?: string | null;
  recurrenceType: 'ONCE' | 'DAILY' | 'WEEKLY' | 'MONTHLY';
  assignedTime: string;
  dueTime: string;
  completedTime?: string;
  assignBy: string;
};

export type LearningMaterialOption = {
  attachmentId: number;
  title: string;
  fileType: string;
  materialVersion: string;
  updatedTime: string;
};

export type LearningExamOption = {
  examId: number;
  title: string;
  projectCode: string;
  positionCode: string;
  dueDate: string;
  targetCount: number;
};

export type ManagedLearningTaskBatchRequest = {
  requestId: string;
  targets: Array<{ extPartyId: string; traineeName?: string }>;
  projectCode: string;
  positionCode: string;
  taskType: string;
  materialType: ManagedLearningTask['materialType'];
  materialAttachmentId: number;
  completionRule: ManagedLearningTask['completionRule'];
  examId?: number | null;
  recurrenceType: ManagedLearningTask['recurrenceType'];
  startTime: string;
  dueTime: string;
};

export type ManagedLearningTaskBatchResponse = {
  requestId: string;
  total: number;
  created: number;
  duplicate: number;
  failed: number;
  items: Array<{ extPartyId: string; traineeName: string; status: string; message: string }>;
};

export type PracticePrepCardResponse = {
  keyPoints: string[];
  redLines: string[];
  scripts: string[];
  promptVersion: string;
};

export type PracticeStartResponse = {
  sessionId: string;
  scenarioId: string;
  scenarioName: string;
  trainee: string;
  customerText: string;
  emotion: number;
  trust: number;
  customerAudioUrl: string;
  persona: {
    customer: string;
    project: string;
    strategy: string;
    goal: string;
  };
};

export type PracticeTurnRequest = {
  sessionId: string;
  roundIndex: number;
  traineeText: string;
  traineeAudioUrl?: string;
  traineeAudioOssId?: number;
};

export type PracticeTurnResponse = {
  customerText: string;
  customerAudioUrl: string;
  emotion: number;
  trust: number;
  coachHint: string;
  redFlag: boolean;
  roundIndex: number;
  finished: boolean;
};

export type PracticeFinishRequest = {
  sessionId: string;
};

export type PracticeFinishResponse = {
  totalScore: number;
  score: Array<{
    label: string;
    value: number | string;
    note: string;
  }>;
  mentorRewrite: string;
  aiComment: string;
  trustCurve: number[];
  records: Array<{
    time: string;
    trainee: string;
    scene: string;
    score: number;
    status: string;
    summary: string;
  }>;
};

export type PracticeCalibrationRequest = {
  reviewer?: string;
  correctedTotal: number;
  correctedCompliance?: number;
  correctedEmotion?: number;
  correctedCommunication?: number;
  correctedMarketing?: number;
  correctedTaskCompletion?: number;
  correctedResponseTimeliness?: number;
  reason?: string;
};

export type PracticeCalibrationResponse = {
  id: number;
  sessionId: string;
  originalScore: number;
  correctedScore: number;
  reviewer: string;
  reason: string;
  status: string;
  createTime: string;
};

export type PromptTemplateResponse = {
  id: number;
  code: string;
  name: string;
  category: string;
  outputFormat: string;
  systemPrompt: string;
  template: string;
  variables: string;
  version: string;
  enabled: boolean;
  description: string;
  updateTime: string;
};

export type PromptTemplateRequest = {
  code: string;
  name: string;
  category: string;
  outputFormat: string;
  systemPrompt: string;
  template: string;
  variables: string;
  version: string;
  enabled: boolean;
  description: string;
};

export function listPracticeScenarios(params?: { position?: string; scenarioType?: string; includeDisabled?: boolean }): Promise<ApiResult<PracticeScenarioResponse[]>> {
  return request({
    url: '/api/train/practice/scenarios',
    method: 'get',
    params
  });
}

export function listPracticeQuestions(params?: { position?: string; type?: 'daily' | 'special'; includeDisabled?: boolean }): Promise<ApiResult<PracticeQuestion[]>> {
  return request({ url: '/api/train/practice/questions', method: 'get', params });
}

export function savePracticeQuestion(data: PracticeQuestionSaveRequest): Promise<ApiResult<PracticeQuestion>> {
  return request({ url: '/api/train/practice/questions', method: 'post', data });
}

export function updatePracticeQuestionEnabled(code: string, enabled: boolean): Promise<ApiResult<null>> {
  return request({ url: `/api/train/practice/questions/${encodeURIComponent(code)}/enabled`, method: 'patch', data: { enabled } });
}

export function reviewPracticeQuestion(code: string, decision: 'APPROVE' | 'REJECT', note = ''): Promise<ApiResult<PracticeQuestion>> {
  return request({
    url: `/api/train/practice/questions/${encodeURIComponent(code)}/review`,
    method: 'patch',
    data: { decision, note }
  });
}

export function listManagedLearningTasks(params?: { status?: string; keyword?: string; limit?: number }): Promise<ApiResult<ManagedLearningTask[]>> {
  return request({ url: '/api/train/practice/onboard-tasks/manage', method: 'get', params });
}

export function listLearningMaterials(): Promise<ApiResult<LearningMaterialOption[]>> {
  return request({ url: '/api/train/practice/onboard-tasks/manage/materials', method: 'get' });
}

export function listLearningExams(): Promise<ApiResult<LearningExamOption[]>> {
  return request({ url: '/api/train/practice/onboard-tasks/manage/exams', method: 'get' });
}

export function createManagedLearningTasks(data: ManagedLearningTaskBatchRequest): Promise<ApiResult<ManagedLearningTaskBatchResponse>> {
  return request({ url: '/api/train/practice/onboard-tasks/manage/batch', method: 'post', data, headers: { repeatSubmit: false } });
}

export function updatePracticeScenarioEnabled(id: string, data: PracticeScenarioEnabledRequest): Promise<ApiResult<null>> {
  return request({
    url: `/api/train/practice/scenarios/${id}/enabled`,
    method: 'patch',
    data
  });
}

export function updatePracticeScenarioReviewStatus(
  id: string,
  data: PracticeScenarioReviewStatusRequest
): Promise<ApiResult<PracticeScenarioReviewStatusResponse>> {
  return request({
    url: `/api/train/practice/scenarios/${encodeURIComponent(id)}/review-status`,
    method: 'patch',
    data
  });
}

export function listPracticeCurriculumCapabilities(params?: {
  position?: string;
  growthLevel?: string;
}): Promise<ApiResult<PracticeCurriculumCapability[]>> {
  return request({ url: '/api/train/practice/curriculum/capabilities', method: 'get', params });
}

export function listPracticeCurriculumMatrix(params?: {
  position?: string;
}): Promise<ApiResult<PracticeCurriculumMatrixRow[]>> {
  return request({ url: '/api/train/practice/curriculum/matrix', method: 'get', params });
}

export function savePracticeScenario(data: PracticeScenarioSaveRequest): Promise<ApiResult<PracticeScenarioResponse>> {
  return request({
    url: '/api/train/practice/scenarios',
    method: 'post',
    data
  });
}

export function listPracticeRubrics(): Promise<ApiResult<PracticeRubricAdmin[]>> {
  return request({ url: '/api/train/practice/rubrics/manage', method: 'get' });
}

export function savePracticeRubric(data: PracticeRubricSaveRequest): Promise<ApiResult<PracticeRubricAdmin>> {
  return request({ url: '/api/train/practice/rubrics/manage', method: 'post', data });
}

export function updatePracticeRubricEnabled(code: string, enabled: boolean): Promise<ApiResult<null>> {
  return request({
    url: `/api/train/practice/rubrics/${encodeURIComponent(code)}/enabled`,
    method: 'patch',
    data: { enabled }
  });
}

export function listManagedPracticeAssignments(params?: { position?: string; status?: string; source?: string; keyword?: string; limit?: number }): Promise<ApiResult<ManagedPracticeAssignment[]>> {
  return request({ url: '/api/train/practice/assignments/manage', method: 'get', params });
}

export function createManagedPracticeAssignments(data: ManagedPracticeAssignmentBatchRequest): Promise<ApiResult<ManagedPracticeAssignmentBatchResponse>> {
  return request({ url: '/api/train/practice/assignments/manage/batch', method: 'post', data, headers: { repeatSubmit: false } });
}

export function cancelManagedPracticeAssignment(id: number, reason?: string): Promise<ApiResult<null>> {
  return request({ url: `/api/train/practice/assignments/manage/${id}/cancel`, method: 'patch', data: { reason }, headers: { repeatSubmit: false } });
}

export function getPracticePrepCard(id: string): Promise<ApiResult<PracticePrepCardResponse>> {
  return request({
    url: `/api/train/practice/scenarios/${id}/prep-card`,
    method: 'get'
  });
}

export function startPracticeSession(data: PracticeStartRequest): Promise<ApiResult<PracticeStartResponse>> {
  return request({
    url: '/api/train/practice/start',
    method: 'post',
    data,
    headers: { repeatSubmit: false }
  });
}

export function submitPracticeTurn(data: PracticeTurnRequest): Promise<ApiResult<PracticeTurnResponse>> {
  return request({
    url: '/api/train/practice/turn',
    method: 'post',
    data,
    headers: { repeatSubmit: false }
  });
}

export function finishPracticeSession(data: PracticeFinishRequest): Promise<ApiResult<PracticeFinishResponse>> {
  return request({
    url: '/api/train/practice/finish',
    method: 'post',
    data,
    headers: { repeatSubmit: false }
  });
}

export function calibratePracticeSession(sessionId: string, data: PracticeCalibrationRequest): Promise<ApiResult<PracticeCalibrationResponse>> {
  return request({
    url: `/api/train/practice/sessions/${sessionId}/calibration`,
    method: 'post',
    data,
    headers: { repeatSubmit: false }
  });
}

export function exportPracticePilotCsv(params: { startDate: string; endDate: string }): Promise<Blob> {
  return request({
    url: '/api/train/practice/export',
    method: 'get',
    params,
    responseType: 'blob'
  }) as unknown as Promise<Blob>;
}

export function listPromptTemplates(params?: { category?: string; code?: string; enabled?: boolean }): Promise<ApiResult<PromptTemplateResponse[]>> {
  return request({
    url: '/api/aihr/prompt-templates',
    method: 'get',
    params
  });
}

export function createPromptTemplate(data: PromptTemplateRequest): Promise<ApiResult<PromptTemplateResponse>> {
  return request({
    url: '/api/aihr/prompt-templates',
    method: 'post',
    data
  });
}

export function updatePromptTemplate(id: number, data: PromptTemplateRequest): Promise<ApiResult<PromptTemplateResponse>> {
  return request({
    url: `/api/aihr/prompt-templates/${id}`,
    method: 'put',
    data
  });
}