// API Client for Server Communication
class PencereAPI {
    constructor() {
        this.baseURL = process.env.API_BASE_URL || 'http://localhost:3001/api';
        this.token = localStorage.getItem('authToken');
        this.user = JSON.parse(localStorage.getItem('currentUser') || 'null');
    }

    // Set authentication token
    setToken(token) {
        this.token = token;
        if (token) {
            localStorage.setItem('authToken', token);
        } else {
            localStorage.removeItem('authToken');
        }
    }

    // Set current user
    setUser(user) {
        this.user = user;
        if (user) {
            localStorage.setItem('currentUser', JSON.stringify(user));
        } else {
            localStorage.removeItem('currentUser');
        }
    }

    // Generic request method
    async request(endpoint, options = {}) {
        const url = `${this.baseURL}${endpoint}`;
        const config = {
            headers: {
                'Content-Type': 'application/json',
                ...options.headers
            },
            ...options
        };

        if (this.token) {
            config.headers.Authorization = `Bearer ${this.token}`;
        }

        try {
            const response = await fetch(url, config);
            
            if (response.status === 401) {
                // Token expired or invalid
                this.setToken(null);
                this.setUser(null);
                window.location.href = '#login';
                throw new Error('Authentication required');
            }

            const data = await response.json();
            
            if (!response.ok) {
                throw new Error(data.error || 'Request failed');
            }
            
            return data;
        } catch (error) {
            console.error(`API Error (${endpoint}):`, error);
            throw error;
        }
    }

    // Authentication methods
    async login(username, password) {
        const data = await this.request('/auth/login', {
            method: 'POST',
            body: JSON.stringify({ username, password })
        });
        
        this.setToken(data.token);
        this.setUser(data.user);
        return data;
    }

    async register(userData) {
        return await this.request('/auth/register', {
            method: 'POST',
            body: JSON.stringify(userData)
        });
    }

    logout() {
        this.setToken(null);
        this.setUser(null);
    }

    // Company methods
    async getCompany() {
        return await this.request('/company');
    }

    async updateCompany(companyData) {
        return await this.request('/company', {
            method: 'PUT',
            body: companyData
        });
    }

    // System methods
    async getSystems() {
        return await this.request('/systems');
    }

    async createSystem(systemData) {
        return await this.request('/systems', {
            method: 'POST',
            body: systemData
        });
    }

    async updateSystem(id, systemData) {
        return await this.request(`/systems/${id}`, {
            method: 'PUT',
            body: systemData
        });
    }

    async deleteSystem(id) {
        return await this.request(`/systems/${id}`, {
            method: 'DELETE'
        });
    }

    // Customer methods
    async getCustomers() {
        return await this.request('/customers');
    }

    async createCustomer(customerData) {
        return await this.request('/customers', {
            method: 'POST',
            body: customerData
        });
    }

    async updateCustomer(id, customerData) {
        return await this.request(`/customers/${id}`, {
            method: 'PUT',
            body: customerData
        });
    }

    async deleteCustomer(id) {
        return await this.request(`/customers/${id}`, {
            method: 'DELETE'
        });
    }

    // Position methods
    async getPositions(customerId = null) {
        const query = customerId ? `?customerId=${customerId}` : '';
        return await this.request(`/positions${query}`);
    }

    async createPosition(positionData) {
        return await this.request('/positions', {
            method: 'POST',
            body: positionData
        });
    }

    async updatePosition(id, positionData) {
        return await this.request(`/positions/${id}`, {
            method: 'PUT',
            body: positionData
        });
    }

    async deletePosition(id) {
        return await this.request(`/positions/${id}`, {
            method: 'DELETE'
        });
    }

    // PDF Settings methods
    async getPDFSettings(type = null) {
        const query = type ? `?type=${type}` : '';
        return await this.request(`/pdf-settings${query}`);
    }

    async updatePDFSettings(settingsData, type = 'global') {
        return await this.request('/pdf-settings', {
            method: 'PUT',
            body: { type, settings: settingsData }
        });
    }

    // Backup methods
    async createBackup() {
        return await this.request('/backup');
    }

    async restoreData(backupData) {
        return await this.request('/restore', {
            method: 'POST',
            body: backupData
        });
    }

    // File upload helper
    async uploadFile(file, endpoint = '/upload') {
        const formData = new FormData();
        formData.append('file', file);

        const url = `${this.baseURL}${endpoint}`;
        const config = {
            method: 'POST',
            body: formData,
            headers: {}
        };

        if (this.token) {
            config.headers.Authorization = `Bearer ${this.token}`;
        }

        try {
            const response = await fetch(url, config);
            const data = await response.json();
            
            if (!response.ok) {
                throw new Error(data.error || 'Upload failed');
            }
            
            return data;
        } catch (error) {
            console.error(`Upload Error (${endpoint}):`, error);
            throw error;
        }
    }

    // Check if user is authenticated
    isAuthenticated() {
        return !!this.token && !!this.user;
    }

    // Get user role
    getUserRole() {
        return this.user ? this.user.role : null;
    }

    // Check if user is admin
    isAdmin() {
        return this.getUserRole() === 'admin';
    }
}

// Create global API instance
const api = new PencereAPI();

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = PencereAPI;
} else {
    window.PencereAPI = PencereAPI;
    window.api = api;
}