import { http, HttpResponse, delay } from 'msw';
import { mockCodeRules } from '../data';
import type { MockCodeRule } from '../data';

// Mutable in-memory store
let codeRules = [...mockCodeRules];
let nextId = Math.max(...codeRules.map((r) => r.id)) + 1;

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

export const codeRuleHandlers = [
  // Page query
  http.get('/admin-api/mdm/code-rule/page', async ({ request }) => {
    await delay(300);
    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 status = url.searchParams.get('status');

    let filtered = [...codeRules];

    if (ruleCode) {
      filtered = filtered.filter((r) => r.ruleCode.includes(ruleCode));
    }
    if (ruleName) {
      filtered = filtered.filter((r) => r.ruleName.includes(ruleName));
    }
    if (status !== null && status !== '') {
      filtered = filtered.filter((r) => r.status === Number(status));
    }

    return HttpResponse.json({
      code: 0,
      data: paginate(filtered, pageNo, pageSize),
      message: 'ok',
    });
  }),

  // Get by ID
  http.get('/admin-api/mdm/code-rule/get', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    const rule = codeRules.find((r) => r.id === id);

    if (!rule) {
      return HttpResponse.json(
        { code: 1, data: null, message: '编码规则不存在' },
      );
    }

    return HttpResponse.json({
      code: 0,
      data: rule,
      message: 'ok',
    });
  }),

  // Create
  http.post('/admin-api/mdm/code-rule/create', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as Record<string, unknown>;

    const codeExists = codeRules.find((r) => r.ruleCode === body.ruleCode);
    if (codeExists) {
      return HttpResponse.json(
        { code: 1, data: null, message: '编码规则标识已存在' },
      );
    }

    const newRule: MockCodeRule = {
      id: nextId++,
      ruleCode: body.ruleCode as string,
      ruleName: body.ruleName as string,
      scope: (body.scope as string) || '',
      formatPattern: body.formatPattern as string,
      description: (body.description as string) || '',
      status: (body.status as number) ?? 0,
      lifecycleStatus: (body.lifecycleStatus as number) ?? 0,
      revision: (body.revision as number) ?? 1,
      createTime: new Date().toISOString().replace('T', ' ').slice(0, 19),
    };

    codeRules.push(newRule);
    return HttpResponse.json({ code: 0, data: newRule.id, message: 'ok' });
  }),

  // Update
  http.put('/admin-api/mdm/code-rule/update', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as Record<string, unknown>;
    const index = codeRules.findIndex((r) => r.id === body.id);

    if (index === -1) {
      return HttpResponse.json(
        { code: 1, data: null, message: '编码规则不存在' },
      );
    }

    // Check code uniqueness (excluding self)
    if (body.ruleCode) {
      const dup = codeRules.find((r) => r.ruleCode === body.ruleCode && r.id !== body.id);
      if (dup) {
        return HttpResponse.json(
          { code: 1, data: null, message: '编码规则标识已存在' },
        );
      }
    }

    codeRules[index] = {
      ...codeRules[index],
      ...(body.ruleCode !== undefined && { ruleCode: body.ruleCode as string }),
      ...(body.ruleName !== undefined && { ruleName: body.ruleName as string }),
      ...(body.scope !== undefined && { scope: body.scope as string }),
      ...(body.formatPattern !== undefined && { formatPattern: body.formatPattern as string }),
      ...(body.description !== undefined && { description: body.description as string }),
      ...(body.status !== undefined && { status: body.status as number }),
      ...(body.lifecycleStatus !== undefined && { lifecycleStatus: body.lifecycleStatus as number }),
      ...(body.revision !== undefined && { revision: body.revision as number }),
    };

    return HttpResponse.json({ code: 0, data: true, message: 'ok' });
  }),

  // Delete
  http.delete('/admin-api/mdm/code-rule/delete', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    codeRules = codeRules.filter((r) => r.id !== id);
    return HttpResponse.json({ code: 0, data: true, message: 'ok' });
  }),
];