/**
 * API Service
 * 
 * Centralized API client for backend communication.
 * All API calls go through this service.
 * 
 * IMPORTANT: Frontend ONLY talks to backend.
 * NO direct AI API calls from frontend.
 */

const API_BASE_URL = '/api';

// Token key for localStorage
const TOKEN_KEY = 'ai_interviewer_token';
const USER_KEY = 'ai_interviewer_user';


// ===========================================
// TOKEN MANAGEMENT
// ===========================================

/**
 * Get auth token from storage
 */
export const getToken = () => localStorage.getItem(TOKEN_KEY);

/**
 * Set auth token in storage
 */
export const setToken = (token) => {
    localStorage.setItem(TOKEN_KEY, token);
};

/**
 * Remove auth token from storage
 */
export const removeToken = () => {
    localStorage.removeItem(TOKEN_KEY);
    localStorage.removeItem(USER_KEY);
};

/**
 * Get stored user data
 */
export const getStoredUser = () => {
    const userData = localStorage.getItem(USER_KEY);
    return userData ? JSON.parse(userData) : null;
};

/**
 * Store user data
 */
export const setStoredUser = (user) => {
    localStorage.setItem(USER_KEY, JSON.stringify(user));
};

/**
 * Clear all app-specific cached data (NOT auth tokens)
 * Use this on app reload to ensure fresh state
 */
export const clearSessionData = () => {
    // Clear sessionStorage completely
    sessionStorage.clear();

    // Clear any interview/session related data from localStorage
    // BUT PRESERVE auth tokens (ai_interviewer_token, ai_interviewer_user)
    const keysToRemove = [];
    for (let i = 0; i < localStorage.length; i++) {
        const key = localStorage.key(i);
        
        // CRITICAL: Skip auth keys - never clear these!
        if (key === TOKEN_KEY || key === USER_KEY) {
            continue;
        }
        
        // Also skip theme preference
        if (key === 'ai_interviewer_theme') {
            continue;
        }
        
        // Clear interview/session related cached data
        if (key && (
            key.includes('interview_session') ||
            key.includes('current_interview') ||
            key.includes('ats_') ||
            key.includes('plan_') ||
            key.includes('analytics_cache') ||
            key.includes('resume_cache') ||
            key.includes('evaluation_cache')
        )) {
            keysToRemove.push(key);
        }
    }
    keysToRemove.forEach(key => localStorage.removeItem(key));
};

/**
 * Clear ALL app data including auth (for logout)
 * Preserves only theme preference
 */
export const clearAllAppData = () => {
    // Save theme preference before clearing
    const theme = localStorage.getItem('ai_interviewer_theme');

    // Clear everything
    localStorage.clear();
    sessionStorage.clear();

    // Restore theme preference
    if (theme) {
        localStorage.setItem('ai_interviewer_theme', theme);
    }
};

/**
 * Check if user is authenticated
 */
export const isAuthenticated = () => !!getToken();


// ===========================================
// HTTP REQUEST HELPER
// ===========================================

// Flag to track if we've already detected a connection error
// This prevents retry spam on ECONNREFUSED
let connectionErrorDetected = false;

/**
 * Reset connection error flag (call when app starts fresh)
 */
export const resetConnectionState = () => {
    connectionErrorDetected = false;
};

/**
 * Check if backend is reachable
 */
export const checkBackendHealth = async () => {
    try {
        const response = await fetch(`${API_BASE_URL}/health`, {
            method: 'GET',
            headers: { 'Content-Type': 'application/json' },
        });

        if (response.ok) {
            connectionErrorDetected = false;
            return true;
        }
        return false;
    } catch {
        return false;
    }
};

/**
 * Make authenticated API request
 * SAFETY: Handles ECONNREFUSED gracefully, no retry spam
 */
async function request(endpoint, options = {}) {
    // If we've already detected a connection error, don't spam requests
    if (connectionErrorDetected && endpoint !== '/health') {
        throw new Error('Backend is unreachable. Please ensure the server is running.');
    }

    const token = getToken();

    const headers = {
        'Content-Type': 'application/json',
        ...(token && { Authorization: `Bearer ${token}` }),
        ...options.headers,
    };

    try {
        const response = await fetch(`${API_BASE_URL}${endpoint}`, {
            ...options,
            headers,
        });

        // Connection succeeded, reset error flag
        connectionErrorDetected = false;

        // Handle 401 - Unauthorized
        if (response.status === 401) {
            removeToken();
            window.location.href = '/login';
            throw new Error('Session expired. Please login again.');
        }

        // Parse response
        const data = await response.json().catch(() => ({}));

        if (!response.ok) {
            throw new Error(data.detail || data.message || `Request failed: ${response.status}`);
        }

        return data;
    } catch (error) {
        // Check for connection errors (ECONNREFUSED, network failure, etc.)
        const isConnectionError =
            error.message === 'Failed to fetch' ||
            error.message.includes('NetworkError') ||
            error.message.includes('ECONNREFUSED') ||
            error.name === 'TypeError' && !error.message.includes('401');

        if (isConnectionError) {
            // Mark connection as failed to prevent retry spam
            connectionErrorDetected = true;

            // DON'T clear auth state on connection errors - the server might just be temporarily down
            // The user's token might still be valid
            // removeToken();  // REMOVED - was causing logout on refresh

            // Don't redirect to login on connection error - show error instead
            // if (window.location.pathname !== '/login') {
            //     console.error('[API] Backend unreachable - redirecting to login');
            //     window.location.href = '/login';
            // }

            throw new Error('Unable to connect to server. Please check if the backend is running.');
        }

        // For auth-related errors, don't retry
        if (error.message.includes('Session expired')) {
            throw error;
        }

        throw error;
    }
}


// ===========================================
// AUTH API
// ===========================================

export const authApi = {
    /**
     * User signup
     */
    async signup(name, email, password) {
        const response = await request('/auth/signup', {
            method: 'POST',
            body: JSON.stringify({ name, email, password }),
        });

        if (response.success && response.token) {
            setToken(response.token.access_token);
            setStoredUser(response.user);
        }

        return response;
    },

    /**
     * User login
     */
    async login(email, password) {
        const response = await request('/auth/login', {
            method: 'POST',
            body: JSON.stringify({ email, password }),
        });

        if (response.success && response.token) {
            setToken(response.token.access_token);
            setStoredUser(response.user);
        }

        return response;
    },

    /**
     * User logout
     */
    async logout() {
        try {
            await request('/auth/logout', { method: 'POST' });
        } catch (error) {
            // Continue with local logout even if server fails
            console.warn('Logout API call failed:', error);
        } finally {
            removeToken();
        }
    },

    /**
     * Get current user
     */
    async getCurrentUser() {
        return request('/auth/me');
    },

    /**
     * Verify token is valid
     * SAFETY: Only calls backend if token exists in localStorage
     * Returns: true (valid), false (invalid), or throws on connection error
     */
    async verifyToken() {
        // Check if token exists BEFORE making any API call
        const token = getToken();
        if (!token) {
            console.log('[Auth] No token in storage, skipping verify-token call');
            return false;
        }

        try {
            await request('/auth/verify-token', { method: 'POST' });
            return true;
        } catch (error) {
            // Check if this is a connection error vs actual auth failure
            const isConnectionError =
                error.message.includes('Unable to connect') ||
                error.message.includes('Backend is unreachable') ||
                error.message.includes('Failed to fetch') ||
                error.message.includes('NetworkError');
            
            if (isConnectionError) {
                // Re-throw connection errors so AuthContext can handle them differently
                console.warn('[Auth] Connection error during token verification');
                throw error;
            }
            
            // Actual auth failure (401, invalid token, etc.)
            console.warn('[Auth] Token verification failed:', error.message);
            return false;
        }
    },
};


// ===========================================
// USER API
// ===========================================

export const userApi = {
    /**
     * Get user profile
     */
    async getProfile() {
        return request('/users/profile');
    },

    /**
     * Update user profile
     */
    async updateProfile(data) {
        const params = new URLSearchParams();
        if (data.name) params.append('name', data.name);

        return request(`/users/profile?${params.toString()}`, {
            method: 'PUT',
        });
    },

    /**
     * Get user analytics
     */
    async getAnalytics() {
        return request('/users/analytics');
    },

    /**
     * Get interview history
     */
    async getHistory(limit = 10, offset = 0) {
        return request(`/users/history?limit=${limit}&offset=${offset}`);
    },

    /**
     * Get user resumes
     */
    async getResumes() {
        return request('/resumes/me');
    },
};


// ===========================================
// BRANCH & ROLE CONFIG API
// ===========================================

export const branchApi = {
    /**
     * Get all engineering branches
     * Returns 6 branches: CSE, ECE, EEE, Mechanical, Civil, Architecture
     */
    async getAllBranches() {
        return request('/interviews/branches');
    },

    /**
     * Get all roles within a specific branch
     * @param {string} branchId - Branch ID (e.g., 'computer_science', 'mechanical')
     */
    async getBranchRoles(branchId) {
        return request(`/interviews/branches/${branchId}/roles`);
    },

    /**
     * Get detailed configuration for a specific role
     * Returns interview rounds, topics, and duration
     * @param {string} branchId - Branch ID
     * @param {string} roleId - Role ID within the branch
     */
    async getRoleConfig(branchId, roleId) {
        return request(`/interviews/branches/${branchId}/roles/${roleId}`);
    },

    /**
     * Get interview questions for a specific role
     * @param {string} branchId - Branch ID
     * @param {string} roleId - Role ID
     */
    async getRoleQuestions(branchId, roleId) {
        return request(`/interviews/branches/${branchId}/roles/${roleId}/questions`);
    },
};


// ===========================================
// INTERVIEW API
// ===========================================

export const interviewApi = {
    /**
     * Create interview session
     */
    async createSession(config) {
        const params = new URLSearchParams();
        if (config.sessionType) params.append('session_type', config.sessionType);
        if (config.difficulty) params.append('difficulty', config.difficulty);
        if (config.questionCount) params.append('question_count', config.questionCount);
        if (config.resumeId) params.append('resume_id', config.resumeId);
        if (config.jobRoleId) params.append('job_role_id', config.jobRoleId);

        return request(`/interviews/sessions?${params.toString()}`, {
            method: 'POST',
        });
    },

    /**
     * Get session details
     */
    async getSession(sessionId) {
        return request(`/interviews/sessions/${sessionId}`);
    },

    /**
     * Start question planning
     */
    async startPlanning(sessionId) {
        return request(`/interviews/sessions/${sessionId}/plan`, {
            method: 'POST',
        });
    },

    /**
     * Start interview
     */
    async startInterview(sessionId) {
        return request(`/interviews/sessions/${sessionId}/start`, {
            method: 'POST',
        });
    },

    /**
     * Get current question
     */
    async getCurrentQuestion(sessionId) {
        return request(`/interviews/sessions/${sessionId}/question`);
    },

    /**
     * Submit answer
     */
    async submitAnswer(sessionId, questionId, answerText, responseTimeSeconds) {
        const params = new URLSearchParams();
        params.append('question_id', questionId);
        params.append('answer_text', answerText);
        params.append('response_time_seconds', responseTimeSeconds);

        return request(`/interviews/sessions/${sessionId}/answer?${params.toString()}`, {
            method: 'POST',
        });
    },

    /**
     * Pause interview
     */
    async pauseInterview(sessionId) {
        return request(`/interviews/sessions/${sessionId}/pause`, {
            method: 'POST',
        });
    },

    /**
     * Resume interview
     */
    async resumeInterview(sessionId) {
        return request(`/interviews/sessions/${sessionId}/resume`, {
            method: 'POST',
        });
    },

    /**
     * End interview
     */
    async endInterview(sessionId) {
        return request(`/interviews/sessions/${sessionId}/end`, {
            method: 'POST',
        });
    },

    /**
     * Get session results
     */
    async getResults(sessionId) {
        return request(`/interviews/sessions/${sessionId}/results`);
    },

    /**
     * Get available job roles
     */
    async getJobRoles() {
        return request('/interviews/roles');
    },
};


// ===========================================
// RESUME API
// ===========================================

export const resumeApi = {
    /**
     * Upload a resume file
     * @param {File} file - The resume file (PDF or DOCX)
     */
    async upload(file) {
        const token = getToken();
        if (!token) {
            removeToken();
            window.location.href = '/login';
            throw new Error('Authentication required. Please login first.');
        }
        const formData = new FormData();
        formData.append('file', file);

        const response = await fetch(`${API_BASE_URL}/resumes/upload`, {
            method: 'POST',
            headers: {
                ...(token && { Authorization: `Bearer ${token}` }),
            },
            body: formData,
        });

        // Handle 401 - Unauthorized
        if (response.status === 401) {
            removeToken();
            window.location.href = '/login';
            throw new Error('Session expired. Please login again.');
        }

        const data = await response.json().catch(() => ({}));

        if (!response.ok) {
            throw new Error(data.detail || data.message || 'Failed to upload resume');
        }

        return data;
    },

    /**
     * Get all resumes for current user
     */
    async getAll() {
        return request('/resumes/me');
    },

    /**
     * Get a specific resume by ID
     */
    async getById(resumeId) {
        return request(`/resumes/${resumeId}`);
    },

    /**
     * Delete a resume
     */
    async delete(resumeId) {
        return request(`/resumes/${resumeId}`, {
            method: 'DELETE',
        });
    },

    /**
     * Validate user-selected domain against resume classification
     * MANDATORY: Must be called before starting interview/prep
     * @param {string} resumeId - Resume ID to validate
     * @param {string} selectedBranch - User-selected branch (e.g., 'computer_science')
     * @param {string} selectedRole - User-selected role (e.g., 'software_engineer')
     */
    async validateDomain(resumeId, selectedBranch, selectedRole) {
        return request('/resumes/validate-domain', {
            method: 'POST',
            body: JSON.stringify({
                resume_id: resumeId,
                selected_branch: selectedBranch,
                selected_role: selectedRole,
            }),
        });
    },

    /**
     * Confirm domain selection despite mismatch
     * For advanced users who want to override the warning
     * @param {string} resumeId - Resume ID
     * @param {string} selectedBranch - User-selected branch
     * @param {string} selectedRole - User-selected role
     */
    async confirmDomain(resumeId, selectedBranch, selectedRole) {
        return request('/resumes/confirm-domain', {
            method: 'POST',
            body: JSON.stringify({
                resume_id: resumeId,
                selected_branch: selectedBranch,
                selected_role: selectedRole,
                user_confirmed: true,
            }),
        });
    },

    /**
     * Get domain classification for a resume
     * @param {string} resumeId - Resume ID
     */
    async getClassification(resumeId) {
        return request(`/resumes/${resumeId}/classification`);
    },
};


// ===========================================
// ATS API
// ===========================================

export const atsApi = {
    /**
     * Analyze resume for ATS compatibility
     * @param {string} resumeId - Resume ID to analyze
     * @param {string} targetRole - Target job role
     * @param {string} [targetDescription] - Optional job description
     */
    async analyze(resumeId, targetRole, targetDescription = null) {
        return request(`/ats/analyze/${resumeId}`, {
            method: 'POST',
            body: JSON.stringify({
                target_role: targetRole,
                target_role_description: targetDescription,
            }),
        });
    },

    /**
     * Get ATS analysis result by ID
     */
    async getResult(analysisId) {
        return request(`/ats/result/${analysisId}`);
    },

    /**
     * Get latest ATS analysis for a resume
     */
    async getResumeAnalysis(resumeId) {
        return request(`/ats/resume/${resumeId}`);
    },

    /**
     * Get user's ATS analysis history
     */
    async getHistory(limit = 10) {
        return request(`/ats/history?limit=${limit}`);
    },

    /**
     * Get ATS API status (OpenAI configured or mock mode)
     */
    async getStatus() {
        return request('/ats/status');
    },
};


// ===========================================
// INTERVIEW PLAN API
// ===========================================

export const planApi = {
    /**
     * Generate interview plan for a resume
     * @param {string} resumeId - Resume ID
     * @param {string} targetRole - Target job role
     * @param {object} options - Optional settings including roundConfig
     */
    async generate(resumeId, targetRole, options = {}) {
        return request(`/interviews/plan/${resumeId}`, {
            method: 'POST',
            body: JSON.stringify({
                target_role: targetRole,
                target_role_description: options.targetDescription || null,
                session_type: options.sessionType || 'mixed',
                difficulty_level: options.difficultyLevel || 'medium',
                question_count: options.questionCount || 10,
                company_mode: options.companyMode || null,
                // NEW: 4-mode architecture
                interview_mode: options.interviewMode || null,
                personality: options.personality || null,
                // CRITICAL: Pass per-round question configuration
                round_config: options.roundConfig || null,
            }),
        });
    },

    /**
     * Get plan by ID
     */
    async getById(planId) {
        return request(`/interviews/plan/${planId}`);
    },

    /**
     * Get latest plan for a resume
     */
    async getByResume(resumeId) {
        return request(`/interviews/plans/resume/${resumeId}`);
    },

    /**
     * Get all user's plans
     */
    async getAll(limit = 10) {
        return request(`/interviews/plans/me?limit=${limit}`);
    },

    /**
     * Get questions from a plan
     */
    async getQuestions(planId) {
        return request(`/interviews/plan/${planId}/questions`);
    },
};


// ===========================================
// INTERVIEW FLOW API (NEW - MANDATORY FLOW CONTROL)
// ===========================================

export const interviewFlowApi = {
    /**
     * Start the complete interview preparation flow
     * MANDATORY: Executes all validation steps before plan can be generated
     * 
     * Steps executed:
     * 1. Resume parsing check
     * 2. Domain classification
     * 3. Internet grounding (fetches live interview data)
     * 4. Domain validation
     * 
     * @param {string} resumeId - Resume ID
     * @param {string} selectedBranch - User-selected branch
     * @param {string} selectedRole - User-selected role
     */
    async startFlow(resumeId, selectedBranch, selectedRole) {
        return request('/interviews/flow/start', {
            method: 'POST',
            body: JSON.stringify({
                resume_id: resumeId,
                selected_branch: selectedBranch,
                selected_role: selectedRole,
            }),
        });
    },

    /**
     * Confirm domain selection despite mismatch
     * For advanced users who want to override the warning
     */
    async confirmDomain(resumeId, selectedBranch, selectedRole) {
        return request('/interviews/flow/confirm-domain', {
            method: 'POST',
            body: JSON.stringify({
                resume_id: resumeId,
                selected_branch: selectedBranch,
                selected_role: selectedRole,
            }),
        });
    },

    /**
     * Fetch internet grounding for a domain
     * Returns current (2024-2026) interview data
     */
    async fetchGrounding(domain, role, detectedSkills = []) {
        return request('/interviews/grounding/fetch', {
            method: 'POST',
            body: JSON.stringify({
                domain: domain,
                role: role,
                detected_skills: detectedSkills,
            }),
        });
    },

    /**
     * Get grounding service status
     */
    async getGroundingStatus() {
        return request('/interviews/grounding/status');
    },

    /**
     * Get flow requirements
     */
    async getRequirements() {
        return request('/interviews/flow/requirements');
    },
};


// ===========================================
// USER MEMORY & INSIGHTS API
// ===========================================

export const memoryApi = {
    /**
     * Get intelligent dashboard comment
     * Analyzes user's interview history and generates actionable insight
     * 
     * @param {string} mode - Interview mode for tone (friendly, balanced, strict, final_boss)
     */
    async getDashboardComment(mode = 'balanced') {
        return request(`/memory/dashboard-comment?mode=${mode}`);
    },

    /**
     * Get profile defining quote
     * One sentence that defines the user's interview personality
     */
    async getProfileQuote() {
        return request('/memory/profile-quote');
    },

    /**
     * Get full insight summary
     * Complete insight including performance, behavior, and recommendations
     */
    async getInsightSummary() {
        return request('/memory/insight-summary');
    },

    /**
     * Get performance history
     * @param {number} limit - Number of records to fetch
     */
    async getPerformanceHistory(limit = 10) {
        return request(`/memory/performance-history?limit=${limit}`);
    },

    /**
     * Record performance after interview completion
     * @param {Object} data - Performance data
     */
    async recordPerformance(data) {
        return request('/memory/record-performance', {
            method: 'POST',
            body: JSON.stringify(data),
        });
    },

    /**
     * Get behavior history (video-based analysis)
     * @param {number} limit - Number of records to fetch
     */
    async getBehaviorHistory(limit = 10) {
        return request(`/memory/behavior-history?limit=${limit}`);
    },

    /**
     * Get confidence timeline graph data for an interview
     * ONLY available for interviews with video (Balanced, Strict, Final Boss modes)
     * 
     * @param {string} interviewId - Interview ID
     */
    async getConfidenceGraph(interviewId) {
        return request(`/memory/confidence-graph/${interviewId}`);
    },

    /**
     * Trigger video analysis for an interview
     * @param {string} interviewId - Interview ID
     * @param {number} durationSeconds - Video duration in seconds
     */
    async analyzeVideo(interviewId, durationSeconds = 600) {
        return request(`/memory/analyze-video/${interviewId}?video_duration_seconds=${durationSeconds}`, {
            method: 'POST',
        });
    },

    /**
     * Get consistency metrics
     * Interview seriousness and commitment tracking
     */
    async getConsistency() {
        return request('/memory/consistency');
    },

    /**
     * Record interview start for consistency tracking
     */
    async recordInterviewStart() {
        return request('/memory/consistency/interview-start', {
            method: 'POST',
        });
    },

    /**
     * Record interview completion for consistency tracking
     * @param {number} questionsAsked - Total questions asked
     * @param {number} questionsAnswered - Questions answered
     * @param {number} questionsSkipped - Questions skipped
     */
    async recordInterviewComplete(questionsAsked, questionsAnswered, questionsSkipped) {
        return request(`/memory/consistency/interview-complete?questions_asked=${questionsAsked}&questions_answered=${questionsAnswered}&questions_skipped=${questionsSkipped}`, {
            method: 'POST',
        });
    },
};


// ===========================================
// LIVE INTERVIEW API
// ===========================================

export const liveInterviewApi = {
    /**
     * Start a live interview session
     * @param {string} planId - Interview plan ID
     * @param {string} persona - Interviewer persona (professional, friendly, stress)
     */
    async start(planId, persona = 'professional') {
        return request('/interviews/live/start', {
            method: 'POST',
            body: JSON.stringify({
                plan_id: planId,
                persona: persona,
            }),
        });
    },

    /**
     * Get session state (for resuming after refresh)
     */
    async getState(sessionId) {
        return request(`/interviews/live/${sessionId}/state`);
    },

    /**
     * Submit an answer
     */
    async submitAnswer(sessionId, answerText, responseTimeSeconds = null) {
        return request(`/interviews/live/${sessionId}/answer`, {
            method: 'POST',
            body: JSON.stringify({
                answer_text: answerText,
                response_time_seconds: responseTimeSeconds,
            }),
        });
    },

    /**
     * Skip current question
     */
    async skip(sessionId) {
        return request(`/interviews/live/${sessionId}/skip`, {
            method: 'POST',
        });
    },

    /**
     * Pause interview
     */
    async pause(sessionId) {
        return request(`/interviews/live/${sessionId}/pause`, {
            method: 'POST',
        });
    },

    /**
     * Resume interview
     */
    async resume(sessionId) {
        return request(`/interviews/live/${sessionId}/resume`, {
            method: 'POST',
        });
    },

    /**
     * End interview early
     */
    async end(sessionId) {
        return request(`/interviews/live/${sessionId}/end`, {
            method: 'POST',
        });
    },

    /**
     * Confirm user consent to start interview
     * Called after user says "yes" to the greeting
     */
    async confirmConsent(sessionId) {
        return request(`/interviews/live/${sessionId}/consent`, {
            method: 'POST',
        });
    },

    /**
     * Process a message through the Interview Brain
     * 
     * This is the recommended endpoint for conversational interviews.
     * It handles:
     * - Off-topic detection and redirection
     * - Repeat/clarify requests
     * - Pause/skip commands
     * - Answer evaluation
     * 
     * @param {string} sessionId - Interview session ID
     * @param {string} messageText - User's message
     * @returns {Promise<Object>} Response with:
     *   - response: Interviewer's response text
     *   - intent: Detected intent (answer, off_topic, repeat, skip, pause)
     *   - next_action: Next action (continue, next_question, repeated, redirected, paused, completed)
     *   - next_question: Next question object (if advancing)
     *   - progress: Updated progress
     */
    async processMessage(sessionId, messageText) {
        return request(`/interviews/live/${sessionId}/message`, {
            method: 'POST',
            body: JSON.stringify({
                message_text: messageText,
            }),
        });
    },

    /**
     * Get API status
     */
    async getStatus() {
        return request('/interviews/live/status');
    },
};


// ===========================================
// EVALUATION API
// ===========================================

export const evaluationApi = {
    /**
     * Quick evaluation (OpenAI) - Layer 1
     */
    async quick(sessionId, questionId, questionText, answerText, questionType = null) {
        return request('/evaluations/quick', {
            method: 'POST',
            body: JSON.stringify({
                session_id: sessionId,
                question_id: questionId,
                question_text: questionText,
                answer_text: answerText,
                question_type: questionType,
            }),
        });
    },

    /**
     * Deep evaluation (OpenAI) - Layer 2
     */
    async deep(sessionId, questionId, questionText, answerText, options = {}) {
        return request('/evaluations/deep', {
            method: 'POST',
            body: JSON.stringify({
                session_id: sessionId,
                question_id: questionId,
                question_text: questionText,
                answer_text: answerText,
                question_type: options.questionType,
                resume_context: options.resumeContext,
                expected_topics: options.expectedTopics,
            }),
        });
    },

    /**
     * Batch deep evaluation for session
     */
    async batch(sessionId) {
        return request('/evaluations/batch', {
            method: 'POST',
            body: JSON.stringify({
                session_id: sessionId,
            }),
        });
    },

    /**
     * Get session evaluations
     */
    async getSession(sessionId) {
        return request(`/evaluations/${sessionId}`);
    },

    /**
     * Get single evaluation
     */
    async getSingle(evaluationId) {
        return request(`/evaluations/single/${evaluationId}`);
    },

    /**
     * Finalize session evaluations
     */
    async finalize(sessionId) {
        return request(`/evaluations/finalize/${sessionId}`, {
            method: 'POST',
        });
    },

    /**
     * Get evaluation API status
     */
    async getStatus() {
        return request('/evaluations/status');
    },
};


// ===========================================
// SIMULATION API (Behavioral Insights)
// ===========================================

export const simulationApi = {
    /**
     * Analyze answer for behavioral patterns
     * Text-based inference only
     */
    async analyze(sessionId, questionId, answerText, options = {}) {
        return request('/simulation/analyze', {
            method: 'POST',
            body: JSON.stringify({
                session_id: sessionId,
                question_id: questionId,
                answer_text: answerText,
                question_text: options.questionText,
                question_type: options.questionType,
                response_time_seconds: options.responseTime,
                evaluation_id: options.evaluationId,
            }),
        });
    },

    /**
     * Generate session behavioral summary
     */
    async generateSummary(sessionId) {
        return request('/simulation/session/summary', {
            method: 'POST',
            body: JSON.stringify({
                session_id: sessionId,
            }),
        });
    },

    /**
     * Get session behavioral insights
     */
    async getSession(sessionId) {
        return request(`/simulation/session/${sessionId}`);
    },

    /**
     * Get single insight
     */
    async getInsight(insightId) {
        return request(`/simulation/insight/${insightId}`);
    },

    /**
     * Get disclaimer
     */
    async getDisclaimer() {
        return request('/simulation/disclaimer');
    },
};


// ===========================================
// REPORT API
// ===========================================

export const reportApi = {
    /**
     * Generate interview report
     */
    async generate(sessionId, options = {}) {
        return request(`/reports/generate/${sessionId}`, {
            method: 'POST',
            body: JSON.stringify({
                include_behavioral: options.includeBehavioral ?? true,
                include_skills: options.includeSkills ?? true,
            }),
        });
    },

    /**
     * Get interview report
     */
    async get(sessionId) {
        return request(`/reports/${sessionId}`);
    },

    /**
     * List user reports
     */
    async list(limit = 10) {
        return request(`/reports/?limit=${limit}`);
    },
};


// ===========================================
// ROADMAP API
// ===========================================

export const roadmapApi = {
    /**
     * Generate career roadmap for session
     */
    async generate(sessionId, options = {}) {
        return request(`/roadmap/generate/${sessionId}`, {
            method: 'POST',
            body: JSON.stringify({
                target_role: options.targetRole,
                current_level: options.currentLevel,
                target_level: options.targetLevel,
                focus_areas: options.focusAreas,
            }),
        });
    },

    /**
     * Generate standalone roadmap
     */
    async generateStandalone(options = {}) {
        return request('/roadmap/generate', {
            method: 'POST',
            body: JSON.stringify({
                target_role: options.targetRole || 'Software Developer',
                current_level: options.currentLevel,
                target_level: options.targetLevel,
                focus_areas: options.focusAreas,
            }),
        });
    },

    /**
     * Get roadmap for session
     */
    async get(sessionId) {
        return request(`/roadmap/${sessionId}`);
    },

    /**
     * List user roadmaps
     */
    async list(limit = 10) {
        return request(`/roadmap/?limit=${limit}`);
    },
};


// ===========================================
// COMPANY MODES API
// ===========================================

export const companyApi = {
    /**
     * Get all company modes
     */
    async getModes() {
        return request('/companies/modes');
    },

    /**
     * Get specific company mode
     */
    async getMode(modeId) {
        return request(`/companies/modes/${modeId}`);
    },
};


// ===========================================
// PERSONALITY MODES API
// ===========================================

export const personalityApi = {
    /**
     * Get all personality modes
     */
    async getAll() {
        return request('/personalities/');
    },

    /**
     * Get specific personality mode
     */
    async getById(personalityId) {
        return request(`/personalities/${personalityId}`);
    },
};


// ===========================================
// ANALYTICS API
// ===========================================

export const analyticsApi = {
    /**
     * Get full dashboard data
     */
    async getDashboard(days = 30) {
        return request(`/analytics/dashboard?days=${days}`);
    },

    /**
     * Get overview statistics
     */
    async getOverview(days = 30) {
        return request(`/analytics/overview?days=${days}`);
    },

    /**
     * Get skill performance
     */
    async getSkills() {
        return request('/analytics/skills');
    },

    /**
     * Get progress over time
     */
    async getProgress(days = 90, interval = 'week') {
        return request(`/analytics/progress?days=${days}&interval=${interval}`);
    },

    /**
     * Get question type breakdown
     */
    async getQuestionTypes() {
        return request('/analytics/question-types');
    },

    /**
     * Get recent interviews
     */
    async getRecent(limit = 5) {
        return request(`/analytics/recent?limit=${limit}`);
    },
};


// ===========================================
// VISION API (Confidence Graph & Video Analysis)
// ===========================================

export const visionApi = {
    /**
     * Get confidence graph data for an interview
     * Returns time-series confidence data for rendering a graph
     * 
     * @param {string} interviewId - Interview ID
     */
    async getConfidenceGraph(interviewId) {
        return request(`/vision/interviews/${interviewId}/confidence-graph`);
    },

    /**
     * Submit real-time confidence data during interview
     * Called periodically to store eye contact and confidence metrics
     * 
     * @param {string} interviewId - Interview ID
     * @param {Array} dataPoints - Array of {timestamp, confidence, eye_contact, face_detected, gaze_direction}
     * @param {string} interviewMode - 'strict' or 'final_boss'
     */
    async submitConfidenceData(interviewId, dataPoints, interviewMode = 'strict') {
        return request(`/vision/interviews/${interviewId}/confidence-data`, {
            method: 'POST',
            body: JSON.stringify({
                interview_id: interviewId,
                data_points: dataPoints,
                interview_mode: interviewMode,
            }),
        });
    },

    /**
     * Finalize confidence data after interview ends
     * Computes summary statistics and caches graph data
     * 
     * @param {string} interviewId - Interview ID
     */
    async finalizeConfidenceData(interviewId) {
        return request(`/vision/interviews/${interviewId}/finalize-confidence`, {
            method: 'POST',
        });
    },

    /**
     * Get detailed per-second confidence metrics
     * More detailed than graph data, includes all detection info
     * 
     * @param {string} interviewId - Interview ID
     */
    async getConfidenceMetrics(interviewId) {
        return request(`/vision/interviews/${interviewId}/confidence-metrics`);
    },

    /**
     * Get confidence analysis summary
     * 
     * @param {string} interviewId - Interview ID
     */
    async getConfidenceSummary(interviewId) {
        return request(`/vision/interviews/${interviewId}/confidence-summary`);
    },

    /**
     * Trigger video analysis for an interview (background processing)
     * 
     * @param {string} interviewId - Interview ID
     * @param {string} videoPath - Optional video path override
     * @param {boolean} force - Force reprocessing
     */
    async analyzeVideo(interviewId, videoPath = null, force = false) {
        const params = new URLSearchParams();
        if (videoPath) params.append('video_path', videoPath);
        if (force) params.append('force', 'true');

        return request(`/vision/interviews/${interviewId}/analyze-video?${params.toString()}`, {
            method: 'POST',
        });
    },

    /**
     * Get user's confidence history across all interviews
     * 
     * @param {string} userId - User ID
     * @param {number} limit - Number of records
     */
    async getConfidenceHistory(userId, limit = 10) {
        return request(`/vision/users/${userId}/confidence-history?limit=${limit}`);
    },
};


// ===========================================
// IDENTITY API (Profile Quotes & Career Identity)
// ===========================================

export const identityApi = {
    /**
     * Get user's full profile identity
     * Returns complete identity including quote, domain scores, trend
     * 
     * @param {string} userId - User ID
     */
    async getProfileIdentity(userId) {
        return request(`/identity/users/${userId}/profile`);
    },

    /**
     * Get user's profile quote (minimal)
     * 
     * @param {string} userId - User ID
     */
    async getQuote(userId) {
        return request(`/identity/users/${userId}/quote`);
    },

    /**
     * Get user's quote history
     * Shows evolution of profile identity over time
     * 
     * @param {string} userId - User ID
     * @param {number} limit - Number of records
     */
    async getQuoteHistory(userId, limit = 10) {
        return request(`/identity/users/${userId}/quote-history?limit=${limit}`);
    },

    /**
     * Manually refresh user's identity (trigger recomputation)
     * 
     * @param {string} userId - User ID
     */
    async refreshIdentity(userId) {
        return request(`/identity/users/${userId}/refresh`, {
            method: 'POST',
        });
    },

    /**
     * Generate AI-powered profile quote
     * Creates a personalized quote based on interview performance
     * 
     * @param {string} userId - User ID
     */
    async generateAIQuote(userId) {
        return request(`/identity/users/${userId}/generate-ai-quote`, {
            method: 'POST',
        });
    },

    /**
     * Get user's domain scores
     * 
     * @param {string} userId - User ID
     */
    async getDomainScores(userId) {
        return request(`/identity/users/${userId}/domain-scores`);
    },
};


// ===========================================
// PROFILE API (User Profile Page)
// ===========================================

export const profileApi = {
    /**
     * Get user profile (same as auth/me)
     */
    async getProfile() {
        return request('/users/profile');
    },

    /**
     * Get interview history
     */
    async getInterviewHistory(limit = 20, offset = 0) {
        return request(`/users/history?limit=${limit}&offset=${offset}`);
    },

    /**
     * Get user statistics
     */
    async getUserStats() {
        try {
            const response = await request('/analytics/overview?days=90');
            // Transform to expected shape
            return {
                success: true,
                stats: {
                    total_interviews: response.total_interviews || 0,
                    completed_interviews: response.completed_interviews || 0,
                    average_score: response.average_score || 0,
                    total_resumes: 0, // Will be filled from resume API
                },
            };
        } catch (error) {
            return {
                success: false,
                stats: {
                    total_interviews: 0,
                    completed_interviews: 0,
                    average_score: 0,
                    total_resumes: 0,
                },
            };
        }
    },

    /**
     * Update user profile
     */
    async updateProfile(data) {
        const params = new URLSearchParams();
        if (data.name) params.append('name', data.name);

        return request(`/users/profile?${params.toString()}`, {
            method: 'PUT',
        });
    },
};


// ===========================================
// COMPILER API - Code Execution for Coding Rounds
// ===========================================

export const compilerApi = {
    /**
     * Get available programming languages
     */
    async getLanguages() {
        return request('/compiler/languages');
    },

    /**
     * Execute code
     * @param {string} code - Source code to execute
     * @param {string} language - Programming language (python, javascript, java, etc.)
     * @param {string} stdin - Optional standard input
     * @param {number} timeout - Execution timeout in seconds (default: 10)
     */
    async execute(code, language, stdin = '', timeout = 10) {
        return request('/compiler/execute', {
            method: 'POST',
            body: JSON.stringify({
                code,
                language,
                stdin: stdin || undefined,
                timeout,
            }),
        });
    },

    /**
     * Test compiler with Hello World
     */
    async test() {
        return request('/compiler/test', { method: 'POST' });
    },
};


// ===========================================
// FINAL BOSS REPORT API
// ===========================================

export const finalBossApi = {
    /**
     * Generate Final Boss Report
     * Returns comprehensive battle plan with weakness heatmap and 14-day war plan
     * @param {string} sessionId - Interview session ID
     * @param {string} candidateName - Optional display name for candidate
     */
    async generate(sessionId, candidateName = null) {
        return request(`/final-boss/generate/${sessionId}`, {
            method: 'POST',
            body: JSON.stringify({
                candidate_name: candidateName,
            }),
        });
    },

    /**
     * Download Final Boss Report as PDF
     * @param {string} sessionId - Interview session ID
     * @param {string} candidateName - Optional display name for candidate
     * @returns {Promise<Blob>} PDF blob for download
     */
    async downloadPdf(sessionId, candidateName = null) {
        const token = getToken();
        const params = candidateName ? `?candidate_name=${encodeURIComponent(candidateName)}` : '';
        
        const response = await fetch(`${API_BASE_URL}/final-boss/pdf/${sessionId}${params}`, {
            method: 'GET',
            headers: {
                'Authorization': token ? `Bearer ${token}` : '',
            },
        });

        if (!response.ok) {
            const error = await response.json().catch(() => ({ message: 'Failed to download PDF' }));
            throw new Error(error.detail || error.message || 'Failed to download PDF');
        }

        return response.blob();
    },

    /**
     * Get Final Boss Report as HTML
     * Useful for client-side rendering or PDF generation
     * @param {string} sessionId - Interview session ID
     * @param {string} candidateName - Optional display name for candidate
     */
    async getHtml(sessionId, candidateName = null) {
        const token = getToken();
        const params = candidateName ? `?candidate_name=${encodeURIComponent(candidateName)}` : '';
        
        const response = await fetch(`${API_BASE_URL}/final-boss/html/${sessionId}${params}`, {
            method: 'GET',
            headers: {
                'Authorization': token ? `Bearer ${token}` : '',
            },
        });

        if (!response.ok) {
            throw new Error('Failed to get HTML report');
        }

        return response.text();
    },
};


// ===========================================
// COMBINED API EXPORT
// ===========================================

export const api = {
    auth: authApi,
    user: userApi,
    interview: interviewApi,
    resume: resumeApi,
    ats: atsApi,
    plan: planApi,
    live: liveInterviewApi,
    evaluation: evaluationApi,
    simulation: simulationApi,
    report: reportApi,
    roadmap: roadmapApi,
    company: companyApi,
    personality: personalityApi,
    analytics: analyticsApi,
    profile: profileApi,
    vision: visionApi,       // Confidence graph & video analysis
    identity: identityApi,   // Profile quotes & career identity
    compiler: compilerApi,   // Code compiler for coding rounds
    finalBoss: finalBossApi, // Final Boss Report - comprehensive PDF battle plan

    // Legacy compatibility
    login: authApi.login,
    signup: authApi.signup,
    logout: authApi.logout,
    getCurrentUser: authApi.getCurrentUser,
};

export default api;