from app.db.models import TeamDefinition, TeamRun, TeamVersion
from app.domain.repositories import (
    TeamDefinitionRepository,
    TeamRunRepository,
    TeamVersionRepository,
)
from app.schemas.team import (
    TeamCreateRequest,
    TeamRunCreateRequest,
    TeamRunStatusUpdateRequest,
    TeamStatusUpdateRequest,
    TeamVersionCreateRequest,
)


class TeamApplicationService:
    def __init__(
        self,
        *,
        team_repository: TeamDefinitionRepository,
        team_version_repository: TeamVersionRepository,
        team_run_repository: TeamRunRepository,
    ) -> None:
        self.team_repository = team_repository
        self.team_version_repository = team_version_repository
        self.team_run_repository = team_run_repository

    def create_team(self, payload: TeamCreateRequest) -> TeamDefinition:
        return self.team_repository.create(
            tenant_id=payload.tenant_id,
            code=payload.code,
            name=payload.name,
            description=payload.description,
            team_type=payload.team_type,
            owner_user_id=payload.owner_user_id,
            metadata_json=payload.metadata_json,
        )

    def list_teams(self, *, tenant_id: str) -> list[TeamDefinition]:
        return self.team_repository.list_by_tenant(tenant_id=tenant_id)

    def update_team_status(
        self,
        *,
        team_id: str,
        payload: TeamStatusUpdateRequest,
    ) -> TeamDefinition | None:
        return self.team_repository.update_status(
            tenant_id=payload.tenant_id,
            team_id=team_id,
            status=payload.status,
        )

    def create_team_version(self, payload: TeamVersionCreateRequest) -> TeamVersion:
        team = self.team_repository.get_by_id(tenant_id=payload.tenant_id, team_id=payload.team_id)
        if team is None:
            raise ValueError(f"team not found: {payload.team_id}")
        if not payload.member_refs:
            raise ValueError("team version requires at least one member")

        return self.team_version_repository.create(
            tenant_id=payload.tenant_id,
            team_id=payload.team_id,
            status=payload.status,
            coordination_mode=payload.coordination_mode,
            objective=payload.objective,
            member_refs_json=[item.model_dump(mode="json") for item in payload.member_refs],
            policy_json=payload.policy_json,
        )

    def list_team_versions(self, *, tenant_id: str, team_id: str) -> list[TeamVersion]:
        return self.team_version_repository.list_by_team(tenant_id=tenant_id, team_id=team_id)

    def create_team_run(self, payload: TeamRunCreateRequest) -> TeamRun:
        team_version = self._resolve_team_version(
            tenant_id=payload.tenant_id,
            team_id=payload.team_id,
            team_version_id=payload.team_version_id,
        )
        if team_version is None:
            raise ValueError("published team version not found")

        return self.team_run_repository.create(
            tenant_id=payload.tenant_id,
            team_id=payload.team_id,
            team_version_id=team_version.id,
            session_id=payload.session_id,
            input_text=payload.input_text,
            input_json=payload.input_json,
        )

    def list_team_runs(
        self,
        *,
        tenant_id: str,
        team_id: str | None = None,
        session_id: str | None = None,
    ) -> list[TeamRun]:
        return self.team_run_repository.list_by_scope(
            tenant_id=tenant_id,
            team_id=team_id,
            session_id=session_id,
        )

    def update_team_run_status(
        self,
        *,
        team_run_id: str,
        payload: TeamRunStatusUpdateRequest,
    ) -> TeamRun | None:
        entity = self.team_run_repository.get_by_id(
            tenant_id=payload.tenant_id,
            team_run_id=team_run_id,
        )
        if entity is None:
            return None
        return self.team_run_repository.update_status(
            team_run_id=team_run_id,
            status=payload.status,
            worker_key=payload.worker_key,
            output_text=payload.output_text,
            output_json=payload.output_json,
            error_code=payload.error_code,
            error_message=payload.error_message,
        )

    def _resolve_team_version(
        self,
        *,
        tenant_id: str,
        team_id: str,
        team_version_id: str | None,
    ) -> TeamVersion | None:
        if team_version_id is not None:
            return self.team_version_repository.get_by_id(
                tenant_id=tenant_id,
                team_version_id=team_version_id,
            )
        return self.team_version_repository.get_latest_published(
            tenant_id=tenant_id,
            team_id=team_id,
        )