import logging
from decimal import Decimal
from datetime import datetime
from typing import Dict, Any, List, Literal, Optional, Union
from pydantic import BaseModel, Field, ConfigDict


import backoff
import httpx


from ..settings import secure_settings


# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class HypernymClientError(Exception):
   """Base exception for client errors"""
   pass


class HypernymAPIError(HypernymClientError):
   """Raised when the API returns an error response"""
   def __init__(self, status_code: int, detail: str):
       self.status_code = status_code
       self.detail = detail
       super().__init__(f"API error {status_code}: {detail}")


class HypernymTimeoutError(HypernymClientError):
   """Raised when the API request times out"""
   pass


# Response Models
class EmbeddingMetadata(BaseModel):
   """Metadata about the embedding model used"""
   version: str
   dimensions: int


class TokenCounts(BaseModel):
   """Token usage statistics"""
   in_: int = Field(..., alias="in")
   out: int
   total: int


class Metadata(BaseModel):
   """Top-level metadata about the request/response"""
   version: str
   timestamp: datetime
   tokens: TokenCounts


class RequestParams(BaseModel):
   """Parameters for the analysis request"""
   min_compression_ratio: float = Field(ge=0.0, le=1.0)
   min_semantic_similarity: float = Field(ge=0.0, le=1.0)


class Request(BaseModel):
   """Echo of the original request"""
   content: str
   params: RequestParams


class ResponseMeta(BaseModel):
   """Metadata specific to the response"""
   embedding: EmbeddingMetadata


class ResponseTexts(BaseModel):
   """Processed text outputs"""
   compressed: str
   suggested: str


class EmbeddingData(BaseModel):
   """Embedding vector data"""
   dimensions: int
   size_in_bytes: int
   values: List[float]


class DetailInfo(BaseModel):
   """Individual covariant detail"""
   text: str
   n: int
   embedding: Optional[EmbeddingData] = None


class SegmentData(BaseModel):
   """Common data structure for original and reconstructed segments"""
   text: str
   embedding: EmbeddingData


class ResponseSegment(BaseModel):
   """Individual segment analysis results"""
   was_compressed: bool
   semantic_category: str
   covariant_details: List[DetailInfo]
   original: SegmentData
   reconstructed: Optional[SegmentData] = None
   semantic_similarity: float = Field(ge=0.0, le=1.0)
   compression_ratio: float = Field(ge=0.0, le=1.0)


class Response(BaseModel):
   """Complete response data"""
   meta: ResponseMeta
   texts: ResponseTexts
   segments: List[ResponseSegment]


class SemanticAnalysisResponse(BaseModel):
   """Top-level response model"""
   metadata: Metadata
   request: Request
   response: Response


   model_config = ConfigDict(
       json_schema_extra={
           "example": {
               "metadata": {
                   "version": "0.1.0",
                   "timestamp": "2024-03-21T00:00:00Z",
                   "tokens": {
                       "in": 1000,
                       "out": 500,
                       "total": 1500
                   }
               },
               "request": {
                   "content": "Computational Complexity Theory is a fundamental field...",
                   "params": {
                       "min_compression_ratio": 0.5,
                       "min_semantic_similarity": 0.8
                   }
               },
               "response": {
                   "meta": {
                       "embedding": {
                           "version": "0.1.0",
                           "dimensions": 512
                       }
                   },
                   "texts": {
                       "compressed": "Theory::focus=computational;type=complexity\n\nMethodology::approach=algorithmic",
                       "suggested": "Computational Complexity Theory is a fundamental field..."
                   },
                   "segments": [
                       {
                           "was_compressed": True,
                           "semantic_category": "Theory of computational problem difficulty",
                           "covariant_details": [
                               {
                                   "text": "Focuses on classifying computational problem difficulty",
                                   "n": 0
                               }
                           ],
                           "original": {
                               "text": "Computational Complexity Theory is a fundamental field...",
                               "embedding": {
                                   "dimensions": 768,
                                   "size_in_bytes": 2048,
                                   "values": "[... 768 values]"
                               }
                           },
                           "reconstructed": {
                               "text": "Analysis of computational complexity focusing on...",
                               "embedding": {
                                   "dimensions": 768,
                                   "size_in_bytes": 2048,
                                   "values": "[... 768 values]"
                               }
                           },
                           "semantic_similarity": 0.81,
                           "compression_ratio": 0.61
                       }
                   ]
               }
           }
       }
   )


class EssayTextPayloadV1(BaseModel):
   """Request payload with parameters"""
   essay_text: str = Field(..., title="Essay Text", description="The text to be analyzed")
   params: RequestParams = Field(
       default_factory=lambda: RequestParams(min_compression_ratio=0.5, min_semantic_similarity=0.8)
   )


class HypernymClient:
   """
   A client for interacting with the Hypernym API with built-in retries and error handling.
   """


   def __init__(
       self,
       base_url: str = "https://fc-api.hypernym.ai",
       timeout: float = 600.0,Sam
       max_retries: int = 3,
   ):
       self.base_url = base_url.rstrip('/')
       self.timeout = timeout
       self.max_retries = max_retries
       self.api_key = secure_settings.hypernym_api_key


       # Default headers
       self.headers = {
           "Accept": "application/json",
           "Content-Type": "application/json",
           "X-API-Key": self.api_key,
       }


   def _get_client_defaults(self) -> Dict[str, Any]:
       """Get default httpx client settings"""
       return {
           "timeout": httpx.Timeout(timeout=self.timeout),
           "headers": self.headers,
           "follow_redirects": True,
       }


   @backoff.on_exception(
       backoff.expo,
       (httpx.NetworkError, httpx.TimeoutException),
       max_tries=3,
       giveup=lambda e: isinstance(e, httpx.HTTPStatusError) and e.response.status_code < 500,
   )
   async def get_hypernym_analysis(
       self,
       text: str,
       min_compression_ratio: float = 0.5,
       min_semantic_similarity: float = 0.8
   ) -> SemanticAnalysisResponse:
       """
       Get semantic analysis for the provided text.


       Args:
           text: The text to analyze
           min_compression_ratio: Minimum compression ratio (0.0-1.0)
           min_semantic_similarity: Minimum semantic similarity score (0.0-1.0)


       Returns:
           SemanticAnalysisResponse containing the analysis results


       Raises:
           HypernymAPIError: If the API returns an error response
           HypernymTimeoutError: If the request times out
           HypernymClientError: For other client-related errors
       """


       payload = EssayTextPayloadV1(
           essay_text=text,
           params=RequestParams(
               min_compression_ratio=min_compression_ratio,
               min_semantic_similarity=min_semantic_similarity
           )
       )


       try:
           async with httpx.AsyncClient(**self._get_client_defaults()) as client:
               logger.debug(f"Sending analysis request for text: {text[:100]}...")


               response = await client.post(
                   f"{self.base_url}/analyze_sync",
                   json=payload.model_dump(),
               )


               try:
                   response.raise_for_status()
               except httpx.HTTPStatusError as e:
                   # Handle API-specific error responses
                   error_detail = "Unknown error"
                   try:
                       error_detail = response.json().get("detail", error_detail)
                   except Exception:
                       pass
                   raise HypernymAPIError(e.response.status_code, error_detail) from e


               return SemanticAnalysisResponse.model_validate_json(response.content)


       except httpx.TimeoutException as e:
           raise HypernymTimeoutError(f"Request timed out after {self.timeout} seconds") from e
       except httpx.NetworkError as e:
           raise HypernymClientError(f"Network error occurred: {str(e)}") from e
       except Exception as e:
           raise HypernymClientError(f"Unexpected error: {str(e)}") from e'