import { http, HttpResponse, delay } from 'msw';
import {
  mockSystemUsers,
  mockPasswords,
  mockAdminBackendMenus,
  mockUserBackendMenus,
  mockAdminPermissions,
  mockUserPermissions,
  mockDepts,
  mockPosts,
  mockSystemRoles,
} from '../data';

// In-memory state
let currentUser: typeof mockSystemUsers[number] | null = null;

function getUserWithDetails(user: typeof mockSystemUsers[number]) {
  const dept = mockDepts.find((d) => d.id === user.deptId);
  const roles = user.username === 'admin'
    ? [mockSystemRoles[0]]
    : [mockSystemRoles[1]];
  const posts = user.postIds
    .map((pid) => mockPosts.find((p) => String(p.id) === pid))
    .filter(Boolean);
  return {
    id: user.id,
    username: user.username,
    nickname: user.nickname,
    avatar: user.avatar,
    email: user.email,
    mobile: user.mobile,
    sex: user.sex,
    status: user.status,
    loginIp: user.loginIp,
    loginDate: user.createTime,
    createTime: user.createTime,
    dept: dept ? { id: dept.id, name: dept.name } : undefined,
    roles: roles.map((r) => ({ id: r!.id, name: r!.name })),
    posts: posts.map((p) => ({ id: p!.id, name: p!.name })),
  };
}

export const authHandlers = [
  // Login
  http.post('/admin-api/system/auth/login', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as { username?: string; password?: string };
    const { username, password } = body;

    if (!username || !password) {
      return HttpResponse.json(
        { code: 1, data: null, message: '用户名或密码不能为空' },
      );
    }

    const user = mockSystemUsers.find((u) => u.username === username);
    if (!user || mockPasswords[username] !== password) {
      return HttpResponse.json(
        { code: 1, data: null, message: '账号或密码错误' },
      );
    }

    if (user.status === 1) {
      return HttpResponse.json(
        { code: 1, data: null, message: '该账号已被禁用' },
      );
    }

    currentUser = user;
    const expiresTime = Date.now() + 2 * 60 * 60 * 1000; // 2 hours

    return HttpResponse.json({
      code: 0,
      data: {
        accessToken: `mock-access-token-${user.username}-${Date.now()}`,
        refreshToken: `mock-refresh-token-${user.username}-${Date.now()}`,
        userId: user.id,
        expiresTime,
      },
      message: 'ok',
    });
  }),

  // Logout
  http.post('/admin-api/system/auth/logout', async () => {
    await delay(200);
    currentUser = null;
    return HttpResponse.json({ code: 0, data: true, message: 'ok' });
  }),

  // Refresh token
  http.post('/admin-api/system/auth/refresh-token', async ({ request }) => {
    await delay(200);
    const url = new URL(request.url);
    const refreshToken = url.searchParams.get('refreshToken');

    if (!refreshToken) {
      return HttpResponse.json(
        { code: 1, data: null, message: '刷新令牌不能为空' },
      );
    }

    const expiresTime = Date.now() + 2 * 60 * 60 * 1000;
    const username = currentUser?.username || 'admin';

    return HttpResponse.json({
      code: 0,
      data: {
        accessToken: `mock-access-token-${username}-${Date.now()}`,
        refreshToken: `mock-refresh-token-${username}-${Date.now()}`,
        expiresTime,
      },
      message: 'ok',
    });
  }),

  // Get permission info
  http.get('/admin-api/system/auth/get-permission-info', async () => {
    await delay(300);

    const user = currentUser || mockSystemUsers[0];
    const isAdmin = user.username === 'admin';

    return HttpResponse.json({
      code: 0,
      data: {
        user: getUserWithDetails(user),
        roles: isAdmin ? ['super_admin'] : ['common'],
        permissions: isAdmin ? mockAdminPermissions : mockUserPermissions,
        menus: isAdmin ? mockAdminBackendMenus : mockUserBackendMenus,
      },
      message: 'ok',
    });
  }),

  // Get profile
  http.get('/admin-api/system/user/profile/get', async () => {
    await delay(300);
    const user = currentUser || mockSystemUsers[0];
    return HttpResponse.json({
      code: 0,
      data: getUserWithDetails(user),
      message: 'ok',
    });
  }),

  // Update profile
  http.put('/admin-api/system/user/profile/update', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as Record<string, unknown>;
    const user = currentUser || mockSystemUsers[0];

    if (body.nickname !== undefined) user.nickname = body.nickname as string;
    if (body.email !== undefined) user.email = body.email as string;
    if (body.mobile !== undefined) user.mobile = body.mobile as string;
    if (body.sex !== undefined) user.sex = body.sex as number;
    if (body.avatar !== undefined) user.avatar = body.avatar as string;

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

  // Update password
  http.put('/admin-api/system/user/profile/update-password', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as { oldPassword?: string; newPassword?: string };
    const user = currentUser || mockSystemUsers[0];

    if (!body.oldPassword || !body.newPassword) {
      return HttpResponse.json(
        { code: 1, data: null, message: '旧密码或新密码不能为空' },
      );
    }

    if (mockPasswords[user.username] !== body.oldPassword) {
      return HttpResponse.json(
        { code: 1, data: null, message: '旧密码不正确' },
      );
    }

    mockPasswords[user.username] = body.newPassword;
    return HttpResponse.json({ code: 0, data: true, message: 'ok' });
  }),

  // Register
  http.post('/admin-api/system/auth/register', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as { username?: string; password?: string };

    if (!body.username || !body.password) {
      return HttpResponse.json(
        { code: 1, data: null, message: '用户名或密码不能为空' },
      );
    }

    const exists = mockSystemUsers.find((u) => u.username === body.username);
    if (exists) {
      return HttpResponse.json(
        { code: 1, data: null, message: '该用户名已存在' },
      );
    }

    const newId = Math.max(...mockSystemUsers.map((u) => u.id)) + 1;
    mockSystemUsers.push({
      id: newId,
      username: body.username,
      nickname: body.username,
      deptId: 104,
      postIds: ['2'],
      email: `${body.username}@example.com`,
      mobile: `138000${String(newId).padStart(5, '0')}`,
      sex: 1,
      avatar: '',
      loginIp: '127.0.0.1',
      status: 0,
      remark: '',
      createTime: new Date().toISOString().replace('T', ' ').slice(0, 19),
    });
    mockPasswords[body.username] = body.password!;

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

  // Reset password
  http.post('/admin-api/system/auth/reset-password', async ({ request }) => {
    await delay(300);
    const body = (await request.json()) as { password?: string; mobile?: string };

    if (!body.password) {
      return HttpResponse.json(
        { code: 1, data: null, message: '密码不能为空' },
      );
    }

    const user = mockSystemUsers.find((u) => u.mobile === body.mobile);
    if (!user) {
      return HttpResponse.json(
        { code: 1, data: null, message: '手机号不存在' },
      );
    }

    mockPasswords[user.username] = body.password;
    return HttpResponse.json({ code: 0, data: true, message: 'ok' });
  }),
];