import type { CourseItem, CoursePageQuery, PaperOption } from './types';

function delay<T>(data: T, ms = 180): Promise<T> {
  return new Promise((resolve) => setTimeout(() => resolve(data), ms));
}

const papers: PaperOption[] = [
  { id: 'p4', fullName: '2026-药物警戒年度培训试题' },
  { id: 'p5', fullName: 'GMP基础知识培训（QC、分析）' },
  { id: 'p6', fullName: '再确认测试' },
  { id: 'p7', fullName: 'SOP-偏差与变更综合考核' },
  { id: 'p8', fullName: '安全生产月专项考试' },
];

const store: CourseItem[] = [
  {
    id: 'course_001',
    courseNo: 'KC2026030001',
    courseName: 'GMP基础知识培训',
    category: 'gmp',
    trainMode: 'onsite',
    evalMode: 'exam',
    paperId: 'p5',
    paperName: 'GMP基础知识培训（QC、分析）',
    hours: 4,
    enabled: '1',
    remark: '新人入职必修',
  },
  {
    id: 'course_002',
    courseNo: 'KC2026030002',
    courseName: '偏差与变更管理 SOP',
    category: 'sop',
    trainMode: 'onsite',
    evalMode: 'quiz',
    paperId: undefined,
    paperName: undefined,
    hours: 2,
    enabled: '1',
    remark: '',
  },
  {
    id: 'course_003',
    courseNo: 'KC2026030003',
    courseName: '设备操作实操培训',
    category: 'skill',
    trainMode: 'practice',
    evalMode: 'practice',
    hours: 8,
    enabled: '1',
    remark: '需现场实操评分',
  },
  {
    id: 'course_004',
    courseNo: 'KC2026030004',
    courseName: '药物警戒年度培训',
    category: 'gmp',
    trainMode: 'online',
    evalMode: 'exam',
    paperId: 'p4',
    paperName: '2026-药物警戒年度培训试题',
    hours: 3,
    enabled: '1',
    remark: '',
  },
  {
    id: 'course_005',
    courseNo: 'KC2026030005',
    courseName: '安全生产月宣贯',
    category: 'safety',
    trainMode: 'onsite',
    evalMode: 'none',
    hours: 1.5,
    enabled: '1',
    remark: '无需考核',
  },
  {
    id: 'course_006',
    courseNo: 'KC2026020001',
    courseName: '旧版文件培训（停用）',
    category: 'other',
    trainMode: 'online',
    evalMode: 'exam',
    paperId: 'p6',
    paperName: '再确认测试',
    hours: 2,
    enabled: '0',
    remark: '已停用，历史引用保留',
  },
];

function nextCourseNo() {
  const now = new Date();
  const ym = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}`;
  const prefix = `KC${ym}`;
  const seqs = store
    .filter((x) => x.courseNo.startsWith(prefix))
    .map((x) => Number(x.courseNo.slice(prefix.length)) || 0);
  const next = (seqs.length ? Math.max(...seqs) : 0) + 1;
  return `${prefix}${String(next).padStart(4, '0')}`;
}

function resolvePaperName(paperId?: string) {
  if (!paperId) return undefined;
  return papers.find((p) => p.id === paperId)?.fullName;
}

export function mockPaperOptions() {
  return delay([...papers]);
}

export function mockQueryCourses(params: CoursePageQuery = {}) {
  const {
    currentPage = 1,
    pageSize = 20,
    keyword = '',
    category,
    trainMode,
    evalMode,
    enabled,
  } = params;
  let list = [...store];
  if (category) list = list.filter((x) => x.category === category);
  if (trainMode) list = list.filter((x) => x.trainMode === trainMode);
  if (evalMode) list = list.filter((x) => x.evalMode === evalMode);
  if (enabled) list = list.filter((x) => x.enabled === enabled);
  if (keyword) {
    const k = keyword.trim().toLowerCase();
    list = list.filter(
      (x) =>
        x.courseNo.toLowerCase().includes(k) ||
        x.courseName.toLowerCase().includes(k) ||
        (x.paperName || '').toLowerCase().includes(k),
    );
  }
  list.sort((a, b) => b.courseNo.localeCompare(a.courseNo));
  const start = (currentPage - 1) * pageSize;
  return delay({
    list: list.slice(start, start + pageSize),
    pagination: { total: list.length, currentPage, pageSize },
  });
}

export async function mockGetCourse(id: string) {
  await delay(null);
  const row = store.find((x) => x.id === id);
  if (!row) throw new Error('培训课程不存在');
  return { ...row };
}

export async function mockSaveCourse(data: Partial<CourseItem> & { id?: string }) {
  await delay(null);
  if (data.evalMode === 'exam' && !data.paperId) {
    throw new Error('在线考试须关联考核试卷');
  }
  const paperName = resolvePaperName(data.paperId);
  if (data.id) {
    const row = store.find((x) => x.id === data.id);
    if (!row) throw new Error('培训课程不存在');
    Object.assign(row, {
      ...data,
      paperName: data.paperId ? paperName : undefined,
    });
    if (!data.paperId) {
      row.paperId = undefined;
      row.paperName = undefined;
    }
    return row;
  }
  if (!data.courseName?.trim()) throw new Error('请填写课程名称');
  const row: CourseItem = {
    id: `course_${Date.now()}`,
    courseNo: nextCourseNo(),
    courseName: data.courseName.trim(),
    category: data.category,
    trainMode: data.trainMode,
    evalMode: data.evalMode,
    paperId: data.paperId,
    paperName: data.paperId ? paperName : undefined,
    hours: data.hours ?? null,
    enabled: (data.enabled as any) || '1',
    remark: data.remark || '',
  };
  store.unshift(row);
  return row;
}

export async function mockSetCourseEnabled(id: string, enabled: '0' | '1') {
  await delay(null);
  const row = store.find((x) => x.id === id);
  if (!row) throw new Error('培训课程不存在');
  row.enabled = enabled;
  return row;
}

export async function mockDeleteCourse(id: string) {
  await delay(null);
  const idx = store.findIndex((x) => x.id === id);
  if (idx < 0) throw new Error('培训课程不存在');
  store.splice(idx, 1);
  return true;
}