"""Advanced portfolio optimization for venture strategies."""

import logging
from typing import Dict, Any, List, Optional, Set, Union, Type, Tuple
import json
from dataclasses import dataclass, field
from enum import Enum
from datetime import datetime
import numpy as np
from collections import defaultdict

@dataclass
class VentureMetrics:
    """Venture performance metrics."""
    revenue: float
    profit: float
    growth_rate: float
    risk_score: float
    resource_usage: Dict[str, float]
    synergy_score: float

@dataclass
class ResourceAllocation:
    """Resource allocation configuration."""
    venture_id: str
    resources: Dict[str, float]
    constraints: List[str]
    dependencies: List[str]
    priority: float

class PortfolioOptimizer:
    """
    Advanced portfolio optimization that:
    1. Optimizes venture mix
    2. Allocates resources
    3. Manages risks
    4. Maximizes synergies
    5. Balances growth
    """
    
    def __init__(self):
        self.ventures: Dict[str, VentureMetrics] = {}
        self.allocations: Dict[str, ResourceAllocation] = {}
        
    async def optimize_portfolio(self,
                               ventures: List[str],
                               context: Dict[str, Any]) -> Dict[str, Any]:
        """Optimize venture portfolio."""
        try:
            # Analyze ventures
            analysis = await self._analyze_ventures(ventures, context)
            
            # Optimize allocation
            allocation = await self._optimize_allocation(analysis, context)
            
            # Risk optimization
            risk = await self._optimize_risk(allocation, context)
            
            # Synergy optimization
            synergy = await self._optimize_synergies(risk, context)
            
            # Performance projections
            projections = await self._project_performance(synergy, context)
            
            return {
                "success": projections["annual_profit"] >= 1_000_000,
                "analysis": analysis,
                "allocation": allocation,
                "risk": risk,
                "synergy": synergy,
                "projections": projections
            }
        except Exception as e:
            logging.error(f"Error in portfolio optimization: {str(e)}")
            return {"success": False, "error": str(e)}

    async def _analyze_ventures(self,
                              ventures: List[str],
                              context: Dict[str, Any]) -> Dict[str, Any]:
        """Analyze venture characteristics."""
        prompt = f"""
        Analyze ventures:
        Ventures: {json.dumps(ventures)}
        Context: {json.dumps(context)}
        
        Analyze:
        1. Performance metrics
        2. Resource requirements
        3. Risk factors
        4. Growth potential
        5. Synergy opportunities
        
        Format as:
        [Venture1]
        Metrics: ...
        Resources: ...
        Risks: ...
        Growth: ...
        Synergies: ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_venture_analysis(response["answer"])

    async def _optimize_allocation(self,
                                 analysis: Dict[str, Any],
                                 context: Dict[str, Any]) -> Dict[str, Any]:
        """Optimize resource allocation."""
        prompt = f"""
        Optimize resource allocation:
        Analysis: {json.dumps(analysis)}
        Context: {json.dumps(context)}
        
        Optimize for:
        1. Resource efficiency
        2. Growth potential
        3. Risk balance
        4. Synergy capture
        5. Constraint satisfaction
        
        Format as:
        [Allocation1]
        Venture: ...
        Resources: ...
        Constraints: ...
        Dependencies: ...
        Priority: ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_allocation_optimization(response["answer"])

    async def _optimize_risk(self,
                           allocation: Dict[str, Any],
                           context: Dict[str, Any]) -> Dict[str, Any]:
        """Optimize risk management."""
        prompt = f"""
        Optimize risk management:
        Allocation: {json.dumps(allocation)}
        Context: {json.dumps(context)}
        
        Optimize for:
        1. Risk diversification
        2. Exposure limits
        3. Correlation management
        4. Hedging strategies
        5. Contingency planning
        
        Format as:
        [Risk1]
        Type: ...
        Exposure: ...
        Mitigation: ...
        Contingency: ...
        Impact: ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_risk_optimization(response["answer"])

    async def _optimize_synergies(self,
                                risk: Dict[str, Any],
                                context: Dict[str, Any]) -> Dict[str, Any]:
        """Optimize portfolio synergies."""
        prompt = f"""
        Optimize synergies:
        Risk: {json.dumps(risk)}
        Context: {json.dumps(context)}
        
        Optimize for:
        1. Resource sharing
        2. Knowledge transfer
        3. Market leverage
        4. Technology reuse
        5. Customer cross-sell
        
        Format as:
        [Synergy1]
        Type: ...
        Ventures: ...
        Potential: ...
        Requirements: ...
        Timeline: ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_synergy_optimization(response["answer"])

    async def _project_performance(self,
                                 synergy: Dict[str, Any],
                                 context: Dict[str, Any]) -> Dict[str, Any]:
        """Project portfolio performance."""
        prompt = f"""
        Project performance:
        Synergy: {json.dumps(synergy)}
        Context: {json.dumps(context)}
        
        Project:
        1. Revenue growth
        2. Profit margins
        3. Resource utilization
        4. Risk metrics
        5. Synergy capture
        
        Format as:
        [Projections]
        Revenue: ...
        Profit: ...
        Resources: ...
        Risk: ...
        Synergies: ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_performance_projections(response["answer"])

    def _calculate_portfolio_metrics(self) -> Dict[str, float]:
        """Calculate comprehensive portfolio metrics."""
        if not self.ventures:
            return {
                "total_revenue": 0.0,
                "total_profit": 0.0,
                "avg_growth": 0.0,
                "avg_risk": 0.0,
                "resource_efficiency": 0.0,
                "synergy_capture": 0.0
            }
        
        metrics = {
            "total_revenue": sum(v.revenue for v in self.ventures.values()),
            "total_profit": sum(v.profit for v in self.ventures.values()),
            "avg_growth": np.mean([v.growth_rate for v in self.ventures.values()]),
            "avg_risk": np.mean([v.risk_score for v in self.ventures.values()]),
            "resource_efficiency": self._calculate_resource_efficiency(),
            "synergy_capture": np.mean([v.synergy_score for v in self.ventures.values()])
        }
        
        return metrics

    def _calculate_resource_efficiency(self) -> float:
        """Calculate resource utilization efficiency."""
        if not self.ventures or not self.allocations:
            return 0.0
        
        total_resources = defaultdict(float)
        used_resources = defaultdict(float)
        
        # Sum up total and used resources
        for venture_id, allocation in self.allocations.items():
            for resource, amount in allocation.resources.items():
                total_resources[resource] += amount
                if venture_id in self.ventures:
                    used_resources[resource] += (
                        amount * self.ventures[venture_id].resource_usage.get(resource, 0)
                    )
        
        # Calculate efficiency for each resource
        efficiencies = []
        for resource in total_resources:
            if total_resources[resource] > 0:
                efficiency = used_resources[resource] / total_resources[resource]
                efficiencies.append(efficiency)
        
        return np.mean(efficiencies) if efficiencies else 0.0

    def get_portfolio_insights(self) -> Dict[str, Any]:
        """Get comprehensive portfolio insights."""
        metrics = self._calculate_portfolio_metrics()
        
        return {
            "portfolio_metrics": metrics,
            "venture_metrics": {
                venture_id: {
                    "revenue": v.revenue,
                    "profit": v.profit,
                    "growth_rate": v.growth_rate,
                    "risk_score": v.risk_score,
                    "synergy_score": v.synergy_score
                }
                for venture_id, v in self.ventures.items()
            },
            "resource_allocation": {
                venture_id: {
                    "resources": a.resources,
                    "priority": a.priority,
                    "constraints": len(a.constraints),
                    "dependencies": len(a.dependencies)
                }
                for venture_id, a in self.allocations.items()
            },
            "risk_profile": {
                "portfolio_risk": metrics["avg_risk"],
                "risk_concentration": self._calculate_risk_concentration(),
                "risk_correlation": self._calculate_risk_correlation()
            },
            "optimization_opportunities": self._identify_optimization_opportunities()
        }

    def _calculate_risk_concentration(self) -> float:
        """Calculate risk concentration in portfolio."""
        if not self.ventures:
            return 0.0
        
        risk_weights = [v.risk_score for v in self.ventures.values()]
        return np.std(risk_weights) if len(risk_weights) > 1 else 0.0

    def _calculate_risk_correlation(self) -> float:
        """Calculate risk correlation between ventures."""
        if len(self.ventures) < 2:
            return 0.0
        
        # Create correlation matrix of risk scores and resource usage
        venture_metrics = [
            [v.risk_score] + list(v.resource_usage.values())
            for v in self.ventures.values()
        ]
        
        correlation_matrix = np.corrcoef(venture_metrics)
        return np.mean(correlation_matrix[np.triu_indices_from(correlation_matrix, k=1)])

    def _identify_optimization_opportunities(self) -> List[Dict[str, Any]]:
        """Identify portfolio optimization opportunities."""
        opportunities = []
        
        # Resource optimization opportunities
        resource_efficiency = self._calculate_resource_efficiency()
        if resource_efficiency < 0.8:
            opportunities.append({
                "type": "resource_optimization",
                "potential": 1.0 - resource_efficiency,
                "description": "Improve resource utilization efficiency"
            })
        
        # Risk optimization opportunities
        risk_concentration = self._calculate_risk_concentration()
        if risk_concentration > 0.2:
            opportunities.append({
                "type": "risk_diversification",
                "potential": risk_concentration,
                "description": "Reduce risk concentration"
            })
        
        # Synergy optimization opportunities
        avg_synergy = np.mean([v.synergy_score for v in self.ventures.values()]) if self.ventures else 0
        if avg_synergy < 0.7:
            opportunities.append({
                "type": "synergy_capture",
                "potential": 1.0 - avg_synergy,
                "description": "Increase synergy capture"
            })
        
        return opportunities