import { http, HttpResponse, delay } from 'msw';
import {
  mockCodingRules,
  mockCodeLogs,
  mockCodeMappings,
  mockApprovals,
  mockSyncRecords,
  mockVariableDicts,
  mockSeqPools,
} from '../data';
import type {
  MockCodingRule,
  MockCodeMapping,
  MockVariableDict,
} from '../data';

const success = <T>(data: T) => HttpResponse.json({ code: 0, data, message: 'ok' });

function paginate<T>(list: T[], pageNo: number, pageSize: number) {
  const start = (pageNo - 1) * pageSize;
  return { list: list.slice(start, start + pageSize), total: list.length };
}

// ── Mutable stores ──
let codingRules = [...mockCodingRules];
let crNextId = Math.max(...codingRules.map((r) => r.id)) + 1;
let codeMappings = [...mockCodeMappings];
let cmNextId = Math.max(...codeMappings.map((r) => r.id)) + 1;
const variableDicts = [...mockVariableDicts];
let vdNextId = Math.max(...variableDicts.map((r) => r.id)) + 1;

export const codingSystemHandlers = [
  // ═══════ 编码规则 ═══════
  http.get('/admin-api/mdm/code-rule/page', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const pageNo = Number(url.searchParams.get('pageNo') || 1);
    const pageSize = Number(url.searchParams.get('pageSize') || 10);
    const ruleCode = url.searchParams.get('ruleCode') || '';
    const ruleName = url.searchParams.get('ruleName') || '';
    const scope = url.searchParams.get('scope') || '';
    const status = url.searchParams.get('status');
    const lifecycleStatus = url.searchParams.get('lifecycleStatus');

    let filtered = [...codingRules];
    if (ruleCode) filtered = filtered.filter((r) => r.ruleCode.toLowerCase().includes(ruleCode.toLowerCase()));
    if (ruleName) filtered = filtered.filter((r) => r.ruleName.includes(ruleName));
    if (scope) filtered = filtered.filter((r) => r.scope === scope);
    if (status !== null && status !== '') filtered = filtered.filter((r) => r.status === Number(status));
    if (lifecycleStatus !== null && lifecycleStatus !== '')
      filtered = filtered.filter((r) => r.lifecycleStatus === Number(lifecycleStatus));

    return success(paginate(filtered, pageNo, pageSize));
  }),

  http.get('/admin-api/mdm/code-rule/get', async ({ request }) => {
    await delay(150);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    const rule = codingRules.find((r) => r.id === id);
    if (!rule) return HttpResponse.json({ code: 1, data: null, message: '编码规则不存在' });
    return success(rule);
  }),

  http.post('/admin-api/mdm/code-rule/create', async ({ request }) => {
    await delay(200);
    const body = (await request.json()) as Record<string, unknown>;
    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
    const newRule: MockCodingRule = {
      id: crNextId++,
      ruleCode: body.ruleCode as string,
      ruleName: body.ruleName as string,
      scope: (body.scope as string) || '',
      pattern: body.pattern as string,
      prefix: (body.prefix as string) || '',
      separator: (body.separator as string) || '-',
      length: (body.length as number) || 20,
      resetCycle: (body.resetCycle as string) || '永不',
      maxSeq: (body.maxSeq as number) || 9999,
      curSeq: 0,
      status: (body.status as number) ?? 0,
      lifecycleStatus: 0, // 草稿
      description: (body.description as string) || '',
      createdBy: '当前用户',
      createTime: now,
      updateTime: now,
    };
    codingRules.push(newRule);
    return success(newRule.id);
  }),

  http.put('/admin-api/mdm/code-rule/update', async ({ request }) => {
    await delay(200);
    const body = (await request.json()) as Record<string, unknown>;
    const index = codingRules.findIndex((r) => r.id === body.id);
    if (index === -1) return HttpResponse.json({ code: 1, data: null, message: '编码规则不存在' });
    const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
    codingRules[index] = { ...codingRules[index], ...body as Partial<MockCodingRule>, updateTime: now };
    return success(true);
  }),

  http.delete('/admin-api/mdm/code-rule/delete', async ({ request }) => {
    await delay(150);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    codingRules = codingRules.filter((r) => r.id !== id);
    return success(true);
  }),

  // ═══════ 编码生成日志 ═══════
  http.get('/admin-api/mdm/code-log/page', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const pageNo = Number(url.searchParams.get('pageNo') || 1);
    const pageSize = Number(url.searchParams.get('pageSize') || 10);
    const scope = url.searchParams.get('scope') || '';
    const trigger = url.searchParams.get('trigger') || '';

    let filtered = [...mockCodeLogs];
    if (scope) filtered = filtered.filter((l) => l.scope === scope);
    if (trigger) filtered = filtered.filter((l) => l.trigger === trigger);

    return success(paginate(filtered, pageNo, pageSize));
  }),

  // ═══════ 编码对照 ═══════
  http.get('/admin-api/mdm/code-mapping/page', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const pageNo = Number(url.searchParams.get('pageNo') || 1);
    const pageSize = Number(url.searchParams.get('pageSize') || 10);
    const entityType = url.searchParams.get('entityType') || '';
    const status = url.searchParams.get('status');

    let filtered = [...codeMappings];
    if (entityType) filtered = filtered.filter((m) => m.entityType === entityType);
    if (status !== null && status !== '') filtered = filtered.filter((m) => m.status === Number(status));

    return success(paginate(filtered, pageNo, pageSize));
  }),

  http.post('/admin-api/mdm/code-mapping/create', async ({ request }) => {
    await delay(200);
    const body = (await request.json()) as Record<string, unknown>;
    const newMapping: MockCodeMapping = {
      id: cmNextId++,
      oldCode: body.oldCode as string,
      newCode: body.newCode as string,
      entityType: (body.entityType as string) || '',
      effectDate: (body.effectDate as string) || '',
      expireDate: (body.expireDate as string) || '',
      reason: (body.reason as string) || '',
      status: 0,
      transition: '进行中',
    };
    codeMappings.push(newMapping);
    return success(newMapping.id);
  }),

  http.delete('/admin-api/mdm/code-mapping/delete', async ({ request }) => {
    await delay(150);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    codeMappings = codeMappings.filter((m) => m.id !== id);
    return success(true);
  }),

  // ═══════ 审批 ═══════
  http.get('/admin-api/mdm/approval/page', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const pageNo = Number(url.searchParams.get('pageNo') || 1);
    const pageSize = Number(url.searchParams.get('pageSize') || 10);
    const tab = url.searchParams.get('tab') || 'pending';

    let filtered = [...mockApprovals];
    if (tab === 'pending') filtered = filtered.filter((a) => a.status === '待审批');
    else if (tab === 'processed') filtered = filtered.filter((a) => a.status !== '待审批');

    return success(paginate(filtered, pageNo, pageSize));
  }),

  // ═══════ 同步 ═══════
  http.get('/admin-api/mdm/sync-record/page', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const pageNo = Number(url.searchParams.get('pageNo') || 1);
    const pageSize = Number(url.searchParams.get('pageSize') || 10);
    const system = url.searchParams.get('system') || '';
    const status = url.searchParams.get('status') || '';

    let filtered = [...mockSyncRecords];
    if (system) filtered = filtered.filter((s) => s.system === system);
    if (status) filtered = filtered.filter((s) => s.status === status);

    return success(paginate(filtered, pageNo, pageSize));
  }),

  http.post('/admin-api/mdm/sync-record/retry', async () => {
    await delay(300);
    return success(true);
  }),

  // ═══════ 变量字典 ═══════
  http.get('/admin-api/mdm/variable-dict/page', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const pageNo = Number(url.searchParams.get('pageNo') || 1);
    const pageSize = Number(url.searchParams.get('pageSize') || 10);
    const scope = url.searchParams.get('scope') || '';

    let filtered = [...variableDicts];
    if (scope) filtered = filtered.filter((v) => v.scope.includes(scope));

    return success(paginate(filtered, pageNo, pageSize));
  }),

  http.get('/admin-api/mdm/variable-dict/get', async ({ request }) => {
    await delay(150);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    const item = variableDicts.find((v) => v.id === id);
    if (!item) return HttpResponse.json({ code: 1, data: null, message: '变量不存在' });
    return success(item);
  }),

  http.post('/admin-api/mdm/variable-dict/save', async ({ request }) => {
    await delay(200);
    const body = (await request.json()) as Record<string, unknown>;
    if (body.id) {
      const index = variableDicts.findIndex((v) => v.id === body.id);
      if (index !== -1) variableDicts[index] = { ...variableDicts[index], ...body as Partial<MockVariableDict> };
    } else {
      const newVar: MockVariableDict = {
        id: vdNextId++,
        key: body.key as string,
        name: body.name as string,
        desc: (body.desc as string) || '',
        scope: (body.scope as string) || '通用',
        example: (body.example as string) || '',
        status: 0,
      };
      variableDicts.push(newVar);
    }
    return success(true);
  }),

  // ═══════ 序列池 ═══════
  http.get('/admin-api/mdm/seq-pool/list', async ({ request }) => {
    await delay(150);
    const url = new URL(request.url);
    const ruleCode = url.searchParams.get('ruleCode') || '';
    const filtered = mockSeqPools.filter((p) => p.ruleCode === ruleCode);
    return success(filtered);
  }),
];