import asyncio
import pandas as pd
from ona_energy_sdk import OnaClient
from ona_energy_sdk.utils import DataProcessor, PolicyAnalyzer
import logging

class AdvancedEnergyPlatform:
    def __init__(self, api_key: str, deployment_type: str = 'cloud'):
        """
        Initialize advanced energy analytics platform
        
        Args:
            api_key: Ona API key
            deployment_type: 'cloud', 'edge', or 'hybrid'
        """
        self.client = OnaClient(
            api_key=api_key,
            base_url=self._get_base_url(deployment_type),
            timeout=60,
            max_retries=3,
            enable_caching=True
        )
        
        self.data_processor = DataProcessor(client=self.client)
        self.policy_analyzer = PolicyAnalyzer(client=self.client)
        
        # Setup logging
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)

    def _get_base_url(self, deployment_type: str) -> str:
        """Get appropriate base URL based on deployment type"""
        if deployment_type == 'edge':
            return 'http://localhost:5000'
        elif deployment_type == 'hybrid':
            return 'https://api.asoba.co'  # Will auto-route to edge when available
        return 'https://api.asoba.co'

    async def comprehensive_energy_analysis(self, 
                                          data_file: str, 
                                          customer_config: dict,
                                          analysis_config: dict = None):
        """
        Perform comprehensive energy analysis including forecasting,
        optimization, and policy compliance
        """
        analysis_config = analysis_config or {
            'forecast_horizon': 168,  # 7 days
            'confidence_level': 0.95,
            'include_weather': True,
            'include_policy_analysis': True,
            'optimization_target': 'cost_efficiency'
        }

        try:
            # Phase 1: Data preprocessing and quality enhancement
            self.logger.info("🔧 Starting data preprocessing...")
            
            raw_data = pd.read_csv(data_file)
            processed_data = await self.data_processor.enhance_data_quality(
                data=raw_data,
                interpolation_method='intelligent',
                outlier_detection=True,
                seasonal_decomposition=True
            )

            # Phase 2: Upload processed data
            self.logger.info("📤 Uploading processed data...")
            upload_result = await self.client.upload_historical_data(
                file_data=processed_data.to_csv(),
                customer_id=customer_config['id'],
                location=customer_config['location'],
                manufacturer=customer_config['manufacturer'],
                equipment_type=customer_config.get('equipment_type', 'solar'),
                metadata={
                    'data_quality_score': processed_data.attrs.get('quality_score'),
                    'processing_timestamp': pd.Timestamp.now().isoformat(),
                    'original_rows': len(raw_data),
                    'processed_rows': len(processed_data)
                }
            )

            # Phase 3: AI model training with hyperparameter optimization
            self.logger.info("🧠 Training AI forecasting models...")
            training_config = {
                'customer_id': customer_config['id'],
                'model_type': 'ensemble',
                'hyperparameter_tuning': True,
                'cross_validation_folds': 5,
                'early_stopping': True,
                'feature_engineering': {
                    'weather_features': analysis_config['include_weather'],
                    'calendar_features': True,
                    'lag_features': [1, 2, 3, 6, 12, 24, 48, 168],
                    'rolling_statistics': [24, 168, 720]  # 1d, 1w, 1m windows
                }
            }

            training_job = await self.client.train_forecasting_model(**training_config)
            
            # Monitor training with progress updates
            training_status = await self._monitor_training_progress(
                training_job['training_job_id']
            )

            # Phase 4: Generate multi-horizon forecasts
            self.logger.info("🔮 Generating multi-horizon forecasts...")
            forecasts = {}
            
            for horizon in [24, 72, 168]:  # 1d, 3d, 7d forecasts
                forecast = await self.client.generate_forecast(
                    customer_id=customer_config['id'],
                    forecast_window=horizon,
                    confidence_interval=analysis_config['confidence_level'],
                    include_weather_impact=analysis_config['include_weather'],
                    scenario_analysis=True
                )
                forecasts[f'{horizon}h'] = forecast

            # Phase 5: Policy compliance and regulatory analysis
            policy_analysis = None
            if analysis_config.get('include_policy_analysis'):
                self.logger.info("📋 Analyzing policy compliance...")
                policy_analysis = await self.policy_analyzer.comprehensive_analysis(
                    customer_config=customer_config,
                    forecasts=forecasts,
                    compliance_domains=['grid_connection', 'environmental', 'financial']
                )

            # Phase 6: Optimization recommendations
            self.logger.info("⚡ Generating optimization recommendations...")
            optimization = await self._generate_optimization_recommendations(
                customer_config, forecasts, policy_analysis, analysis_config
            )

            # Phase 7: Risk assessment
            risk_assessment = await self._assess_operational_risks(
                forecasts, customer_config, training_status['metrics']
            )

            return {
                'data_processing': {
                    'quality_improvement': processed_data.attrs.get('quality_improvement', 0),
                    'outliers_detected': processed_data.attrs.get('outliers_removed', 0),
                    'missing_data_filled': processed_data.attrs.get('missing_filled', 0)
                },
                'model_performance': training_status['metrics'],
                'forecasts': forecasts,
                'policy_compliance': policy_analysis,
                'optimization_recommendations': optimization,
                'risk_assessment': risk_assessment,
                'execution_summary': {
                    'processing_time': training_status.get('processing_time'),
                    'model_accuracy': training_status['metrics'].get('mape'),
                    'confidence_score': forecasts['24h'].get('average_confidence'),
                    'compliance_score': policy_analysis.get('overall_score') if policy_analysis else None
                }
            }

        except Exception as e:
            self.logger.error(f"❌ Comprehensive analysis failed: {str(e)}")
            
            # Intelligent error recovery
            if 'tier_limit' in str(e).lower():
                self.logger.info("💡 Tier limit reached. Consider upgrading for unlimited access.")
                return await self._generate_limited_analysis(data_file, customer_config)
            
            raise

    async def _monitor_training_progress(self, training_job_id: str):
        """Monitor training progress with real-time updates"""
        import time
        
        start_time = time.time()
        while True:
            status = await self.client.get_training_status(training_job_id)
            
            if status['status'] == 'completed':
                self.logger.info(f"✅ Training completed in {time.time() - start_time:.1f}s")
                return status
            elif status['status'] == 'failed':
                raise Exception(f"Training failed: {status.get('error_message')}")
            
            progress = status.get('progress', 0)
            self.logger.info(f"⏳ Training progress: {progress}%")
            await asyncio.sleep(30)  # Check every 30 seconds

    async def _generate_optimization_recommendations(self, customer_config, forecasts, policy_analysis, analysis_config):
        """Generate actionable optimization recommendations"""
        # Implementation for optimization logic
        pass

    async def _assess_operational_risks(self, forecasts, customer_config, model_metrics):
        """Assess operational and financial risks"""
        # Implementation for risk assessment
        pass

# Example Usage
async def main():
    platform = AdvancedEnergyPlatform(
        api_key="your-ona-api-key",
        deployment_type="hybrid"  # Use edge when available, cloud as fallback
    )
    
    customer_config = {
        'id': 'wind_farm_eastern_cape_001',
        'location': 'PortElizabeth',
        'manufacturer': 'Vestas',
        'equipment_type': 'wind_turbine',
        'capacity_mw': 50,
        'commissioning_date': '2023-01-15',
        'business_model': 'ipp_wheeling'
    }
    
    analysis_config = {
        'forecast_horizon': 168,
        'confidence_level': 0.95,
        'include_weather': True,
        'include_policy_analysis': True,
        'optimization_target': 'revenue_maximization'
    }
    
    results = await platform.comprehensive_energy_analysis(
        data_file='./wind_farm_data_2024.csv',
        customer_config=customer_config,
        analysis_config=analysis_config
    )
    
    print("📊 Analysis Results:", results)

# Run the example
if __name__ == "__main__":
    asyncio.run(main())

# Python configuration for edge deployment
from ona_energy_sdk import OnaClient

edge_client = OnaClient(
    base_url='http://localhost:5000',
    api_key=os.environ['ONA_API_KEY'],
    deployment_type='edge',
    fallback_to_cloud=True,
    sync_with_cloud=True,
    edge_config={
        'max_local_storage': '100GB',
        'auto_cleanup_days': 30,
        'prefer_local_processing': True
    }
)

# Test edge connectivity
health_status = await edge_client.health_check()
print(f"Edge Status: {health_status}")

# Process multiple customers in parallel
batch_processor = client.create_batch_processor(
    max_concurrent=5,
    retry_strategy='exponential_backoff'
)

results = await batch_processor.process_multiple_customers([
    {'id': 'customer_001', 'file': 'data1.csv'},
    {'id': 'customer_002', 'file': 'data2.csv'},
    {'id': 'customer_003', 'file': 'data3.csv'}
])

from ona_energy_sdk.utils import RateLimitHandler

# Intelligent rate limit handling
rate_handler = RateLimitHandler(
    strategy='adaptive',  # Automatically adjust request rate
    max_retries=5,
    backoff_factor=2.0
)

client = OnaClient(
    api_key=api_key,
    rate_limit_handler=rate_handler
)

# Optimized batch upload for large datasets
async def optimized_batch_upload(client, large_dataset, chunk_size=1000):
    """
    Upload large datasets in optimized chunks with compression
    """
    chunks = [large_dataset[i:i+chunk_size] for i in range(0, len(large_dataset), chunk_size)]
    
    upload_tasks = []
    for i, chunk in enumerate(chunks):
        # Compress data for faster upload
        compressed_chunk = compress_energy_data(chunk)
        
        task = client.upload_historical_data(
            file_data=compressed_chunk,
            chunk_id=i,
            total_chunks=len(chunks),
            compression='gzip'
        )
        upload_tasks.append(task)
    
    # Upload chunks in parallel with controlled concurrency
    results = await asyncio.gather(*upload_tasks, return_exceptions=True)
    return results