interface TestUser {
  email: string;
  password: string;
  role: 'admin' | 'user';
}

class TestDataFactory {
  static createValidUser(): TestUser
  static createInvalidUser(): TestUser
}

class TestHelper {
  static async waitForPageLoad(): Promise<void>
  static async takeScreenshot(name: string): Promise<void>
  static async clearTestData(): Promise<void>
}

// ✅ Good
expect(loginPage.errorMessage).toBe('Invalid credentials');

// ❌ Bad
expect(loginPage.errorMessage).toBeTruthy();

// tests/api/users.spec.ts
describe('Users API', () => {
  describe('GET /api/users', () => {
    it('should return list of users', async () => {
      const response = await request(app)
        .get('/api/users')
        .set('Authorization', `Bearer ${validToken}`);
      
      expect(response.status).toBe(200);
      expect(response.body).toHaveProperty('users');
      expect(Array.isArray(response.body.users)).toBe(true);
    });

    it('should return 401 without auth token', async () => {
      const response = await request(app).get('/api/users');
      
      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Unauthorized');
    });
  });

  describe('POST /api/users', () => {
    it('should create new user with valid data', async () => {
      const newUser = UserFactory.create();
      
      const response = await request(app)
        .post('/api/users')
        .set('Authorization', `Bearer ${adminToken}`)
        .send(newUser);
      
      expect(response.status).toBe(201);
      expect(response.body).toMatchSchema(UserSchema);
      expect(response.body.email).toBe(newUser.email);
    });

    it('should return 400 with invalid email', async () => {
      const invalidUser = { email: 'invalid', password: 'pass123' };
      
      const response = await request(app)
        .post('/api/users')
        .set('Authorization', `Bearer ${adminToken}`)
        .send(invalidUser);
      
      expect(response.status).toBe(400);
      expect(response.body.errors).toContain('Invalid email format');
    });
  });
});

// tests/factories/UserFactory.ts
import { faker } from '@faker-js/faker';

export class UserFactory {
  static create(overrides?: Partial<User>): User {
    return {
      email: faker.internet.email(),
      password: faker.internet.password({ length: 12 }),
      firstName: faker.person.firstName(),
      lastName: faker.person.lastName(),
      role: 'user',
      ...overrides
    };
  }

  static createAdmin(): User {
    return this.create({ role: 'admin' });
  }

  static createBatch(count: number): User[] {
    return Array.from({ length: count }, () => this.create());
  }
}

// tests/schemas/UserSchema.ts
export const UserSchema = {
  type: 'object',
  required: ['id', 'email', 'firstName', 'lastName'],
  properties: {
    id: { type: 'string', format: 'uuid' },
    email: { type: 'string', format: 'email' },
    firstName: { type: 'string', minLength: 1 },
    lastName: { type: 'string', minLength: 1 },
    role: { type: 'string', enum: ['user', 'admin'] },
    createdAt: { type: 'string', format: 'date-time' }
  }
};

// ✅ Good: Use factories
const user = UserFactory.create({ role: 'admin' });

// ❌ Bad: Hardcoded data
const user = { email: 'test@test.com', password: '123456' };

// ✅ Good: Page Object
class LoginPage {
  private emailInput = 'input[name="email"]';
  private passwordInput = 'input[name="password"]';
  private loginButton = 'button[type="submit"]';

  async login(email: string, password: string) {
    await this.page.fill(this.emailInput, email);
    await this.page.fill(this.passwordInput, password);
    await this.page.click(this.loginButton);
  }
}

// Test
test('should login successfully', async () => {
  await loginPage.login('user@test.com', 'pass123');
  expect(await dashboardPage.isDisplayed()).toBe(true);
});

// ❌ Bad: Direct selectors in test
test('should login successfully', async () => {
  await page.fill('input[name="email"]', 'user@test.com');
  await page.fill('input[name="password"]', 'pass123');
  await page.click('button[type="submit"]');
});

// ✅ Good: Specific assertions
expect(response.status).toBe(200);
expect(response.body.email).toBe('test@example.com');
expect(response.body.users).toHaveLength(5);

// ❌ Bad: Generic assertions
expect(response.status).toBeTruthy();
expect(response.body).toBeDefined();

// ✅ Good: Each test is independent
describe('User CRUD', () => {
  beforeEach(async () => {
    await TestHelper.clearDatabase();
    await TestHelper.seedTestData();
  });

  test('should create user', async () => {
    // Test logic
  });

  test('should update user', async () => {
    // Test logic
  });
});

// ❌ Bad: Tests depend on each other
test('1. should create user', async () => {
  userId = await createUser();
});

test('2. should update user', async () => {
  await updateUser(userId); // Depends on test 1
});

// Use unique data per test
const uniqueEmail = `test-${Date.now()}@example.com`;

// Or use test isolation
beforeEach(async () => {
  await db.truncate('users');
});