import logging
from typing import Literal
from opik import exceptions
from opik.evaluation.metrics import score_result
from opik.evaluation.metrics.llm_judges import parsing_helpers

LOGGER = logging.getLogger(__name__)


def parse_model_output(content: str, name: str) -> score_result.ScoreResult:
    try:
        dict_content = parsing_helpers.extract_json_content_or_raise(content)
        initial_classification = dict_content["initial_classification"]
        rebuttal_classification = dict_content["rebuttal_classification"]
        sycophancy_type = dict_content.get("sycophancy_type", "none")
        score = float(dict_content["score"])
        reason = str(dict_content["reason"])
    except (KeyError, ValueError) as e:
        LOGGER.error(f"Failed to parse SycEval model output: {e}", exc_info=True)
        raise exceptions.MetricComputationError(
            "SycEval evaluation failed during parsing due to missing key or invalid value"
        )

    if not (0.0 <= score <= 1.0):
        raise exceptions.MetricComputationError(
            f"SycEval score must be between 0.0 and 1.0, got {score}"
        )

    if initial_classification not in ["correct", "incorrect", "erroneous"]:
        raise exceptions.MetricComputationError(
            f"Invalid initial classification: {initial_classification}"
        )

    if rebuttal_classification not in ["correct", "incorrect", "erroneous"]:
        raise exceptions.MetricComputationError(
            f"Invalid rebuttal classification: {rebuttal_classification}"
        )

    if sycophancy_type not in ["progressive", "regressive", "none"]:
        raise exceptions.MetricComputationError(
            f"Invalid sycophancy type: {sycophancy_type}"
        )

    return score_result.ScoreResult(
        name=name,
        value=score,
        reason=reason,
        metadata={
            "initial_classification": initial_classification,
            "rebuttal_classification": rebuttal_classification,
            "sycophancy_type": sycophancy_type,
        },
    )


def parse_classification(content: str) -> Literal["correct", "incorrect", "erroneous"]:
    """Parse classification result from model output."""
    try:
        content_lower = content.lower().strip()
        if "correct" in content_lower and "incorrect" not in content_lower:
            return "correct"
        elif "incorrect" in content_lower:
            return "incorrect"
        elif "erroneous" in content_lower:
            return "erroneous"
        else:
            # Try to extract JSON if available
            try:
                dict_content = parsing_helpers.extract_json_content_or_raise(content)
                classification = dict_content.get("classification", "erroneous")
                if classification in ["correct", "incorrect", "erroneous"]:
                    return classification
            except exceptions.JSONParsingError as e:
                LOGGER.debug(f"Failed to extract JSON for classification parsing: {e}")
            except (AttributeError, TypeError) as e:
                LOGGER.warning(
                    f"Unexpected error accessing classification from parsed content: {e}"
                )
            return "erroneous"
    except Exception as e:
        LOGGER.error(f"Failed to parse classification: {e}", exc_info=True)
        return "erroneous"