import { http, HttpResponse, delay } from 'msw';
import { mockSystemRoles } from '../data';
import type { MockSystemRole } from '../data';

// Mutable in-memory store
let roles = [...mockSystemRoles];
let nextId = Math.max(...roles.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 roleHandlers = [
  // Page query
  http.get('/admin-api/system/role/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 name = url.searchParams.get('name') || '';
    const code = url.searchParams.get('code') || '';
    const status = url.searchParams.get('status');
    const createTimeStart = url.searchParams.get('createTime[0]') || url.searchParams.get('createTimeStart') || '';
    const createTimeEnd = url.searchParams.get('createTime[1]') || url.searchParams.get('createTimeEnd') || '';

    let filtered = [...roles];

    if (name) {
      filtered = filtered.filter((r) => r.name.includes(name));
    }
    if (code) {
      filtered = filtered.filter((r) => r.code.includes(code));
    }
    if (status !== null && status !== '') {
      filtered = filtered.filter((r) => r.status === Number(status));
    }
    if (createTimeStart) {
      filtered = filtered.filter((r) => r.createTime >= createTimeStart);
    }
    if (createTimeEnd) {
      filtered = filtered.filter((r) => r.createTime <= createTimeEnd);
    }

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

  // Simple list (all roles, no pagination)
  http.get('/admin-api/system/role/simple-list', async () => {
    await delay(200);
    const simpleRoles = roles.map((r) => ({
      id: r.id,
      name: r.name,
      code: r.code,
    }));
    return HttpResponse.json({
      code: 0,
      data: simpleRoles,
      message: 'ok',
    });
  }),

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

    if (!role) {
      return HttpResponse.json(
        { code: 1, data: null, message: '角色不存在' },
      );
    }

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

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

    const codeExists = roles.find((r) => r.code === body.code);
    if (codeExists) {
      return HttpResponse.json(
        { code: 1, data: null, message: '角色标识已存在' },
      );
    }

    const newRole: MockSystemRole = {
      id: nextId++,
      name: body.name as string,
      code: body.code as string,
      sort: (body.sort as number) ?? 0,
      status: (body.status as number) ?? 0,
      type: (body.type as number) ?? 2,
      dataScope: (body.dataScope as number) ?? 1,
      dataScopeDeptIds: (body.dataScopeDeptIds as number[]) || [],
      createTime: new Date().toISOString().replace('T', ' ').slice(0, 19),
    };

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

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

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

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

    roles[index] = {
      ...roles[index],
      ...(body.name !== undefined && { name: body.name as string }),
      ...(body.code !== undefined && { code: body.code as string }),
      ...(body.sort !== undefined && { sort: body.sort as number }),
      ...(body.status !== undefined && { status: body.status as number }),
      ...(body.type !== undefined && { type: body.type as number }),
      ...(body.dataScope !== undefined && { dataScope: body.dataScope as number }),
      ...(body.dataScopeDeptIds !== undefined && { dataScopeDeptIds: body.dataScopeDeptIds as number[] }),
    };

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

  // Delete single
  http.delete('/admin-api/system/role/delete', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));

    if (id === 1) {
      return HttpResponse.json(
        { code: 1, data: null, message: '不能删除超级管理员角色' },
      );
    }

    roles = roles.filter((r) => r.id !== id);
    return HttpResponse.json({ code: 0, data: true, message: 'ok' });
  }),

  // Delete list (batch)
  http.delete('/admin-api/system/role/delete-list', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as number[];

    if (body.includes(1)) {
      return HttpResponse.json(
        { code: 1, data: null, message: '不能删除超级管理员角色' },
      );
    }

    roles = roles.filter((r) => !body.includes(r.id));
    return HttpResponse.json({ code: 0, data: true, message: 'ok' });
  }),
];