"""
Business Rules Insights Orchestrator
Coordinates business rules optimization and insight posting
"""

import pandas as pd
from typing import Dict, List, Any, Optional
import structlog
from datetime import datetime
from uuid import UUID
import sys
import os

# Add shared clients to path
sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..'))
from shared.clients.ai_insights_client import AIInsightsClient
from shared.messaging import UnifiedEventPublisher

from app.ml.dynamic_rules_engine import DynamicRulesEngine

logger = structlog.get_logger()


class BusinessRulesInsightsOrchestrator:
    """
    Orchestrates business rules analysis and insight generation workflow.

    Workflow:
    1. Analyze dynamic business rule performance
    2. Generate insights for rule optimization
    3. Post insights to AI Insights Service
    4. Publish recommendation events to RabbitMQ
    5. Provide rule optimization for forecasting
    6. Track rule effectiveness and improvements
    """

    def __init__(
        self,
        ai_insights_base_url: str = "http://ai-insights-service:8000",
        event_publisher: Optional[UnifiedEventPublisher] = None
    ):
        self.rules_engine = DynamicRulesEngine()
        self.ai_insights_client = AIInsightsClient(ai_insights_base_url)
        self.event_publisher = event_publisher

    async def analyze_and_post_business_rules_insights(
        self,
        tenant_id: str,
        inventory_product_id: str,
        sales_data: pd.DataFrame,
        min_samples: int = 10
    ) -> Dict[str, Any]:
        """
        Complete workflow: Analyze business rules and post insights.

        Args:
            tenant_id: Tenant identifier
            inventory_product_id: Product identifier
            sales_data: Historical sales data
            min_samples: Minimum samples for rule analysis

        Returns:
            Workflow results with analysis and posted insights
        """
        logger.info(
            "Starting business rules analysis workflow",
            tenant_id=tenant_id,
            inventory_product_id=inventory_product_id,
            samples=len(sales_data)
        )

        # Step 1: Learn and analyze rules
        rules_results = await self.rules_engine.learn_all_rules(
            tenant_id=tenant_id,
            inventory_product_id=inventory_product_id,
            sales_data=sales_data,
            external_data=None,
            min_samples=min_samples
        )

        logger.info(
            "Business rules analysis complete",
            insights_generated=len(rules_results.get('insights', [])),
            rules_learned=len(rules_results.get('rules', {}))
        )

        # Step 2: Enrich insights with tenant_id and product context
        enriched_insights = self._enrich_insights(
            rules_results.get('insights', []),
            tenant_id,
            inventory_product_id
        )

        # Step 3: Post insights to AI Insights Service
        if enriched_insights:
            post_results = await self.ai_insights_client.create_insights_bulk(
                tenant_id=UUID(tenant_id),
                insights=enriched_insights
            )

            logger.info(
                "Business rules insights posted to AI Insights Service",
                inventory_product_id=inventory_product_id,
                total=post_results['total'],
                successful=post_results['successful'],
                failed=post_results['failed']
            )
        else:
            post_results = {'total': 0, 'successful': 0, 'failed': 0}
            logger.info("No insights to post for product", inventory_product_id=inventory_product_id)

        # Step 4: Publish insight events to RabbitMQ
        created_insights = post_results.get('created_insights', [])
        if created_insights:
            product_context = {'inventory_product_id': inventory_product_id}
            await self._publish_insight_events(
                tenant_id=tenant_id,
                insights=created_insights,
                product_context=product_context
            )

        # Step 5: Return comprehensive results
        return {
            'tenant_id': tenant_id,
            'inventory_product_id': inventory_product_id,
            'learned_at': rules_results['learned_at'],
            'rules': rules_results.get('rules', {}),
            'insights_generated': len(enriched_insights),
            'insights_posted': post_results['successful'],
            'insights_failed': post_results['failed'],
            'created_insights': post_results.get('created_insights', [])
        }

    def _enrich_insights(
        self,
        insights: List[Dict[str, Any]],
        tenant_id: str,
        inventory_product_id: str
    ) -> List[Dict[str, Any]]:
        """
        Enrich insights with required fields for AI Insights Service.

        Args:
            insights: Raw insights from rules engine
            tenant_id: Tenant identifier
            inventory_product_id: Product identifier

        Returns:
            Enriched insights ready for posting
        """
        enriched = []

        for insight in insights:
            # Add required tenant_id
            enriched_insight = insight.copy()
            enriched_insight['tenant_id'] = tenant_id

            # Add product context to metrics
            if 'metrics_json' not in enriched_insight:
                enriched_insight['metrics_json'] = {}

            enriched_insight['metrics_json']['inventory_product_id'] = inventory_product_id

            # Add source metadata
            enriched_insight['source_service'] = 'forecasting'
            enriched_insight['source_model'] = 'dynamic_rules_engine'
            enriched_insight['detected_at'] = datetime.utcnow().isoformat()

            enriched.append(enriched_insight)

        return enriched

    async def analyze_all_business_rules(
        self,
        tenant_id: str,
        products_data: Dict[str, pd.DataFrame],
        min_samples: int = 10
    ) -> Dict[str, Any]:
        """
        Analyze all products for business rules optimization and generate comparative insights.

        Args:
            tenant_id: Tenant identifier
            products_data: Dict of {inventory_product_id: sales_data DataFrame}
            min_samples: Minimum samples for rule analysis

        Returns:
            Comprehensive analysis with rule optimization insights
        """
        logger.info(
            "Analyzing business rules for all products",
            tenant_id=tenant_id,
            products=len(products_data)
        )

        all_results = []
        total_insights_posted = 0

        # Analyze each product
        for inventory_product_id, sales_data in products_data.items():
            try:
                results = await self.analyze_and_post_business_rules_insights(
                    tenant_id=tenant_id,
                    inventory_product_id=inventory_product_id,
                    sales_data=sales_data,
                    min_samples=min_samples
                )

                all_results.append(results)
                total_insights_posted += results['insights_posted']

            except Exception as e:
                logger.error(
                    "Error analyzing business rules for product",
                    inventory_product_id=inventory_product_id,
                    error=str(e)
                )

        # Generate summary insight
        if total_insights_posted > 0:
            summary_insight = self._generate_portfolio_summary_insight(
                tenant_id, all_results
            )

            if summary_insight:
                enriched_summary = self._enrich_insights(
                    [summary_insight], tenant_id, 'all_products'
                )

                post_results = await self.ai_insights_client.create_insights_bulk(
                    tenant_id=UUID(tenant_id),
                    insights=enriched_summary
                )

                total_insights_posted += post_results['successful']

        logger.info(
            "All business rules analysis complete",
            tenant_id=tenant_id,
            products_analyzed=len(all_results),
            total_insights_posted=total_insights_posted
        )

        return {
            'tenant_id': tenant_id,
            'analyzed_at': datetime.utcnow().isoformat(),
            'products_analyzed': len(all_results),
            'product_results': all_results,
            'total_insights_posted': total_insights_posted
        }

    def _generate_portfolio_summary_insight(
        self,
        tenant_id: str,
        all_results: List[Dict[str, Any]]
    ) -> Optional[Dict[str, Any]]:
        """
        Generate portfolio-level business rules summary insight.

        Args:
            tenant_id: Tenant identifier
            all_results: All product analysis results

        Returns:
            Summary insight or None
        """
        if not all_results:
            return None

        # Calculate summary statistics
        total_products = len(all_results)
        total_rules = sum(len(r.get('rules', {})) for r in all_results)
        
        # Count products with significant rule improvements
        significant_improvements = sum(1 for r in all_results 
                                     if any('improvement' in str(v).lower() for v in r.get('rules', {}).values()))

        return {
            'type': 'recommendation',
            'priority': 'high' if significant_improvements > total_products * 0.3 else 'medium',
            'category': 'forecasting',
            'title': f'Business Rule Optimization: {total_products} Products Analyzed',
            'description': f'Learned {total_rules} dynamic rules across {total_products} products. Identified {significant_improvements} products with significant rule improvements.',
            'impact_type': 'operational_efficiency',
            'impact_value': total_rules,
            'impact_unit': 'rules',
            'confidence': 80,
            'metrics_json': {
                'total_products': total_products,
                'total_rules': total_rules,
                'significant_improvements': significant_improvements,
                'rules_per_product': round(total_rules / total_products, 2)
            },
            'actionable': True,
            'recommendation_actions': [
                {
                    'label': 'Review Learned Rules',
                    'action': 'review_business_rules',
                    'params': {'tenant_id': tenant_id}
                },
                {
                    'label': 'Implement Optimized Rules',
                    'action': 'implement_business_rules',
                    'params': {'tenant_id': tenant_id}
                }
            ],
            'source_service': 'forecasting',
            'source_model': 'dynamic_rules_engine'
        }

    async def get_learned_rules(
        self,
        inventory_product_id: str
    ) -> Optional[Dict[str, Any]]:
        """
        Get cached learned rules for a product.

        Args:
            inventory_product_id: Product identifier

        Returns:
            Learned rules or None if not analyzed
        """
        return self.rules_engine.get_all_rules(inventory_product_id)

    async def _publish_insight_events(self, tenant_id, insights, product_context=None):
        """
        Publish insight events to RabbitMQ for alert processing.

        Args:
            tenant_id: Tenant identifier
            insights: List of created insights
            product_context: Additional context about the product
        """
        if not self.event_publisher:
            logger.warning("No event publisher available for business rules insights")
            return

        for insight in insights:
            # Determine severity based on confidence and priority
            confidence = insight.get('confidence', 0)
            priority = insight.get('priority', 'medium')
            
            # Map priority to severity, with confidence as tiebreaker
            if priority == 'critical' or (priority == 'high' and confidence >= 70):
                severity = 'high'
            elif priority == 'high' or (priority == 'medium' and confidence >= 80):
                severity = 'medium'
            else:
                severity = 'low'

            # Prepare the event data
            event_data = {
                'insight_id': insight.get('id'),
                'type': insight.get('type'),
                'title': insight.get('title'),
                'description': insight.get('description'),
                'category': insight.get('category'),
                'priority': insight.get('priority'),
                'confidence': confidence,
                'recommendation': insight.get('recommendation_actions', []),
                'impact_type': insight.get('impact_type'),
                'impact_value': insight.get('impact_value'),
                'inventory_product_id': product_context.get('inventory_product_id') if product_context else None,
                'timestamp': insight.get('detected_at', datetime.utcnow().isoformat()),
                'source_service': 'forecasting',
                'source_model': 'dynamic_rules_engine'
            }

            try:
                await self.event_publisher.publish_recommendation(
                    event_type='ai_business_rule',
                    tenant_id=tenant_id,
                    severity=severity,
                    data=event_data
                )
                logger.info(
                    "Published business rules insight event",
                    tenant_id=tenant_id,
                    insight_id=insight.get('id'),
                    severity=severity
                )
            except Exception as e:
                logger.error(
                    "Failed to publish business rules insight event",
                    tenant_id=tenant_id,
                    insight_id=insight.get('id'),
                    error=str(e)
                )

    async def close(self):
        """Close HTTP client connections."""
        await self.ai_insights_client.close()