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

test.describe('DataStrategyManager - 数据策略管理器测试', () => {
  
  test('应该能够初始化并获取默认策略', async ({ dataStrategyManager }) => {
    const strategy = dataStrategyManager.getStrategy();
    expect(strategy).toBe('hybrid');
    
    const config = dataStrategyManager.getConfig();
    expect(config.strategy).toBe('hybrid');
    expect(config.mockEnabled).toBe(true);
    expect(config.realDataEnabled).toBe(true);
    expect(config.autoCleanup).toBe(true);
  });

  test('应该能够设置和获取数据策略', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('mock');
    expect(dataStrategyManager.getStrategy()).toBe('mock');
    
    dataStrategyManager.setStrategy('real');
    expect(dataStrategyManager.getStrategy()).toBe('real');
    
    dataStrategyManager.setStrategy('hybrid');
    expect(dataStrategyManager.getStrategy()).toBe('hybrid');
  });

  test('应该能够根据@smoke标签选择Mock数据源', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    const dataSource = dataStrategyManager.selectDataSource(['@smoke']);
    expect(dataSource).toBe('mock');
  });

  test('应该能够根据@regression标签选择混合数据源', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    const dataSource = dataStrategyManager.selectDataSource(['@regression']);
    expect(dataSource).toBe('hybrid');
  });

  test('应该能够根据@full标签选择真实数据源', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    const dataSource = dataStrategyManager.selectDataSource(['@full']);
    expect(dataSource).toBe('real');
  });

  test('应该能够根据@critical标签选择真实数据源', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    const dataSource = dataStrategyManager.selectDataSource(['@critical']);
    expect(dataSource).toBe('real');
  });

  test('应该能够创建Mock用户数据', async ({ dataStrategyManager }) => {
    const userData = {
      username: 'testuser',
      password: 'password123'
    };
    
    const result = await dataStrategyManager.createData('user', userData, ['@smoke']);
    expect(result).toBeDefined();
    expect(result.username).toBe('testuser');
    expect(result.password).toBe('password123');
    expect(result.email).toBeDefined();
    expect(result.phone).toBeDefined();
  });

  test('应该能够创建Mock角色数据', async ({ dataStrategyManager }) => {
    const roleData = {
      roleName: '测试角色',
      roleKey: 'test_role'
    };
    
    const result = await dataStrategyManager.createData('role', roleData, ['@smoke']);
    expect(result).toBeDefined();
    expect(result.roleName).toBe('测试角色');
    expect(result.roleKey).toBe('test_role');
    expect(result.description).toBeDefined();
  });

  test('应该能够创建Mock菜单数据', async ({ dataStrategyManager }) => {
    const menuData = {
      menuName: '测试菜单',
      path: '/test'
    };
    
    const result = await dataStrategyManager.createData('menu', menuData, ['@smoke']);
    expect(result).toBeDefined();
    expect(result.menuName).toBe('测试菜单');
    expect(result.path).toBe('/test');
    expect(result.icon).toBeDefined();
  });

  test('应该能够创建数据快照', async ({ dataStrategyManager }) => {
    const snapshotName = 'test-snapshot';
    const snapshot = await dataStrategyManager.createSnapshot(snapshotName);
    
    expect(snapshot).toBeDefined();
    expect(snapshot.name).toBe(snapshotName);
    expect(snapshot.timestamp).toBeGreaterThan(0);
    expect(snapshot.data).toBeDefined();
  });

  test('应该能够回滚到数据快照', async ({ dataStrategyManager }) => {
    const snapshotName = 'rollback-test-snapshot';
    
    await dataStrategyManager.createData('user', { username: 'user1' }, ['@smoke']);
    await dataStrategyManager.createSnapshot(snapshotName);
    
    await dataStrategyManager.createData('user', { username: 'user2' }, ['@smoke']);
    
    await dataStrategyManager.rollbackToSnapshot(snapshotName);
    
    const users = dataStrategyManager.getTestData('user');
    expect(users.length).toBe(1);
    expect(users[0].username).toBe('user1');
  });

  test('应该能够获取所有快照', async ({ dataStrategyManager }) => {
    await dataStrategyManager.createSnapshot('snapshot1');
    await dataStrategyManager.createSnapshot('snapshot2');
    await dataStrategyManager.createSnapshot('snapshot3');
    
    const snapshots = dataStrategyManager.getAllSnapshots();
    expect(snapshots.length).toBe(3);
    expect(snapshots[0].name).toBe('snapshot1');
    expect(snapshots[1].name).toBe('snapshot2');
    expect(snapshots[2].name).toBe('snapshot3');
  });

  test('应该能够删除快照', async ({ dataStrategyManager }) => {
    const snapshotName = 'delete-test-snapshot';
    await dataStrategyManager.createSnapshot(snapshotName);
    
    expect(dataStrategyManager.getSnapshot(snapshotName)).toBeDefined();
    
    dataStrategyManager.deleteSnapshot(snapshotName);
    
    expect(dataStrategyManager.getSnapshot(snapshotName)).toBeUndefined();
  });

  test('应该能够获取统计信息', async ({ dataStrategyManager }) => {
    await dataStrategyManager.createData('user', { username: 'user1' }, ['@smoke']);
    await dataStrategyManager.createData('user', { username: 'user2' }, ['@smoke']);
    await dataStrategyManager.createData('role', { roleName: 'role1' }, ['@smoke']);
    await dataStrategyManager.createSnapshot('snapshot1');
    await dataStrategyManager.createSnapshot('snapshot2');
    
    const stats = dataStrategyManager.getStatistics();
    
    expect(stats.totalTestData).toBe(3);
    expect(stats.totalSnapshots).toBe(2);
    expect(stats.strategy).toBe('hybrid');
    expect(stats.config).toBeDefined();
  });

  test('应该能够清理所有测试数据', async ({ dataStrategyManager }) => {
    await dataStrategyManager.createData('user', { username: 'user1' }, ['@smoke']);
    await dataStrategyManager.createData('role', { roleName: 'role1' }, ['@smoke']);
    await dataStrategyManager.createSnapshot('snapshot1');
    
    expect(dataStrategyManager.getTestData('user').length).toBeGreaterThan(0);
    expect(dataStrategyManager.getAllSnapshots().length).toBeGreaterThan(0);
    
    await dataStrategyManager.cleanupAll();
    
    expect(dataStrategyManager.getTestData('user').length).toBe(0);
    expect(dataStrategyManager.getAllSnapshots().length).toBe(0);
  });

  test('应该能够处理多个标签的情况', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    
    const dataSource1 = dataStrategyManager.selectDataSource(['@smoke', '@normal']);
    expect(dataSource1).toBe('mock');
    
    const dataSource2 = dataStrategyManager.selectDataSource(['@regression', '@normal']);
    expect(dataSource2).toBe('hybrid');
    
    const dataSource3 = dataStrategyManager.selectDataSource(['@full', '@complete']);
    expect(dataSource3).toBe('real');
    
    const dataSource4 = dataStrategyManager.selectDataSource(['@critical', '@smoke']);
    expect(dataSource4).toBe('real');
  });

  test('应该能够处理未知数据类型', async ({ dataStrategyManager }) => {
    const unknownData = { name: 'unknown' };
    const result = await dataStrategyManager.createData('unknown', unknownData, ['@smoke']);
    
    expect(result).toBeDefined();
    expect(result.name).toBe('unknown');
  });

  test('应该能够处理强制真实数据策略', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('real');
    
    const dataSource = dataStrategyManager.selectDataSource(['@smoke']);
    expect(dataSource).toBe('real');
  });

  test('应该能够处理强制Mock数据策略', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('mock');
    
    const dataSource = dataStrategyManager.selectDataSource(['@full']);
    expect(dataSource).toBe('mock');
  });

  test('应该能够处理没有标签的情况', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    
    const dataSource = dataStrategyManager.selectDataSource([]);
    expect(dataSource).toBe('mock');
  });

  test('应该能够创建混合数据', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    
    const userData = { username: 'hybrid_user' };
    const result = await dataStrategyManager.createData('user', userData, ['@regression']);
    
    expect(result).toBeDefined();
    expect(result.username).toBe('hybrid_user');
    expect(result._dataSource).toBe('hybrid');
    expect(result._mockData).toBeDefined();
    expect(result._realData).toBeDefined();
  });
});

test.describe('DataStrategyManager - 集成测试', () => {
  
  test('应该在测试用例中正常使用数据策略管理器', async ({ dataStrategyManager, page }) => {
    dataStrategyManager.setStrategy('hybrid');
    
    const userData = await dataStrategyManager.createData('user', {
      username: 'integration_test_user',
      password: 'password123'
    }, ['@smoke']);
    
    expect(userData).toBeDefined();
    expect(userData.username).toBe('integration_test_user');
    
    await page.goto('http://localhost:3000/login');
    await page.fill('input[name="username"]', userData.username);
    await page.fill('input[name="password"]', userData.password);
  });

  test('应该能够在不同测试标签下使用不同数据源', async ({ dataStrategyManager }) => {
    dataStrategyManager.setStrategy('hybrid');
    
    const mockData = await dataStrategyManager.createData('user', {
      username: 'mock_user'
    }, ['@smoke']);
    
    const hybridData = await dataStrategyManager.createData('user', {
      username: 'hybrid_user'
    }, ['@regression']);
    
    const realData = await dataStrategyManager.createData('user', {
      username: 'real_user'
    }, ['@full']);
    
    expect(mockData).toBeDefined();
    expect(hybridData).toBeDefined();
    expect(realData).toBeDefined();
  });
});