import { chromium, Page, Browser } from '@playwright/test';
import { testEnvironment, API_ENDPOINTS, SETUP_TIMEOUT } from './config';
import { testPersonas } from '../personas/userPersonas';
import { testEvents } from '../events/eventDefinitions';

export class TestEnvironmentManager {
    private browser: Browser | null = null;
    private page: Page | null = null;
    private authToken: string | null = null;

    async setup() {
        console.log('Setting up test environment...');
        this.browser = await chromium.launch();
        this.page = await this.browser.newPage();
        await this.authenticate();
        await this.createTestUsers();
        await this.createTestEvents();
        console.log('Test environment setup complete.');
    }

    async authenticate() {
        const response = await this.page!.request.post(`${testEnvironment.baseUrl}${API_ENDPOINTS.auth}`, {
            data: {
                username: testEnvironment.adminUser.username,
                password: testEnvironment.adminUser.password
            }
        });
        const data = await response.json();
        this.authToken = data.token;
    }

    async createTestUsers() {
        console.log('Creating test users...');
        for (const [key, persona] of Object.entries(testPersonas)) {
            try {
                await this.page!.request.post(`${testEnvironment.baseUrl}${API_ENDPOINTS.users}`, {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`
                    },
                    data: {
                        username: persona.username,
                        email: persona.email,
                        password: persona.password,
                        first_name: persona.firstName,
                        last_name: persona.lastName,
                        roles: [persona.role],
                        meta: {
                            business_name: persona.businessName,
                            business_type: persona.businessType,
                            location: persona.location,
                            special_attributes: persona.specialAttributes
                        }
                    }
                });
                console.log(`Created user: ${persona.username}`);
            } catch (error) {
                console.error(`Failed to create user ${persona.username}:`, error);
            }
        }
    }

    async createTestEvents() {
        console.log('Creating test events...');
        for (const event of testEvents) {
            try {
                await this.page!.request.post(`${testEnvironment.baseUrl}${API_ENDPOINTS.events}`, {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`
                    },
                    data: {
                        title: event.title,
                        description: event.description,
                        start_date: event.startDate,
                        end_date: event.endDate,
                        capacity: event.capacity,
                        cost: event.price,
                        venue: event.location,
                        categories: [event.category],
                        tags: event.tags
                    }
                });
                console.log(`Created event: ${event.title}`);
            } catch (error) {
                console.error(`Failed to create event ${event.title}:`, error);
            }
        }
    }

    async verify() {
        console.log('Verifying test environment...');
        const usersResponse = await this.page!.request.get(`${testEnvironment.baseUrl}${API_ENDPOINTS.users}`, {
            headers: { 'Authorization': `Bearer ${this.authToken}` }
        });
        const users = await usersResponse.json();
        
        const eventsResponse = await this.page!.request.get(`${testEnvironment.baseUrl}${API_ENDPOINTS.events}`, {
            headers: { 'Authorization': `Bearer ${this.authToken}` }
        });
        const events = await eventsResponse.json();

        const expectedUserCount = Object.keys(testPersonas).length;
        const expectedEventCount = testEvents.length;

        if (users.length < expectedUserCount || events.length < expectedEventCount) {
            throw new Error('Test environment verification failed: Missing users or events');
        }
        console.log('Test environment verified successfully.');
    }

    async teardown(force = false) {
        console.log('Tearing down test environment...');
        if (force) {
            await this.deleteAllTestData();
        }
        if (this.browser) {
            await this.browser.close();
        }
        this.browser = null;
        this.page = null;
        this.authToken = null;
        console.log('Test environment teardown complete.');
    }

    private async deleteAllTestData() {
        console.log('Force deleting all test data...');
        // Delete test events
        const eventsResponse = await this.page!.request.get(`${testEnvironment.baseUrl}${API_ENDPOINTS.events}`, {
            headers: { 'Authorization': `Bearer ${this.authToken}` }
        });
        const events = await eventsResponse.json();
        for (const event of events) {
            await this.page!.request.delete(`${testEnvironment.baseUrl}${API_ENDPOINTS.events}/${event.id}`, {
                headers: { 'Authorization': `Bearer ${this.authToken}` }
            });
        }

        // Delete test users
        const usersResponse = await this.page!.request.get(`${testEnvironment.baseUrl}${API_ENDPOINTS.users}`, {
            headers: { 'Authorization': `Bearer ${this.authToken}` }
        });
        const users = await usersResponse.json();
        for (const user of users) {
            if (user.username !== testEnvironment.adminUser.username) {
                await this.page!.request.delete(`${testEnvironment.baseUrl}${API_ENDPOINTS.users}/${user.id}`, {
                    headers: { 'Authorization': `Bearer ${this.authToken}` }
                });
            }
        }
        console.log('All test data deleted.');
    }
}

export const testEnv = new TestEnvironmentManager();