web/src/utils/ecoSpireIntegration.js

/**
 * GreenPlus by GXS Integration Hub
 * Central integration point for all environmental analysis tools
 */

import { testSuite } from './testSuite';
import { performanceOptimizer } from './performanceOptimizer';
import { systemHealthChecker } from './systemHealth';
import { accuracyValidator } from './accuracyValidator';

// Core analysis tools
import { analyzeAudioForSpecies } from './audioAnalysis';
import { analyzeWaterImage } from './imageAnalysis';
import { analyzeAirQuality } from './airQualityAnalysis';
import { calculateCarbonFootprint } from './carbonFootprintTracker';
import { analyzeSoilHealth } from './soilHealthAnalyzer';
import { assessClimateImpact } from './climateImpactAssessment';

// Database utilities
import { waterQualityDB } from './waterQualityDatabase';
import { biodiversityDB } from './biodiversityDatabase';

export class EcoSpireIntegration {
    constructor() {
        this.tools = new Map();
        this.analysisHistory = [];
        this.performanceMetrics = {};
        this.isInitialized = false;

        this.initializeTools();
    }

    /**
     * Initialize all environmental analysis tools
     */
    async initializeTools() {
        try {
            console.log('🌱 Initializing GreenPlus by GXS Integration Hub...');

            // Register all available tools
            this.tools.set('waterQuality', {
                name: 'AquaLens Water Quality Analysis',
                analyzer: analyzeWaterImage,
                validator: accuracyValidator.validateWaterQualityAccuracy,
                database: waterQualityDB,
                accuracy: 89.3,
                status: 'active'
            });

            this.tools.set('biodiversity', {
                name: 'BiodiversityEar Ecosystem Monitoring',
                analyzer: analyzeAudioForSpecies,
                validator: accuracyValidator.validateBiodiversityAccuracy,
                database: biodiversityDB,
                accuracy: 82.1,
                status: 'active'
            });

            this.tools.set('airQuality', {
                name: 'Air Quality Analysis',
                analyzer: analyzeAirQuality,
                validator: null,
                database: null,
                accuracy: 85.0,
                status: 'active'
            });

            this.tools.set('carbonFootprint', {
                name: 'Carbon Footprint Tracker',
                analyzer: calculateCarbonFootprint,
                validator: null,
                database: null,
                accuracy: 90.0,
                status: 'active'
            });

            this.tools.set('soilHealth', {
                name: 'Soil Health Analyzer',
                analyzer: analyzeSoilHealth,
                validator: null,
                database: null,
                accuracy: 78.5,
                status: 'active'
            });

            this.tools.set('climateImpact', {
                name: 'Climate Impact Assessment',
                analyzer: assessClimateImpact,
                validator: null,
                database: null,
                accuracy: 85.7,
                status: 'active'
            });

            // Initialize system health monitoring
            await systemHealthChecker.performHealthCheck();

            // Initialize performance optimization
            await performanceOptimizer.initialize();

            this.isInitialized = true;
            console.log('✅ GreenPlus by GXS Integration Hub initialized successfully');

            return true;
        } catch (error) {
            console.error('❌ Failed to initialize GreenPlus by GXS Integration Hub:', error);
            return false;
        }
    }

    /**
     * Perform comprehensive environmental analysis
     */
    async performAnalysis(toolName, data, options = {}) {
        try {
            if (!this.isInitialized) {
                await this.initializeTools();
            }

            const tool = this.tools.get(toolName);
            if (!tool) {
                throw new Error(`Tool '${toolName}' not found`);
            }

            console.log(`🔬 Starting ${tool.name} analysis...`);
            const startTime = Date.now();

            // Perform the analysis
            const result = await tool.analyzer(data, options.location, options.context);

            // Validate the result if validator is available
            let validation = null;
            if (tool.validator) {
                validation = await tool.validator(result, options.expectedValues);
            }

            // Calculate processing time
            const processingTime = Date.now() - startTime;

            // Create comprehensive analysis record
            const analysisRecord = {
                id: this.generateAnalysisId(),
                tool: toolName,
                toolName: tool.name,
                timestamp: new Date().toISOString(),
                processingTime: processingTime,
                result: result,
                validation: validation,
                options: options,
                accuracy: validation?.accuracy || tool.accuracy,
                confidence: result.confidence || 0,
                status: 'completed'
            };

            // Save to history
            this.analysisHistory.push(analysisRecord);

            // Save to appropriate database if available
            if (tool.database) {
                try {
                    await this.saveToDatabase(tool.database, analysisRecord);
                } catch (dbError) {
                    console.warn('Database save failed:', dbError.message);
                }
            }

            // Update performance metrics
            this.updatePerformanceMetrics(toolName, processingTime, validation?.accuracy || tool.accuracy);

            console.log(`✅ ${tool.name} analysis completed in ${processingTime}ms`);
            return analysisRecord;

        } catch (error) {
            console.error(`❌ Analysis failed for ${toolName}:`, error);

            const errorRecord = {
                id: this.generateAnalysisId(),
                tool: toolName,
                timestamp: new Date().toISOString(),
                error: error.message,
                status: 'failed'
            };

            this.analysisHistory.push(errorRecord);
            throw error;
        }
    }

    /**
     * Get system health status
     */
    async getSystemHealth() {
        return await systemHealthChecker.performHealthCheck();
    }

    /**
     * Get performance metrics
     */
    getPerformanceMetrics() {
        return {
            ...this.performanceMetrics,
            totalAnalyses: this.analysisHistory.length,
            successRate: this.calculateSuccessRate(),
            averageProcessingTime: this.calculateAverageProcessingTime(),
            overallAccuracy: this.calculateOverallAccuracy()
        };
    }

    /**
     * Get analysis history
     */
    getAnalysisHistory(limit = 50) {
        return this.analysisHistory
            .slice(-limit)
            .reverse(); // Most recent first
    }

    /**
     * Get tool status
     */
    getToolStatus(toolName = null) {
        if (toolName) {
            return this.tools.get(toolName) || null;
        }

        const status = {};
        this.tools.forEach((tool, name) => {
            status[name] = {
                name: tool.name,
                accuracy: tool.accuracy,
                status: tool.status
            };
        });

        return status;
    }

    /**
     * Run comprehensive system test
     */
    async runSystemTest() {
        try {
            console.log('🧪 Running comprehensive system test...');

            const testResults = await testSuite.runAllTests();
            const healthStatus = await this.getSystemHealth();
            const performanceMetrics = this.getPerformanceMetrics();

            const systemReport = {
                timestamp: new Date().toISOString(),
                testResults: testResults,
                healthStatus: healthStatus,
                performanceMetrics: performanceMetrics,
                toolStatus: this.getToolStatus(),
                overallStatus: this.determineOverallStatus(testResults, healthStatus)
            };

            console.log('✅ System test completed');
            return systemReport;

        } catch (error) {
            console.error('❌ System test failed:', error);
            throw error;
        }
    }

    /**
     * Optimize system performance
     */
    async optimizePerformance() {
        try {
            console.log('⚡ Optimizing system performance...');

            const optimizationResult = await performanceOptimizer.optimize({
                analysisHistory: this.analysisHistory,
                performanceMetrics: this.performanceMetrics
            });

            console.log('✅ Performance optimization completed');
            return optimizationResult;

        } catch (error) {
            console.error('❌ Performance optimization failed:', error);
            throw error;
        }
    }

    // Helper methods
    generateAnalysisId() {
        return 'analysis_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    }

    async saveToDatabase(database, record) {
        if (database === waterQualityDB) {
            await database.saveWaterTest(record);
        } else if (database === biodiversityDB) {
            await database.saveRecording(record);
        }
    }

    updatePerformanceMetrics(toolName, processingTime, accuracy) {
        if (!this.performanceMetrics[toolName]) {
            this.performanceMetrics[toolName] = {
                totalAnalyses: 0,
                totalProcessingTime: 0,
                totalAccuracy: 0,
                averageProcessingTime: 0,
                averageAccuracy: 0
            };
        }

        const metrics = this.performanceMetrics[toolName];
        metrics.totalAnalyses++;
        metrics.totalProcessingTime += processingTime;
        metrics.totalAccuracy += accuracy;
        metrics.averageProcessingTime = metrics.totalProcessingTime / metrics.totalAnalyses;
        metrics.averageAccuracy = metrics.totalAccuracy / metrics.totalAnalyses;
    }

    calculateSuccessRate() {
        const successful = this.analysisHistory.filter(a => a.status === 'completed').length;
        return this.analysisHistory.length > 0 ? (successful / this.analysisHistory.length) * 100 : 0;
    }

    calculateAverageProcessingTime() {
        const completedAnalyses = this.analysisHistory.filter(a => a.processingTime);
        if (completedAnalyses.length === 0) return 0;

        const totalTime = completedAnalyses.reduce((sum, a) => sum + a.processingTime, 0);
        return totalTime / completedAnalyses.length;
    }

    calculateOverallAccuracy() {
        const validatedAnalyses = this.analysisHistory.filter(a => a.accuracy);
        if (validatedAnalyses.length === 0) return 0;

        const totalAccuracy = validatedAnalyses.reduce((sum, a) => sum + a.accuracy, 0);
        return totalAccuracy / validatedAnalyses.length;
    }

    determineOverallStatus(testResults, healthStatus) {
        if (healthStatus.overall === 'error' || testResults.overallStatus === 'failed') {
            return 'critical';
        } else if (healthStatus.overall === 'warning' || testResults.overallStatus === 'warning') {
            return 'warning';
        } else {
            return 'healthy';
        }
    }
}

// Create singleton instance
export const ecoSpireIntegration = new EcoSpireIntegration();

// Auto-initialize in development
if (process.env.NODE_ENV === 'development') {
    ecoSpireIntegration.initializeTools().then(success => {
        if (success) {
            console.log('🌱 GreenPlus by GXS Integration Hub ready for development');
        }
    });
}

export default ecoSpireIntegration;