import { http, HttpResponse, delay } from 'msw';
import { mockOrders, type MockOrder } from '../data/aps';

// Mutable in-memory store
let orders = [...mockOrders];
let nextId = Math.max(...orders.map((o) => o.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 apsOrderHandlers = [
  // Page query
  http.get('/admin-api/aps/order/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 orderId = url.searchParams.get('orderId') || '';
    const customerName = url.searchParams.get('customerName') || '';
    const status = url.searchParams.get('status');
    const priority = url.searchParams.get('priority');

    let filtered = [...orders];

    if (orderId) {
      filtered = filtered.filter((o) => o.orderId.includes(orderId));
    }
    if (customerName) {
      filtered = filtered.filter((o) => o.customerName.includes(customerName));
    }
    if (status !== null && status !== '') {
      filtered = filtered.filter((o) => o.status === Number(status));
    }
    if (priority !== null && priority !== '') {
      filtered = filtered.filter((o) => o.priority === Number(priority));
    }

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

  // Get by ID
  http.get('/admin-api/aps/order/get', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    const order = orders.find((o) => o.id === id);
    if (!order) {
      return HttpResponse.json({ code: 1, data: null, msg: '订单不存在' });
    }
    return HttpResponse.json({ code: 0, data: order, msg: '' });
  }),

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

    const exists = orders.find((o) => o.orderId === body.orderId);
    if (exists) {
      return HttpResponse.json({ code: 1, data: null, msg: '订单编号已存在' });
    }

    const newOrder: MockOrder = {
      id: nextId++,
      orderId: body.orderId as string,
      customerName: body.customerName as string,
      alloy: body.alloy as string,
      temper: body.temper as string,
      thickness: body.thickness as number,
      width: body.width as number,
      innerDiameter: body.innerDiameter as number,
      minOuterDiameter: body.minOuterDiameter as number,
      maxOuterDiameter: body.maxOuterDiameter as number,
      demand: body.demand as number,
      deliveryDate: body.deliveryDate as string,
      priority: (body.priority as number) ?? 3,
      status: (body.status as number) ?? 0,
      assigned: 0,
      createTime: new Date().toISOString().replace('T', ' ').slice(0, 19),
    };

    orders.unshift(newOrder);
    return HttpResponse.json({ code: 0, data: newOrder.id, msg: '' });
  }),

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

    if (index === -1) {
      return HttpResponse.json({ code: 1, data: null, msg: '订单不存在' });
    }

    if (body.orderId) {
      const dup = orders.find((o) => o.orderId === body.orderId && o.id !== body.id);
      if (dup) {
        return HttpResponse.json({ code: 1, data: null, msg: '订单编号已存在' });
      }
    }

    orders[index] = {
      ...orders[index],
      ...(body.orderId !== undefined && { orderId: body.orderId as string }),
      ...(body.customerName !== undefined && { customerName: body.customerName as string }),
      ...(body.alloy !== undefined && { alloy: body.alloy as string }),
      ...(body.temper !== undefined && { temper: body.temper as string }),
      ...(body.thickness !== undefined && { thickness: body.thickness as number }),
      ...(body.width !== undefined && { width: body.width as number }),
      ...(body.innerDiameter !== undefined && { innerDiameter: body.innerDiameter as number }),
      ...(body.minOuterDiameter !== undefined && { minOuterDiameter: body.minOuterDiameter as number }),
      ...(body.maxOuterDiameter !== undefined && { maxOuterDiameter: body.maxOuterDiameter as number }),
      ...(body.demand !== undefined && { demand: body.demand as number }),
      ...(body.deliveryDate !== undefined && { deliveryDate: body.deliveryDate as string }),
      ...(body.priority !== undefined && { priority: body.priority as number }),
      ...(body.status !== undefined && { status: body.status as number }),
    };

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

  // Delete
  http.delete('/admin-api/aps/order/delete', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const id = Number(url.searchParams.get('id'));
    orders = orders.filter((o) => o.id !== id);
    return HttpResponse.json({ code: 0, data: true, msg: '' });
  }),

  // Import (mock)
  http.post('/admin-api/aps/order/import', async () => {
    await delay(1000);
    return HttpResponse.json({
      code: 0,
      data: { successCount: 5, failCount: 0, errors: [] },
      msg: '',
    });
  }),

  // Download template (mock)
  http.get('/admin-api/aps/order/import-template', async () => {
    await delay(200);
    return new HttpResponse(new Blob(), {
      headers: { 'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' },
    });
  }),

  // Export (mock)
  http.get('/admin-api/aps/order/export', async () => {
    await delay(500);
    return new HttpResponse(new Blob(), {
      headers: { 'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' },
    });
  }),
];