/**
 * Data Processor Module
 * Handles parsing and processing of CSV data for health metrics and workouts
 */

class DataProcessor {
    constructor() {
        this.metricsData = null;
        this.workoutsData = null;
    }

    /**
     * Parse CSV string into array of objects
     * @param {string} csvString - Raw CSV data as string
     * @returns {Array} - Array of objects with headers as keys
     */
    parseCSV(csvString) {
        // Split the CSV string into lines
        const lines = csvString.split('\n');
        
        // Extract headers (first line) and remove quotes and any extra characters
        const headers = lines[0].split(',').map(header => {
            // Clean up header - remove quotes, carriage returns, etc.
            return header.replace(/^"(.*)"$/, '$1').replace(/\r$/, '');
        });
        
        // Process each data line
        const results = [];
        for (let i = 1; i < lines.length; i++) {
            // Skip empty lines
            if (!lines[i].trim()) continue;
            
            // Split the line into values, handling quoted values with commas
            const values = this.splitCSVLine(lines[i]);
            
            // Create an object with headers as keys and values
            const entry = {};
            headers.forEach((header, index) => {
                // Remove quotes if present and convert to appropriate type
                let value = values[index] ? values[index].replace(/^"(.*)"$/, '$1').replace(/\r$/, '') : '';
                
                // Try to convert to number if it looks like one
                if (!isNaN(value) && value.trim() !== '') {
                    value = parseFloat(value);
                }
                
                entry[header] = value;
            });
            
            results.push(entry);
        }
        
        return results;
    }
    
    /**
     * Split CSV line handling quoted values with commas
     * @param {string} line - CSV line to split
     * @returns {Array} - Array of values
     */
    splitCSVLine(line) {
        const values = [];
        let inQuotes = false;
        let currentValue = '';
        
        for (let i = 0; i < line.length; i++) {
            const char = line[i];
            
            if (char === '"') {
                inQuotes = !inQuotes;
            } else if (char === ',' && !inQuotes) {
                values.push(currentValue);
                currentValue = '';
            } else {
                currentValue += char;
            }
        }
        
        // Add the last value
        values.push(currentValue);
        
        return values;
    }

    /**
     * Process metrics data from CSV
     * @param {string} csvString - Raw CSV data as string
     * @returns {Object} - Processed metrics data
     */
    processMetricsData(csvString) {
        const rawData = this.parseCSV(csvString);
        
        // Log the first few entries to verify structure
        console.log('First few entries from metrics CSV:', rawData.slice(0, 5));
        
        // Group metrics by date
        const metricsByDate = {};
        
        rawData.forEach(entry => {
            // Extract date from timestamp (format: "2025-04-14 00:00:00")
            const date = entry.Timestamp.split(' ')[0];
            
            if (!metricsByDate[date]) {
                metricsByDate[date] = {};
            }
            
            // Add metric to the date group
            // Ensure Type is trimmed to handle any extra spaces
            const metricType = entry.Type.trim();
            
            // Get the value from the correct column (might be '"Value"' instead of 'Value')
            let metricValue = null;
            if (entry.Value !== undefined) {
                metricValue = entry.Value;
            } else if (entry['"Value"'] !== undefined) {
                metricValue = entry['"Value"'];
            }
            
            // Convert Value to number if it's numeric
            if (metricValue !== null && !isNaN(metricValue) && metricValue.toString().trim() !== '') {
                metricValue = parseFloat(metricValue);
            }
            
            metricsByDate[date][metricType] = metricValue;
        });
        
        // Log the metrics by date to verify structure
        console.log('Sample of metrics by date:', Object.keys(metricsByDate).slice(0, 3).map(date => ({
            date,
            metrics: metricsByDate[date]
        })));
        
        // Convert to array and sort by date
        const processedData = Object.keys(metricsByDate).map(date => {
            return {
                date,
                metrics: metricsByDate[date]
            };
        }).sort((a, b) => new Date(a.date) - new Date(b.date));
        
        this.metricsData = processedData;
        return processedData;
    }

    /**
     * Process workouts data from CSV
     * @param {string} csvString - Raw CSV data as string
     * @returns {Array} - Processed workouts data
     */
    processWorkoutsData(csvString) {
        const rawData = this.parseCSV(csvString);
        
        // Process each workout entry
        const processedData = rawData.map(workout => {
            // Convert workout day to date object for easier comparison
            const workoutDate = new Date(workout.WorkoutDay);
            
            return {
                date: workout.WorkoutDay,
                type: workout.WorkoutType,
                title: workout.Title,
                distance: workout.DistanceInMeters,
                duration: workout.TimeTotalInHours,
                heartRate: {
                    average: workout.HeartRateAverage,
                    max: workout.HeartRateMax
                },
                power: {
                    average: workout.PowerAverage,
                    max: workout.PowerMax
                },
                energy: workout.Energy,
                zones: {
                    heartRate: this.extractHeartRateZones(workout),
                    power: this.extractPowerZones(workout)
                },
                rpe: workout.Rpe,
                feeling: workout.Feeling,
                cadence: {
                    average: workout.CadenceAverage,
                    max: workout.CadenceMax
                },
                velocity: {
                    average: workout.VelocityAverage,
                    max: workout.VelocityMax
                },
                comments: {
                    athlete: workout.AthleteComments,
                    coach: workout.CoachComments
                }
            };
        }).sort((a, b) => new Date(a.date) - new Date(b.date));
        
        this.workoutsData = processedData;
        return processedData;
    }

    /**
     * Extract heart rate zone data from workout entry
     * @param {Object} workout - Workout data entry
     * @returns {Array} - Heart rate zone minutes
     */
    extractHeartRateZones(workout) {
        const zones = [];
        for (let i = 1; i <= 10; i++) {
            const zoneKey = `HRZone${i}Minutes`;
            if (workout[zoneKey] !== undefined && workout[zoneKey] !== '') {
                zones.push({
                    zone: i,
                    minutes: parseFloat(workout[zoneKey])
                });
            }
        }
        return zones;
    }

    /**
     * Extract power zone data from workout entry
     * @param {Object} workout - Workout data entry
     * @returns {Array} - Power zone minutes
     */
    extractPowerZones(workout) {
        const zones = [];
        for (let i = 1; i <= 10; i++) {
            const zoneKey = `PWRZone${i}Minutes`;
            if (workout[zoneKey] !== undefined && workout[zoneKey] !== '') {
                zones.push({
                    zone: i,
                    minutes: parseFloat(workout[zoneKey])
                });
            }
        }
        return zones;
    }

    /**
     * Load sample data from files
     * @returns {Promise} - Promise resolving when data is loaded
     */
    async loadSampleData() {
        try {
            // Load metrics data using XMLHttpRequest to avoid CORS issues with file:// URLs
            const metricsCSV = await this.loadFileWithXHR(CONFIG.sampleData.metricsPath);
            this.processMetricsData(metricsCSV);
            
            // Load workouts data
            const workoutsCSV = await this.loadFileWithXHR(CONFIG.sampleData.workoutsPath);
            this.processWorkoutsData(workoutsCSV);
            
            return {
                metrics: this.metricsData,
                workouts: this.workoutsData
            };
        } catch (error) {
            console.error('Error loading sample data:', error);
            throw error;
        }
    }
    
    /**
     * Load a file using XMLHttpRequest (works with file:// URLs)
     * @param {string} filePath - Path to the file
     * @returns {Promise<string>} - Promise resolving with file contents
     */
    loadFileWithXHR(filePath) {
        return new Promise((resolve, reject) => {
            const xhr = new XMLHttpRequest();
            xhr.open('GET', filePath, true);
            xhr.responseType = 'text';
            
            xhr.onload = function() {
                if (xhr.status === 200 || (xhr.status === 0 && xhr.responseText)) {
                    resolve(xhr.responseText);
                } else {
                    reject(new Error(`Failed to load file: ${filePath}`));
                }
            };
            
            xhr.onerror = function() {
                reject(new Error(`Network error loading file: ${filePath}`));
            };
            
            xhr.send();
        });
    }

    /**
     * Process file data from file inputs
     * @param {File} metricsFile - Metrics CSV file
     * @param {File} workoutsFile - Workouts CSV file
     * @returns {Promise} - Promise resolving with processed data
     */
    async processFiles(metricsFile, workoutsFile) {
        try {
            // Process metrics file
            const metricsData = await this.readFile(metricsFile);
            this.processMetricsData(metricsData);
            
            // Process workouts file
            const workoutsData = await this.readFile(workoutsFile);
            this.processWorkoutsData(workoutsData);
            
            return {
                metrics: this.metricsData,
                workouts: this.workoutsData
            };
        } catch (error) {
            console.error('Error processing files:', error);
            throw error;
        }
    }

    /**
     * Read file as text
     * @param {File} file - File to read
     * @returns {Promise} - Promise resolving with file contents
     */
    readFile(file) {
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            
            reader.onload = (event) => {
                resolve(event.target.result);
            };
            
            reader.onerror = (error) => {
                reject(error);
            };
            
            reader.readAsText(file);
        });
    }

    /**
     * Prepare data for OpenAI analysis
     * @returns {Object} - Data formatted for analysis
     */
    prepareDataForAnalysis() {
        if (!this.metricsData || !this.workoutsData) {
            throw new Error('Data not loaded. Please load data first.');
        }
        
        return {
            metrics: this.metricsData,
            workouts: this.workoutsData,
            summary: this.generateDataSummary()
        };
    }

    /**
     * Generate summary statistics from the data
     * @returns {Object} - Summary statistics
     */
    generateDataSummary() {
        if (!this.metricsData || !this.workoutsData) {
            return null;
        }
        
        // Log all available metric types from the first few days to help diagnose issues
        console.log('Available metric types in first few days:');
        this.metricsData.slice(0, 3).forEach(day => {
            console.log(`Day ${day.date} metrics:`, Object.keys(day.metrics));
        });
        
        // Find sleep hours data with case-insensitive matching
        const sleepData = [];
        const sleepHoursKey = 'Sleep Hours'; // The expected key
        
        this.metricsData.forEach(day => {
            // Try to find the sleep hours key (case-insensitive)
            let foundSleepHours = false;
            
            // First try the exact key
            if (day.metrics[sleepHoursKey] !== undefined) {
                sleepData.push(parseFloat(day.metrics[sleepHoursKey]));
                foundSleepHours = true;
            } else {
                // If not found, try case-insensitive search
                for (const key in day.metrics) {
                    if (key.toLowerCase() === sleepHoursKey.toLowerCase()) {
                        sleepData.push(parseFloat(day.metrics[key]));
                        foundSleepHours = true;
                        console.log(`Found sleep hours with different case: "${key}"`);
                        break;
                    }
                }
            }
            
            if (!foundSleepHours) {
                console.log(`No sleep hours found for day ${day.date}`);
            }
        });
        
        console.log(`Found ${sleepData.length} days with sleep data out of ${this.metricsData.length} total days`);
        
        const sleepStats = sleepData.length > 0 ? {
            average: this.calculateAverage(sleepData),
            min: Math.min(...sleepData),
            max: Math.max(...sleepData)
        } : null;
        
        console.log('Sleep stats:', sleepStats);
        
        // Calculate stress statistics
        const stressQualifiers = this.metricsData
            .filter(day => day.metrics['Stress Qualifier'] !== undefined)
            .map(day => day.metrics['Stress Qualifier']);
        
        const stressQualifierCounts = {};
        stressQualifiers.forEach(qualifier => {
            stressQualifierCounts[qualifier] = (stressQualifierCounts[qualifier] || 0) + 1;
        });
        
        // Calculate workout statistics
        const workoutDistances = this.workoutsData
            .map(workout => parseFloat(workout.distance));
        
        const workoutStats = workoutDistances.length > 0 ? {
            count: this.workoutsData.length,
            totalDistance: this.calculateSum(workoutDistances),
            averageDistance: this.calculateAverage(workoutDistances),
            averageHeartRate: this.calculateAverage(
                this.workoutsData.map(w => parseFloat(w.heartRate.average))
            )
        } : null;
        
        return {
            dateRange: {
                start: this.metricsData[0]?.date,
                end: this.metricsData[this.metricsData.length - 1]?.date
            },
            sleep: sleepStats,
            stress: {
                qualifiers: stressQualifierCounts
            },
            workouts: workoutStats
        };
    }

    /**
     * Calculate average of array values
     * @param {Array} values - Array of numbers
     * @returns {number} - Average value
     */
    calculateAverage(values) {
        if (!values || values.length === 0) return 0;
        return values.reduce((sum, val) => sum + val, 0) / values.length;
    }

    /**
     * Calculate sum of array values
     * @param {Array} values - Array of numbers
     * @returns {number} - Sum of values
     */
    calculateSum(values) {
        if (!values || values.length === 0) return 0;
        return values.reduce((sum, val) => sum + val, 0);
    }
}

// Create a global instance
const dataProcessor = new DataProcessor();