"""Independent federation allocation; least outstanding workload, random tie break."""
import secrets
from django.db.models import Count
from clubs.models import ClubSquadMembership
from federations.models import Federation, FederationAdminAssignment
from federations.region_selection import available_regions
from .friendly_models import FriendlyGame

OPEN_STATUSES = ['PROPOSED', 'FUNDED', 'APPROVED', 'RUNNING', 'REVIEW']


def context():
    regions = {r.pk:r for r in available_regions()}
    governors = dict(FederationAdminAssignment.objects.filter(
        role='GOVERNOR', is_active=True, user__is_active=True, federation_id__in=regions,
    ).values_list('federation_id', 'user_id'))
    player_clubs = {}
    for club_id, user_id in ClubSquadMembership.objects.filter(
        player__career__user_id__in=governors.values()
    ).values_list('club_id', 'player__career__user_id'):
        player_clubs.setdefault(club_id, set()).add(user_id)
    return regions, governors, player_clubs


def eligible_supervisors(clubs, *, data=None):
    regions, governors, player_clubs = data if data is not None else context()
    if any(c.regional_federation_id not in regions for c in clubs):
        return []
    participants = set()
    for club in clubs:
        participants.update([club.owner_id, club.coach_user_id])
        participants.update(player_clubs.get(club.pk, set()))
    return [region for pk, region in regions.items() if pk in governors and governors[pk] not in participants]


def choose_supervisor(clubs):
    from .friendlies import FriendlyError
    # Every proposal locks this one row until its assignment has been inserted.
    # Concurrent proposals therefore see each other's updated workload.
    if not Federation.objects.select_for_update().filter(federation_type='MOTHER', status='ACTIVE').first():
        raise FriendlyError('An active mother federation is required.')
    eligible = eligible_supervisors(clubs)
    if not eligible:
        raise FriendlyError('No active regional federation with an independent appointed governor can supervise this friendly.')
    loads = dict(FriendlyGame.objects.filter(federation_id__in=[f.pk for f in eligible],
                                            status__in=OPEN_STATUSES)
                 .values('federation_id').annotate(total=Count('pk')).values_list('federation_id','total'))
    minimum = min(loads.get(f.pk, 0) for f in eligible)
    tied = sorted([f for f in eligible if loads.get(f.pk,0) == minimum], key=lambda f:str(f.pk))
    selected = secrets.choice(tied)
    evidence = {'policy':'least-open-friendlies-random-tie-v1', 'minimum_open_games':minimum,
                'tied_federation_ids':[str(f.pk) for f in tied], 'selected_federation_id':str(selected.pk),
                'loads':{str(f.pk):loads.get(f.pk,0) for f in eligible}}
    return selected, evidence


def validate_supervisor(game, clubs):
    from .friendlies import FriendlyError
    if game.federation_id not in {f.pk for f in eligible_supervisors(clubs)}:
        raise FriendlyError('The selected federation or its independent governorship is no longer eligible; federation review is required.')
