import { testEvents } from './eventDefinitions';
import { testEnvironment, API_ENDPOINTS } from '../environment/config';
import { Page } from '@playwright/test';

export class EventManager {
    constructor(private page: Page, private authToken: string) {}

    async createEvent(eventIndex: number) {
        const event = testEvents[eventIndex];
        if (!event) {
            throw new Error(`No event found at index ${eventIndex}`);
        }

        try {
            const response = 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
                    }
                }
            );

            const data = await response.json();
            console.log(`Created event: ${event.title} with ID: ${data.id}`);
            return data.id;
        } catch (error) {
            console.error(`Failed to create event ${event.title}:`, error);
            throw error;
        }
    }

    async createAllEvents() {
        const eventIds = [];
        for (let i = 0; i < testEvents.length; i++) {
            const id = await this.createEvent(i);
            eventIds.push(id);
        }
        return eventIds;
    }

    async deleteEvent(eventId: number) {
        try {
            await this.page.request.delete(
                `${testEnvironment.baseUrl}${API_ENDPOINTS.events}/${eventId}`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`
                    }
                }
            );
            console.log(`Deleted event with ID: ${eventId}`);
        } catch (error) {
            console.error(`Failed to delete event ${eventId}:`, error);
            throw error;
        }
    }

    async deleteAllEvents() {
        const response = await this.page.request.get(
            `${testEnvironment.baseUrl}${API_ENDPOINTS.events}`,
            {
                headers: {
                    'Authorization': `Bearer ${this.authToken}`
                }
            }
        );
        const events = await response.json();
        
        for (const event of events) {
            await this.deleteEvent(event.id);
        }
        console.log('All test events deleted');
    }

    async getEventById(eventId: number) {
        try {
            const response = await this.page.request.get(
                `${testEnvironment.baseUrl}${API_ENDPOINTS.events}/${eventId}`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`
                    }
                }
            );
            return await response.json();
        } catch (error) {
            console.error(`Failed to get event ${eventId}:`, error);
            throw error;
        }
    }

    async updateEvent(eventId: number, updates: Partial<typeof testEvents[0]>) {
        try {
            const response = await this.page.request.patch(
                `${testEnvironment.baseUrl}${API_ENDPOINTS.events}/${eventId}`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`
                    },
                    data: updates
                }
            );
            console.log(`Updated event ${eventId}`);
            return await response.json();
        } catch (error) {
            console.error(`Failed to update event ${eventId}:`, error);
            throw error;
        }
    }
}