api-service.js

// API Service for Gemini API calls
class ApiService {
    constructor(config) {
        this.config = config;
        // Use the correct Gemini model - gemini-1.5-flash is the current stable model
        this.baseUrl = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent';
    }

    async generateHints(problemStatement) {
        if (!this.config.hasValidApiKey()) {
            throw new Error('No valid API key found. Please set your Gemini API key.');
        }

        const prompt = formatPrompt(PROMPT_TEMPLATES.DSA_HINTS, problemStatement);
        
        try {
            console.log('Making API request to Gemini...');
            const response = await fetch(
                `${this.baseUrl}?key=${this.config.getApiKey()}`,
                {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({
                        contents: [{
                            parts: [{
                                text: prompt
                            }]
                        }],
                        generationConfig: {
                            temperature: 0.7,
                            topK: 40,
                            topP: 0.95,
                            maxOutputTokens: 800,
                        }
                    })
                }
            );

            console.log('API Response status:', response.status);

            if (!response.ok) {
                const errorData = await response.json().catch(() => ({}));
                const errorMessage = errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`;
                
                console.error('API Error:', errorData);
                
                // Handle specific API errors
                if (response.status === 400) {
                    throw new Error(`Invalid request: ${errorMessage}`);
                } else if (response.status === 401) {
                    throw new Error('Invalid API key. Please check your Gemini API key.');
                } else if (response.status === 403) {
                    throw new Error('API key not authorized. Please check your API key permissions.');
                } else if (response.status === 429) {
                    throw new Error('Rate limit exceeded. Please try again later.');
                } else if (response.status >= 500) {
                    throw new Error('Server error. Please try again later.');
                } else {
                    throw new Error(`API Error: ${errorMessage}`);
                }
            }

            const data = await response.json();
            console.log('API Response data:', data);
            
            // Validate response structure
            if (!data.candidates || !data.candidates[0] || !data.candidates[0].content || !data.candidates[0].content.parts || !data.candidates[0].content.parts[0]) {
                throw new Error('Invalid response format from API');
            }

            const responseText = data.candidates[0].content.parts[0].text;
            
            if (!responseText || responseText.trim().length === 0) {
                throw new Error('Empty response from API');
            }

            return extractHints(responseText);
        } catch (error) {
            console.error('Error in generateHints:', error);
            
            // Re-throw API errors
            if (error.message.includes('API Error') || error.message.includes('Invalid') || error.message.includes('Rate limit')) {
                throw error;
            }
            
            // Handle network errors
            if (error.name === 'TypeError' && error.message.includes('fetch')) {
                throw new Error('Network error. Please check your internet connection.');
            }
            
            // Handle JSON parsing errors
            if (error.name === 'SyntaxError') {
                throw new Error('Invalid response from API. Please try again.');
            }
            
            // Generic error
            throw new Error(`Failed to generate hints: ${error.message}`);
        }
    }

    async testApiKey(apiKey) {
        const testPrompt = "Hello, this is a test message.";
        
        try {
            console.log('Testing API key...');
            const response = await fetch(
                `${this.baseUrl}?key=${apiKey}`,
                {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({
                        contents: [{
                            parts: [{
                                text: testPrompt
                            }]
                        }],
                        generationConfig: {
                            maxOutputTokens: 10,
                        }
                    })
                }
            );

            console.log('Test API Response status:', response.status);

            if (!response.ok) {
                const errorData = await response.json().catch(() => ({}));
                console.error('Test API Error:', errorData);
                
                if (response.status === 401 || response.status === 403) {
                    return { valid: false, error: 'Invalid API key' };
                }
                return { valid: false, error: errorData.error?.message || 'API test failed' };
            }

            const data = await response.json();
            console.log('Test API Response data:', data);
            
            return { valid: true };
        } catch (error) {
            console.error('Error testing API key:', error);
            return { valid: false, error: error.message };
        }
    }
}

// Export for use in other files
if (typeof module !== 'undefined' && module.exports) {
    module.exports = ApiService;
}