"""Bayesian reasoning implementation."""

import logging
from typing import Dict, Any, List
import json
import re
from datetime import datetime

from .base import ReasoningStrategy

class BayesianReasoning(ReasoningStrategy):
    """Implements Bayesian reasoning for probabilistic analysis."""
    
    def __init__(self, prior_weight: float = 0.3):
        self.prior_weight = prior_weight
    
    async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
        try:
            # Generate hypotheses
            hypotheses = await self._generate_hypotheses(query, context)
            
            # Calculate prior probabilities
            priors = await self._calculate_priors(hypotheses, context)
            
            # Update with evidence
            posteriors = await self._update_with_evidence(hypotheses, priors, context)
            
            # Generate final analysis
            analysis = await self._generate_analysis(posteriors, context)
            
            return {
                "success": True,
                "answer": analysis["conclusion"],
                "hypotheses": hypotheses,
                "priors": priors,
                "posteriors": posteriors,
                "confidence": analysis["confidence"],
                "reasoning_path": analysis["reasoning_path"]
            }
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    async def _generate_hypotheses(self, query: str, context: Dict[str, Any]) -> List[Dict[str, Any]]:
        prompt = f"""
        Generate 3-4 hypotheses for this problem:
        Query: {query}
        Context: {json.dumps(context)}
        
        For each hypothesis:
        1. [Statement]: Clear statement of the hypothesis
        2. [Assumptions]: Key assumptions made
        3. [Testability]: How it could be tested/verified
        
        Format as:
        [H1]
        Statement: ...
        Assumptions: ...
        Testability: ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_hypotheses(response["answer"])

    async def _calculate_priors(self, hypotheses: List[Dict[str, Any]], context: Dict[str, Any]) -> Dict[str, float]:
        prompt = f"""
        Calculate prior probabilities for these hypotheses:
        Context: {json.dumps(context)}
        
        Hypotheses:
        {json.dumps(hypotheses, indent=2)}
        
        For each hypothesis, estimate its prior probability (0-1) based on:
        1. Alignment with known principles
        2. Historical precedent
        3. Domain expertise
        
        Format: [H1]: 0.XX, [H2]: 0.XX, ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_probabilities(response["answer"])

    async def _update_with_evidence(self, hypotheses: List[Dict[str, Any]], priors: Dict[str, float], 
                                  context: Dict[str, Any]) -> Dict[str, float]:
        prompt = f"""
        Update probabilities with available evidence:
        Context: {json.dumps(context)}
        
        Hypotheses and Priors:
        {json.dumps(list(zip(hypotheses, priors.values())), indent=2)}
        
        Consider:
        1. How well each hypothesis explains the evidence
        2. Any new evidence from the context
        3. Potential conflicts or support between hypotheses
        
        Format: [H1]: 0.XX, [H2]: 0.XX, ...
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_probabilities(response["answer"])

    async def _generate_analysis(self, posteriors: Dict[str, float], context: Dict[str, Any]) -> Dict[str, Any]:
        prompt = f"""
        Generate final Bayesian analysis:
        Context: {json.dumps(context)}
        
        Posterior Probabilities:
        {json.dumps(posteriors, indent=2)}
        
        Provide:
        1. Main conclusion based on highest probability hypotheses
        2. Confidence level (0-1)
        3. Key reasoning steps taken
        """
        
        response = await context["groq_api"].predict(prompt)
        return self._parse_analysis(response["answer"])

    def _parse_hypotheses(self, response: str) -> List[Dict[str, Any]]:
        """Parse hypotheses from response."""
        hypotheses = []
        current = None
        
        for line in response.split('\n'):
            line = line.strip()
            if not line:
                continue
            
            if line.startswith('[H'):
                if current:
                    hypotheses.append(current)
                current = {
                    "statement": "",
                    "assumptions": "",
                    "testability": ""
                }
            elif current:
                if line.startswith('Statement:'):
                    current["statement"] = line[10:].strip()
                elif line.startswith('Assumptions:'):
                    current["assumptions"] = line[12:].strip()
                elif line.startswith('Testability:'):
                    current["testability"] = line[12:].strip()
        
        if current:
            hypotheses.append(current)
        
        return hypotheses

    def _parse_probabilities(self, response: str) -> Dict[str, float]:
        """Parse probabilities from response."""
        probs = {}
        pattern = r'\[H(\d+)\]:\s*(0\.\d+)'
        
        for match in re.finditer(pattern, response):
            h_num = int(match.group(1))
            prob = float(match.group(2))
            probs[f"H{h_num}"] = prob
        
        return probs

    def _parse_analysis(self, response: str) -> Dict[str, Any]:
        """Parse analysis from response."""
        lines = response.split('\n')
        analysis = {
            "conclusion": "",
            "confidence": 0.0,
            "reasoning_path": []
        }
        
        for line in lines:
            line = line.strip()
            if not line:
                continue
                
            if line.startswith('Conclusion:'):
                analysis["conclusion"] = line[11:].strip()
            elif line.startswith('Confidence:'):
                try:
                    analysis["confidence"] = float(line[11:].strip())
                except:
                    analysis["confidence"] = 0.5
            elif line.startswith('- '):
                analysis["reasoning_path"].append(line[2:].strip())
        
        return analysis