"""Shared competition-source helpers for League and Federation fixtures."""
from __future__ import annotations

from dataclasses import dataclass

from django.db import transaction

from federations.constants import CompetitionStatus
from federations.models import FederationCompetition
from leagues.constants import LeagueCompetitionStatus
from leagues.models import LeagueCompetition

from .exceptions import MatchNotFoundError
from .models import Match


@dataclass(frozen=True)
class LockedCompetitionSource:
    kind: str
    competition: object
    match: Match

    @property
    def season(self):
        return self.competition.season


@transaction.atomic
def lock_competition_source_and_match(match_id) -> LockedCompetitionSource:
    try:
        source_ids = Match.objects.values(
            "fixture__competition_id",
            "fixture__federation_competition_id",
        ).get(pk=match_id)
    except Match.DoesNotExist as exc:
        raise MatchNotFoundError("Match does not exist.") from exc

    league_id = source_ids["fixture__competition_id"]
    federation_id = source_ids["fixture__federation_competition_id"]
    if bool(league_id) == bool(federation_id):
        raise MatchNotFoundError("Match fixture has an invalid competition source.")

    if league_id:
        competition = (
            LeagueCompetition.objects.select_for_update()
            .select_related("season", "league")
            .get(pk=league_id)
        )
        kind = "LEAGUE"
    else:
        competition = (
            FederationCompetition.objects.select_for_update(of=("self", "federation"))
            .select_related("season", "federation")
            .get(pk=federation_id)
        )
        kind = "FEDERATION"

    try:
        match = (
            # Fixture is mandatory; competition/federation_competition are mutually
            # exclusive nullable relations. PostgreSQL cannot FOR UPDATE the
            # nullable side of these outer joins. Both competition rows are
            # already independently locked above. Keep the historical lock
            # coverage for Match and its non-null Fixture only.
            Match.objects.select_for_update(of=("self", "fixture"))
            .select_related("fixture")
            .get(pk=match_id)
        )
    except Match.DoesNotExist as exc:
        raise MatchNotFoundError("Match does not exist.") from exc

    # The applicable source and its season were already fetched and locked above.
    # Rejoining both mutually exclusive branches on every kickoff assignment adds
    # avoidable nullable joins to hundreds of identical lock queries.
    source_field = "competition" if league_id else "federation_competition"
    if getattr(match.fixture, f"{source_field}_id") != competition.pk:
        raise MatchNotFoundError("Match competition source changed during locking.")
    match.fixture._state.fields_cache[source_field] = competition

    return LockedCompetitionSource(kind=kind, competition=competition, match=match)


def competition_is_schedulable(source: LockedCompetitionSource) -> bool:
    if source.kind == "LEAGUE":
        return source.competition.status in {
            LeagueCompetitionStatus.SCHEDULED,
            LeagueCompetitionStatus.ACTIVE,
        }
    return source.competition.status == CompetitionStatus.ACTIVE


def competition_is_startable(source: LockedCompetitionSource) -> bool:
    return competition_is_schedulable(source)


def mark_started_if_needed(source: LockedCompetitionSource, *, now) -> None:
    if source.kind == "LEAGUE":
        if source.competition.status == LeagueCompetitionStatus.SCHEDULED:
            source.competition.status = LeagueCompetitionStatus.ACTIVE
            source.competition.started_at = now
            source.competition.save(update_fields=["status", "started_at", "updated_at"])
        return

    if source.competition.started_at is None:
        source.competition.started_at = now
        source.competition.save(update_fields=["started_at", "updated_at"])
