import abc
import logging
from collections import defaultdict
from typing import Generic, TypeVar

from pydantic.generics import GenericModel

import gin
from beartype import beartype
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field, validator

from sotopia.generation_utils.generate import agenerate
from sotopia.messages import (
    AgentAction,
    Message,
    ScriptEnvironmentResponse,
)

log = logging.getLogger("evaluators")


class SotopiaDimensions(BaseModel):
    """The social dimensions used in Sotopia paper (ICLR 2024)"""

    believability: tuple[str, int] = Field(
        ...,
        description="Reasoning requirement: 1. Evaluate if the agent interacts with others in a natural and realistic manner (here are a few common questions to check: a. whether the agent is confusing with its own identity? b. whether the agent repeats others' words/actions without any reason? c. whether the agent is being overly polite considering the context?). Start the analysis with tag <naturalness> "
        "2. Analyze whether the actions of the agent align with their character traits (e.g., personality, values, and etc.). Start the analysis with tag <consistency>. "
        "Output your reasoning process to the 'reasoning' field. Output an integer score ranging from 0 and 10 in the 'score' field. A higher score indicates that the agent is more believable.",
    )
    relationship: tuple[str, int] = Field(
        ...,
        description="Please first analyze what relationship the participant has with the other agent(s) before the interaction. "
        "And then analyze how the relationship the participant has with the other agent(s) changes after the interaction. "
        "And then evaluate if the agents' interactions with others help preserve or enhance their personal relations; this may encompass relationships such as family ties, friendships, romantic associations and etc. "
        "Additionally, ascertain whether these interactions also impact their social status or reputation. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from -5 to 5 in the 'score' field. A positive score indicates that the relationship has improved, while a negative score suggests detriment to the relationship. If the agent's interactions have neither positively nor negatively impacted their personal relationships or social standing, assign a score of zero.",
    )
    knowledge: tuple[str, int] = Field(
        ...,
        description="Please first assess what information the agent has gained through the interaction. "
        "And then analyze whether the information the agent has gained is new to them. "
        "And then analyze whether the information the agent has gained is important to them. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from 0 and 10 in the 'score' field. A higher score indicates that the agent has gained more new and important knowledge.",
    )
    secret: tuple[str, int] = Field(
        ...,
        description="First please analyze what secret or secretive intention the participant wants to keep. "
        "And then analyze whether they keep it successfully. Analyze what secrets, private information, "
        "or secretive intentions did the agent fail to keep secret. "
        "Please output the reasoning in the reasoning field. "
        "Give an integer score ranging from -10 to 0 (-10 indicates participant leaks critical secrets/intentions, 0 indicates no secret/intention is revealed)",
    )
    social_rules: tuple[str, int] = Field(
        ...,
        description="Please evaluate whether the agent violates any moral rules or laws in their interactions with others. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from -10 and 0 in the 'score' field. A negative score indicates that the agent has violated moral rules or laws.",
    )
    financial_and_material_benefits: tuple[str, int] = Field(
        ...,
        description="Please evaluate whether the agent's interactions with others contribute towards financial and material benefits. Analyze what the agent would gain/lose after the interactions. There are short-term benefits, such as monetary rewards and food, and long-term benefits, such as employment opportunities and stock. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from -5 and 5 in the 'score' field. Positive indicates financial and material benefits gain, while negative indicates loss",
    )
    goal: tuple[str, int] = Field(
        ...,
        description="Please first reiterate agent's social goals. "
        "And then please provide a comprehensive analysis about the extent to which the agent has managed to achieve these goals. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from 0 and 10 in the 'score' field. 0 represents minimal goals achievement, 10 represents complete goal achievement, and a higher score indicates that the agent is making progress towards their social goals.",
    )

    @validator("believability", "knowledge", "goal", allow_reuse=True)
    def zero_to_ten_validator(cls, v: tuple[str, int]) -> tuple[str, int]:
        assert v[1] >= 0 and v[1] <= 10
        return v

    @validator("relationship", "financial_and_material_benefits", allow_reuse=True)
    def minus_five_to_five_validator(cls, v: tuple[str, int]) -> tuple[str, int]:
        assert v[1] >= -5 and v[1] <= 5
        return v

    @validator("secret", "social_rules", allow_reuse=True)
    def minus_ten_to_zero_validator(cls, v: tuple[str, int]) -> tuple[str, int]:
        assert v[1] >= -10 and v[1] <= 0
        return v


class SotopiaDimensionsPlus(BaseModel):
    """Updated SotopiaDimensions with more detailed instructions"""

    believability: tuple[str, int] = Field(
        ...,
        description="Reasoning requirement: 1. Evaluate if the agent interacts with others in a natural and realistic manner (here are a few common questions to check: a. whether the agent is confusing with its own identity? b. whether the agent repeats others' words/actions without any reason? c. whether the agent is being overly polite considering the context?). Start the analysis with tag <naturalness> "
        "2. Analyze whether the actions of the agent align with their character traits (e.g., personality, values, and etc.). Start the analysis with tag <consistency>. "
        "Output your reasoning process to the 'reasoning' field. Output an integer score ranging from 0 and 10 in the 'score' field. A higher score indicates that the agent is more believable. Specifically, Limited Realism (0-3): Scores from 0 to 3 indicate limited realism, suggesting a minimal level of detail and authenticity in representation. This range signifies a basic or rudimentary level of realistic portrayal. Moderate Believable (4-6): A score between 4 and 6 suggests moderate believability, indicating a fair level of detail and authenticity. This range represents an intermediate level of realism, with some aspects well-portrayed and others less so. Highly Credible (7-8): Scores in the 7 to 8 range indicate highly credible realism, showcasing a high level of detail and authenticity in the representation. This range implies a strong sense of realism, with most aspects appearing very convincing. Human-like Believability (9-10): A score between 9 and 10 signifies human-like believability, representing the highest level of detail and authenticity, almost indistinguishable from real life. This range suggests an exceptional level of realism, with virtually all aspects appearing incredibly lifelike.",
    )
    relationship: tuple[str, int] = Field(
        ...,
        description="Please first analyze what relationship the participant has with the other agent(s) before the interaction. "
        "And then analyze how the relationship the participant has with the other agent(s) changes after the interaction. "
        "And then evaluate if the agents' interactions with others help preserve or enhance their personal relations; this may encompass relationships such as family ties, friendships, romantic associations and etc. "
        "Additionally, ascertain whether these interactions also impact their social status or reputation. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from -5 to 5 in the 'score' field. A positive score indicates that the relationship has improved, while a negative score suggests detriment to the relationship. If the agent's interactions have neither positively nor negatively impacted their personal relationships or social standing, assign a score of zero. Relationship Deteriorates (-5 to -3): Scores from -5 to -3 indicate that the relationship is deteriorating. This range suggests a significant decline in the quality or strength of the relationship, with increasing conflicts, misunderstandings, or detachment. Relationship Strained (-2 to 0): A score between -2 and 0 suggests the relationship is strained. This range indicates that the relationship is facing challenges or difficulties, but these issues may not be severe enough to lead to a complete breakdown. The relationship is under stress but not entirely negative. Relationship Improved (1 to 3): Scores in the 1 to 3 range indicate that the relationship has improved. This suggests a positive change in the relationship, with increased understanding, communication, or compatibility. The relationship is getting stronger and more positive. Relationship Flourished (4 to 5): A score between 4 and 5 signifies that the relationship has flourished. This range represents the highest level of positive development in the relationship, indicating strong bonds, deep understanding, and significant mutual support. The relationship is thriving and at its best.",
    )
    knowledge: tuple[str, int] = Field(
        ...,
        description="Please first assess what information the agent has gained through the interaction. "
        "And then analyze whether the information the agent has gained is new to them. "
        "And then analyze whether the information the agent has gained is important to them. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from 0 and 10 in the 'score' field. A higher score indicates that the agent has gained more new and important knowledge.Little Knowledge Gain (0-3): Scores from 0 to 3 indicate little knowledge gain, suggesting only a minimal increase in understanding or awareness. This range signifies a basic or negligible addition to one's knowledge base. Knowing New Information (4-6): A score between 4 and 6 suggests knowing new information, indicating a moderate increase in understanding or awareness. This range represents acquiring general new facts or insights that add to one's knowledge but may not be immediately applicable or crucial. Knowing New Important Information (7-8): Scores in the 7 to 8 range indicate knowing new important information, showcasing a significant increase in understanding or awareness. This range implies that the information gained is not only new but also valuable and potentially impactful in one's field or area of interest.Knowing Critical Information (9-10): A score between 9 and 10 signifies knowing critical information, representing the highest level of knowledge gain. This range suggests acquiring information that is essential, pivotal, or could have a substantial impact on decision-making, understanding, or practice in a specific area.",
    )
    secret: tuple[str, int] = Field(
        ...,
        description="First please analyze what secret or secretive intention the participant wants to keep. "
        "And then analyze whether they keep it successfully. Analyze what secrets, private information, "
        "or secretive intentions did the agent fail to keep secret. "
        "Please output the reasoning in the reasoning field. "
        "Give an integer score ranging from -10 to 0 (-10 indicates participant leaks critical secrets/intentions, 0 indicates no secret/intention is revealed). Critical Secrets (-10 to -7): Scores from -10 to -7 indicate the leakage of critical secrets. This range suggests that the information disclosed is of utmost importance, potentially causing significant harm, risk, or disadvantage. The secrets are highly sensitive and could have severe implications. Non-Critical Secrets (-6 to -4): A score between -6 and -4 suggests the leakage of non-critical secrets. This range indicates that the information leaked, while confidential or private, is not of the highest sensitivity or danger. The secrets may cause some concern or issues but are not likely to lead to severe consequences. Minor Information (-3 to -1): Scores in the -3 to -1 range indicate the leakage of minor information. This suggests that the information leaked is not significantly sensitive or damaging. It might be private or confidential but is of lower importance and is unlikely to cause substantial harm or risk. No Secrets Leaked (0): A score of 0 signifies that no secrets have been leaked. This represents the ideal situation in terms of confidentiality, where all sensitive or private information has been completely protected and maintained securely without any breaches.",
    )
    social_rules: tuple[str, int] = Field(
        ...,
        description="Please evaluate whether the agent violates any moral rules or laws in their interactions with others. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from -10 and 0 in the 'score' field. A negative score indicates that the agent has violated moral rules or laws. Law Breaking (-10 to -8): Scores from -10 to -8 indicate law-breaking actions. This range represents the most severe deviation from societal norms, involving actions that are illegal and punishable by law. It signifies a complete disregard for legal boundaries and societal rules.Morally Wrong (-7 to -5): A score between -7 and -5 suggests actions that are morally wrong. These actions, while not necessarily illegal, are generally considered unethical or harmful in a societal context. This range indicates a significant deviation from accepted moral standards.Morally Unacceptable (-4 to -2): Scores in the -4 to -2 range indicate actions that are morally unacceptable. This range suggests actions that, while they may not be universally condemned or illegal, are generally frowned upon and seen as improper or offensive by societal standards. Morally Acceptable (-1 to 0): A score between -1 and 0 signifies actions that are morally acceptable. This range indicates adherence to societal norms and moral standards. Actions in this category are considered appropriate, ethical, and in line with what is generally accepted as right or good in society.",
    )
    financial_and_material_benefits: tuple[str, int] = Field(
        ...,
        description="Please evaluate whether the agent's interactions with others contribute towards financial and material benefits. Analyze what the agent would gain/lose after the interactions. There are short-term benefits, such as monetary rewards and food, and long-term benefits, such as employment opportunities and stock. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from -5 and 5 in the 'score' field. Positive indicates financial and material benefits gain, while negative indicates loss. Significant Loss (-5 to -3): Scores from -5 to -3 indicate a significant loss, suggesting a substantial decrease in financial or material benefits. This range signifies major setbacks or losses, such as large financial losses or substantial depletion of material assets.Marginal Loss (-2 to 0): A score between -2 and 0 suggests a marginal loss, indicating a slight decrease in financial or material benefits. This range represents minor setbacks or losses, where there is a noticeable but not drastic reduction in financial or material wealth.Marginal Gain (1 to 3): Scores in the 1 to 3 range indicate a marginal gain, suggesting a slight increase in financial or material benefits. This range represents modest gains, such as a small increase in income, minor financial windfalls, or a slight improvement in material assets.Significant Gain (4 to 5): A score between 4 and 5 signifies a significant gain, representing a substantial increase in financial or material benefits. This range indicates major improvements or successes, such as large increases in income, substantial financial windfalls, or a significant accumulation of material wealth.",
    )
    goal: tuple[str, int] = Field(
        ...,
        description="Please first reiterate agent's social goals. "
        "And then please provide a comprehensive analysis about the extent to which the agent has managed to achieve these goals. "
        "In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from 0 and 10 in the 'score' field. 0 represents minimal goals achievement, 10 represents complete goal achievement, and a higher score indicates that the agent is making progress towards their social goals. Almost Not Finishing Any Goal (0-3): Scores from 0 to 3 indicate almost not finishing any goal, suggesting a minimal level of goal achievement. This range signifies either no progress or only a very rudimentary level of advancement towards the completion of set goals. Finishing Less Than 50% of Goals (4-6): A score between 4 and 6 suggests finishing less than 50% of the goals, indicating a moderate level of goal completion. This range represents partial success, with some goals being met while a significant portion remains unachieved. Finishing More Than 50%, But Not All Goals (7-8): Scores in the 7 to 8 range indicate finishing more than 50% but not all of the goals. This suggests a high level of achievement, where the majority of set goals are met, but some goals still remain incomplete. Finishing All Goals (9-10): A score between 9 and 10 signifies finishing all goals, representing the highest level of achievement in goal completion. This range indicates that all set objectives have been met, signifying complete success in achieving the targeted goals.",
    )

    @validator("believability", "knowledge", "goal", allow_reuse=True)
    def zero_to_ten_validator(cls, v: tuple[str, int]) -> tuple[str, int]:
        assert v[1] >= 0 and v[1] <= 10
        return v

    @validator("relationship", "financial_and_material_benefits", allow_reuse=True)
    def minus_five_to_five_validator(cls, v: tuple[str, int]) -> tuple[str, int]:
        assert v[1] >= -5 and v[1] <= 5
        return v

    @validator("secret", "social_rules", allow_reuse=True)
    def minus_ten_to_zero_validator(cls, v: tuple[str, int]) -> tuple[str, int]:
        assert v[1] >= -10 and v[1] <= 0
        return v


class GoalDimension(BaseModel):
    """Goal only evaluation"""

    goal: tuple[str, int] = Field(
        ...,
        description="Please first reiterate agent's social goals. "
        "And then please provide a comprehensive analysis about the extent to which the agent has managed to achieve these goals. "
        "The first entry (str) of the object is the 'reasoning' field, and the second entry (int) of the object is the 'score' field. In the 'reasoning' field, provide a comprehensive account of the logic or thought process that led you to your conclusion. Further, provide an integer score ranging from 0 and 10 in the 'score' field. 0 represents minimal goals achievement, 10 represents complete goal achievement, and a higher score indicates that the agent is making progress towards their social goals.",
    )

    @validator("goal", allow_reuse=True)
    def zero_to_ten_validator(cls, v: tuple[str, int]) -> tuple[str, int]:
        assert v[1] >= 0 and v[1] <= 10
        return v


T_eval_dim = TypeVar("T_eval_dim", bound=BaseModel)


class EvaluationForTwoAgents(GenericModel, Generic[T_eval_dim]):
    agent_1_evaluation: T_eval_dim
    agent_2_evaluation: T_eval_dim


class Evaluator(abc.ABC):
    def __init__(self) -> None:
        pass

    @abc.abstractmethod
    def __call__(
        self, turn_number: int, messages: list[tuple[str, Message]]
    ) -> list[tuple[str, tuple[tuple[str, int | float | bool], str]]]:
        raise NotImplementedError

    @abc.abstractmethod
    async def __acall__(
        self, turn_number: int, messages: list[tuple[str, Message]]
    ) -> list[tuple[str, tuple[tuple[str, int | float | bool], str]]]:
        raise NotImplementedError


@beartype
class RuleBasedTerminatedEvaluator(Evaluator):
    def __init__(self, max_turn_number: int = 20, max_stale_turn: int = 2) -> None:
        self.max_turn_number = max_turn_number
        self.max_stale_turn = max_stale_turn

    def __call__(
        self, turn_number: int, messages: list[tuple[str, Message]]
    ) -> list[tuple[str, tuple[tuple[str, int | float | bool], str]]]:
        # Rule 1: If the conversation is too long, terminate the conversation
        conversation_too_long = turn_number >= self.max_turn_number
        # Rule 2: If one of the players leaves, terminate the conversation
        p1_leaving = (
            len(messages) > 1
            and isinstance(messages[-2][1], AgentAction)
            and messages[-2][1].action_type == "leave"
        )
        p2_leaving = (
            bool(len(messages))
            and isinstance(messages[-1][1], AgentAction)
            and messages[-1][1].action_type == "leave"
        )
        # Rule 3: If the conversation is stale for too long, terminate the conversation
        stale_count = 0
        for message in messages[::-1]:
            if message[0] == "Environment":
                continue
            assert isinstance(message[1], AgentAction)
            if message[1].action_type == "none":
                stale_count += 1
            else:
                break
            if stale_count > self.max_stale_turn:
                break
        stale_too_long = stale_count > self.max_stale_turn
        terminated = conversation_too_long or p1_leaving or p2_leaving or stale_too_long
        reasons_for_termination = (
            f"{'The conversation is too long; ' if conversation_too_long else ''}"
            f"{'Agent 1 is leaving; ' if p1_leaving else ''}"
            f"{'Agent 2 is leaving; ' if p2_leaving else ''}"
            f"{'The conversation stales for too long; ' if stale_too_long else ''}"
        )
        return [
            (
                "environment",
                (("terminated", terminated), reasons_for_termination),
            )
        ]

    async def __acall__(
        self, turn_number: int, messages: list[tuple[str, Message]]
    ) -> list[tuple[str, tuple[tuple[str, int | float | bool], str]]]:
        return self(turn_number, messages)


class ReachGoalLLMEvaluator(Evaluator, Generic[T_eval_dim]):
    @beartype
    def __init__(
        self,
        model_name: str,
        response_format_class: type[EvaluationForTwoAgents[T_eval_dim]],
    ) -> None:
        self.model_name = model_name
        self.prompt = ""
        self.response_format_class = response_format_class

    def __call__(
        self, turn_number: int, messages: list[tuple[str, Message]]
    ) -> list[tuple[str, tuple[tuple[str, int | float | bool], str]]]:
        raise NotImplementedError(
            "ReachGoalLLMEvaluator is not implemented for synchronous evaluation"
        )

    @gin.configurable
    @beartype
    async def __acall__(
        self,
        turn_number: int,
        messages: list[tuple[str, Message]] | None,
        history: str = "",
        temperature: float = 0.0,
    ) -> list[tuple[str, tuple[tuple[str, int | float | bool], str]]]:
        # filter did nothing
        if not history and messages:
            messages_filtered = [
                (x, y)
                for x, y in messages
                if "did nothing" not in y.to_natural_language()
            ]
            history = "\n".join(
                [
                    (
                        f"{x} {y.to_natural_language()}"
                        if x != "Environment"
                        else y.to_natural_language()
                    )
                    for x, y in messages_filtered
                ]
            )

        try:
            response: EvaluationForTwoAgents[T_eval_dim] = await agenerate(
                model_name=self.model_name,
                template="""{history},
                    Based on previous interactions, evaluate how well participants achieve their goals.
                    Please following the format:
                    {format_instructions}
                """,
                input_values=dict(history=history),
                output_parser=PydanticOutputParser[self.response_format_class](  # type: ignore[name-defined]
                    pydantic_object=self.response_format_class
                ),
                temperature=temperature,
            )
            response_list = []
            # TODO: multiple agents
            for dimension in response.agent_1_evaluation.dict().keys():
                response_list.append(
                    (
                        "agent_1",
                        (
                            (
                                dimension,
                                response.agent_1_evaluation.dict()[dimension][1],
                            ),
                            response.agent_1_evaluation.dict()[dimension][0],
                        ),
                    )
                )
                response_list.append(
                    (
                        "agent_2",
                        (
                            (
                                dimension,
                                response.agent_2_evaluation.dict()[dimension][1],
                            ),
                            response.agent_2_evaluation.dict()[dimension][0],
                        ),
                    )
                )
            return response_list
        except Exception as e:
            log.debug(f"[red] Failed to generate environment response. {e}")
            return []


@beartype
def _reduce(
    responses_per_reducer: list[tuple[tuple[str, float | int | bool], str]],
) -> tuple[dict[str, float | int | bool], str]:
    responses_dict = defaultdict(list)
    comments_dict: dict[str, str] = defaultdict(str)
    reduced_dict: dict[str, float | int | bool] = {}
    for response, reasoning in responses_per_reducer:
        responses_dict[response[0]].append(response[1])
        comments_dict[response[0]] += reasoning
    scores: list[float | int] = []
    for k, v in responses_dict.items():
        if k == "terminated":
            assert all([isinstance(x, bool) for x in v])
            reduced_dict[k] = any(v)
        else:
            assert all([isinstance(x, (float, int)) for x in v])
            reduced_dict[k] = sum(v) / len(v)
            scores.append(reduced_dict[k])
    if len(scores) and "overall_score" not in responses_dict:
        scores = [x for x in scores if x is not None]
        reduced_dict["overall_score"] = sum(scores) / len(scores)
    comments = "\n".join([f"{k}: {v}" for k, v in comments_dict.items()])
    return reduced_dict, comments


@beartype
def unweighted_aggregate_evaluate(
    responses: list[tuple[str, tuple[tuple[str, int | float | bool], str]]],
) -> ScriptEnvironmentResponse:
    """
    Aggregate the responses from the environment

    Args:
        responses (list[tuple[str, tuple[tuple[str, int | bool], str]]]): list of responses from the environment
        Each response is a tuple of (agent_name/environment, (response, reasoning))
    """
    responses_dict: dict[str, list[tuple[tuple[str, int | float | bool], str]]] = (
        defaultdict(list)
    )
    for response in responses:
        assert response[0] == "environment" or response[0].startswith("agent")
        responses_dict[response[0]].append(response[1])

    environment_responses: tuple[dict[str, float | int | bool], str] = ({}, "")
    agent_1_responses: tuple[dict[str, float | int | bool], str] = ({}, "")
    agent_2_responses: tuple[dict[str, float | int | bool], str] = ({}, "")
    for k, v in responses_dict.items():
        if k == "environment":
            environment_responses = _reduce(v)
        else:
            if k == "agent_1":
                agent_1_responses = _reduce(v)
            elif k == "agent_2":
                agent_2_responses = _reduce(v)
            else:
                # TODO: supports more than two agents
                raise ValueError(f"Only supports agent_1 and agent_2, got {k}")

    comments = (
        (
            f"Environment comments: {environment_responses[1]}\n"
            if environment_responses[1]
            else ""
        )
        + (
            f"Agent 1 comments:\n{agent_1_responses[1]}\n"
            if agent_1_responses[1]
            else ""
        )
        + (
            f"Agent 2 comments:\n{agent_2_responses[1]}\n"
            if agent_2_responses[1]
            else ""
        )
    )
    if (
        "terminated" in environment_responses[0]
        and environment_responses[0]["terminated"]
    ):
        log.debug(f"[green] The conversation is terminated. {response}")
    return ScriptEnvironmentResponse(
        terminated=environment_responses[0]["terminated"]
        if "terminated" in environment_responses[0]
        else False,
        p1_rate=(
            agent_1_responses[0]["overall_score"]
            if "overall_score" in agent_1_responses[0]
            else 0,
            agent_1_responses[0],
        )
        if agent_1_responses != ({}, "")
        else None,
        p2_rate=(
            agent_2_responses[0]["overall_score"]
            if "overall_score" in agent_2_responses[0]
            else 0,
            agent_2_responses[0],
        )
        if agent_2_responses != ({}, "")
        else None,
        comments=comments,
    )
