import { test, expect } from '../fixtures/test-fixtures';

test.describe('API集成测试', () => {
  test.beforeEach(async ({ apiHelper, testLogger }) => {
    testLogger.startTest('API集成测试');
    await apiHelper.login('admin', 'admin123');
  });

  test.afterEach(async ({ apiHelper, testLogger }) => {
    await apiHelper.logout();
    testLogger.endTest('API集成测试', 'passed');
  });

  test('TC-API-001: 用户CRUD操作', async ({ apiHelper, assertionHelper, testLogger }) => {
    testLogger.startStep('步骤1: 创建用户');
    
    const userData = {
      username: `api_test_${Date.now()}`,
      password: 'Test@123456',
      realName: 'API测试用户',
      email: `api_test_${Date.now()}@example.com`,
      phone: '13800138000',
      status: 1,
      gender: 1
    };
    
    const createResponse = await apiHelper.post('/api/sys/user', userData);
    await assertionHelper.assertAPISuccess(createResponse, '创建用户API应该返回成功');
    
    const createdUser = await createResponse.json();
    const userId = createdUser.data?.id || createdUser.id;
    
    testLogger.endStep('步骤1: 创建用户', 'passed');
    
    testLogger.startStep('步骤2: 查询用户');
    
    const getResponse = await apiHelper.get(`/api/sys/user/${userId}`);
    await assertionHelper.assertAPISuccess(getResponse, '查询用户API应该返回成功');
    
    const getUser = await getResponse.json();
    expect(getUser.data?.username).toBe(userData.username);
    
    testLogger.endStep('步骤2: 查询用户', 'passed');
    
    testLogger.startStep('步骤3: 更新用户');
    
    const updateData = {
      id: userId,
      realName: '更新后的用户名',
      email: `updated_${Date.now()}@example.com`
    };
    
    const updateResponse = await apiHelper.put('/api/sys/user', updateData);
    await assertionHelper.assertAPISuccess(updateResponse, '更新用户API应该返回成功');
    
    testLogger.endStep('步骤3: 更新用户', 'passed');
    
    testLogger.startStep('步骤4: 验证更新');
    
    const verifyResponse = await apiHelper.get(`/api/sys/user/${userId}`);
    const verifyUser = await verifyResponse.json();
    expect(verifyUser.data?.realName).toBe(updateData.realName);
    expect(verifyUser.data?.email).toBe(updateData.email);
    
    testLogger.endStep('步骤4: 验证更新', 'passed');
    
    testLogger.startStep('步骤5: 删除用户');
    
    const deleteResponse = await apiHelper.delete(`/api/sys/user/${userId}`);
    await assertionHelper.assertAPISuccess(deleteResponse, '删除用户API应该返回成功');
    
    testLogger.endStep('步骤5: 删除用户', 'passed');
    
    testLogger.startStep('步骤6: 验证删除');
    
    const verifyDeleteResponse = await apiHelper.get(`/api/sys/user/${userId}`);
    expect(verifyDeleteResponse.status()).toBe(404);
    
    testLogger.endStep('步骤6: 验证删除', 'passed');
  });

  test('TC-API-002: 角色CRUD操作', async ({ apiHelper, assertionHelper, testLogger }) => {
    testLogger.startStep('步骤1: 创建角色');
    
    const roleData = {
      roleName: `API测试角色_${Date.now()}`,
      roleCode: `api_test_role_${Date.now()}`,
      description: 'API测试角色描述',
      status: 1
    };
    
    const createResponse = await apiHelper.post('/api/sys/role', roleData);
    await assertionHelper.assertAPISuccess(createResponse, '创建角色API应该返回成功');
    
    const createdRole = await createResponse.json();
    const roleId = createdRole.data?.id || createdRole.id;
    
    testLogger.endStep('步骤1: 创建角色', 'passed');
    
    testLogger.startStep('步骤2: 查询角色列表');
    
    const listResponse = await apiHelper.get('/api/sys/role/list');
    await assertionHelper.assertAPISuccess(listResponse, '查询角色列表API应该返回成功');
    
    const roleList = await listResponse.json();
    expect(roleList.data?.length).toBeGreaterThan(0);
    
    testLogger.endStep('步骤2: 查询角色列表', 'passed');
    
    testLogger.startStep('步骤3: 查询单个角色');
    
    const getResponse = await apiHelper.get(`/api/sys/role/${roleId}`);
    await assertionHelper.assertAPISuccess(getResponse, '查询角色API应该返回成功');
    
    const getRole = await getResponse.json();
    expect(getRole.data?.roleName).toBe(roleData.roleName);
    
    testLogger.endStep('步骤3: 查询单个角色', 'passed');
    
    testLogger.startStep('步骤4: 更新角色');
    
    const updateData = {
      id: roleId,
      roleName: '更新后的角色名',
      description: '更新后的角色描述'
    };
    
    const updateResponse = await apiHelper.put('/api/sys/role', updateData);
    await assertionHelper.assertAPISuccess(updateResponse, '更新角色API应该返回成功');
    
    testLogger.endStep('步骤4: 更新角色', 'passed');
    
    testLogger.startStep('步骤5: 删除角色');
    
    const deleteResponse = await apiHelper.delete(`/api/sys/role/${roleId}`);
    await assertionHelper.assertAPISuccess(deleteResponse, '删除角色API应该返回成功');
    
    testLogger.endStep('步骤5: 删除角色', 'passed');
  });

  test('TC-API-003: 菜单CRUD操作', async ({ apiHelper, assertionHelper, testLogger }) => {
    testLogger.startStep('步骤1: 创建菜单');
    
    const menuData = {
      name: `API测试菜单_${Date.now()}`,
      code: `api_test_menu_${Date.now()}`,
      path: `/api-test-menu-${Date.now()}`,
      icon: 'SettingOutlined',
      sortOrder: 10,
      status: 1,
      parentId: 0
    };
    
    const createResponse = await apiHelper.post('/api/sys/menu', menuData);
    await assertionHelper.assertAPISuccess(createResponse, '创建菜单API应该返回成功');
    
    const createdMenu = await createResponse.json();
    const menuId = createdMenu.data?.id || createdMenu.id;
    
    testLogger.endStep('步骤1: 创建菜单', 'passed');
    
    testLogger.startStep('步骤2: 查询菜单树');
    
    const treeResponse = await apiHelper.get('/api/sys/menu/tree');
    await assertionHelper.assertAPISuccess(treeResponse, '查询菜单树API应该返回成功');
    
    const menuTree = await treeResponse.json();
    expect(menuTree.data?.length).toBeGreaterThan(0);
    
    testLogger.endStep('步骤2: 查询菜单树', 'passed');
    
    testLogger.startStep('步骤3: 查询单个菜单');
    
    const getResponse = await apiHelper.get(`/api/sys/menu/${menuId}`);
    await assertionHelper.assertAPISuccess(getResponse, '查询菜单API应该返回成功');
    
    const getMenu = await getResponse.json();
    expect(getMenu.data?.name).toBe(menuData.name);
    
    testLogger.endStep('步骤3: 查询单个菜单', 'passed');
    
    testLogger.startStep('步骤4: 更新菜单');
    
    const updateData = {
      id: menuId,
      name: '更新后的菜单名',
      icon: 'EditOutlined'
    };
    
    const updateResponse = await apiHelper.put('/api/sys/menu', updateData);
    await assertionHelper.assertAPISuccess(updateResponse, '更新菜单API应该返回成功');
    
    testLogger.endStep('步骤4: 更新菜单', 'passed');
    
    testLogger.startStep('步骤5: 删除菜单');
    
    const deleteResponse = await apiHelper.delete(`/api/sys/menu/${menuId}`);
    await assertionHelper.assertAPISuccess(deleteResponse, '删除菜单API应该返回成功');
    
    testLogger.endStep('步骤5: 删除菜单', 'passed');
  });

  test('TC-API-004: 分页查询用户', async ({ apiHelper, assertionHelper, testLogger }) => {
    testLogger.startStep('步骤1: 创建多个测试用户');
    
    const users = [];
    for (let i = 0; i < 5; i++) {
      const userData = {
        username: `pagination_test_${Date.now()}_${i}`,
        password: 'Test@123456',
        realName: `分页测试用户${i}`,
        email: `pagination_test_${i}@example.com`,
        phone: '13800138000',
        status: 1,
        gender: 1
      };
      
      const createResponse = await apiHelper.post('/api/sys/user', userData);
      const createdUser = await createResponse.json();
      users.push(createdUser.data?.id || createdUser.id);
    }
    
    testLogger.endStep('步骤1: 创建多个测试用户', 'passed');
    
    testLogger.startStep('步骤2: 分页查询用户');
    
    const page1Response = await apiHelper.get('/api/sys/user/page', {
      current: 1,
      size: 2
    });
    
    await assertionHelper.assertAPISuccess(page1Response, '分页查询API应该返回成功');
    
    const page1Data = await page1Response.json();
    expect(page1Data.data?.records?.length).toBeLessThanOrEqual(2);
    expect(page1Data.data?.total).toBeGreaterThanOrEqual(5);
    
    testLogger.endStep('步骤2: 分页查询用户', 'passed');
    
    testLogger.startStep('步骤3: 查询第二页');
    
    const page2Response = await apiHelper.get('/api/sys/user/page', {
      current: 2,
      size: 2
    });
    
    await assertionHelper.assertAPISuccess(page2Response, '分页查询API应该返回成功');
    
    const page2Data = await page2Response.json();
    expect(page2Data.data?.records?.length).toBeLessThanOrEqual(2);
    
    testLogger.endStep('步骤3: 查询第二页', 'passed');
    
    testLogger.startStep('步骤4: 清理测试数据');
    
    for (const userId of users) {
      await apiHelper.delete(`/api/sys/user/${userId}`);
    }
    
    testLogger.endStep('步骤4: 清理测试数据', 'passed');
  });

  test('TC-API-005: 用户搜索功能', async ({ apiHelper, assertionHelper, testLogger }) => {
    testLogger.startStep('步骤1: 创建测试用户');
    
    const userData = {
      username: `search_test_${Date.now()}`,
      password: 'Test@123456',
      realName: '搜索测试用户',
      email: 'search_test@example.com',
      phone: '13800138000',
      status: 1,
      gender: 1
    };
    
    const createResponse = await apiHelper.post('/api/sys/user', userData);
    const createdUser = await createResponse.json();
    const userId = createdUser.data?.id || createdUser.id;
    
    testLogger.endStep('步骤1: 创建测试用户', 'passed');
    
    testLogger.startStep('步骤2: 按用户名搜索');
    
    const searchResponse = await apiHelper.get('/api/sys/user/page', {
      username: userData.username
    });
    
    await assertionHelper.assertAPISuccess(searchResponse, '搜索API应该返回成功');
    
    const searchData = await searchResponse.json();
    expect(searchData.data?.records?.length).toBeGreaterThan(0);
    expect(searchData.data?.records?.[0]?.username).toBe(userData.username);
    
    testLogger.endStep('步骤2: 按用户名搜索', 'passed');
    
    testLogger.startStep('步骤3: 按真实姓名搜索');
    
    const searchByNameResponse = await apiHelper.get('/api/sys/user/page', {
      realName: userData.realName
    });
    
    await assertionHelper.assertAPISuccess(searchByNameResponse, '按姓名搜索API应该返回成功');
    
    const searchByNameData = await searchByNameResponse.json();
    expect(searchByNameData.data?.records?.length).toBeGreaterThan(0);
    expect(searchByNameData.data?.records?.[0]?.realName).toBe(userData.realName);
    
    testLogger.endStep('步骤3: 按真实姓名搜索', 'passed');
    
    testLogger.startStep('步骤4: 清理测试数据');
    
    await apiHelper.delete(`/api/sys/user/${userId}`);
    
    testLogger.endStep('步骤4: 清理测试数据', 'passed');
  });
});