from math import floor
from typing import Tuple
from os.path import join, isfile
from dataclasses import dataclass
from importlib.resources import path
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine, not_
from match_up.utilities import (
    generate_guests,
    _init_database_from_csv,
    _init_random_database,
    _textualize_guest,
)
from match_up.data import (
    Player,
    DisplayPlayer,
    PLAYER_PER_COURT,
    BASE,
)


@dataclass
class CourtList:
    total: int = 12

    def __post_init__(self) -> None:
        self.courts = {i + 1: True for i in range(self.total)}

    def get_court_status(self, court_number: int) -> bool:
        return self.courts[court_number]

    def toggle_court_status(self, court_number: int) -> bool:
        new_status = not self.courts[court_number]
        self.courts[court_number] = new_status
        return new_status

    def get_courts(self) -> dict:
        return self.courts

    def separate_courts(self) -> Tuple[dict, dict]:
        active_courts = {k: v for k, v in self.courts.items() if v}
        inactive_courts = {k: v for k, v in self.courts.items() if not v}
        return active_courts, inactive_courts


class PlayerList:
    guest_count: dict = {1: 0, 3: 0, 5: 0}

    def __init__(self, csv_location=None) -> None:
        with path("match_up", "players.db") as p:
            self.db_location = p
        db_file_found = True
        if not isfile(self.db_location):
            db_file_found = False
        self._init_database()
        if csv_location is not None:
            _init_database_from_csv(self.session, csv_location)
        else:
            if not db_file_found:
                _init_random_database(self.session)

    def _init_database(self):
        engine = create_engine("sqlite:///" + str(self.db_location))
        BASE.metadata.create_all(bind=engine)
        self.session = sessionmaker(bind=engine)()

    def increment_guests(self, level: int):
        self.guest_count[level] = self.guest_count[level] + 1
        return _textualize_guest(level, self.guest_count[level])

    def decrement_guests(self, level: int):
        if self.guest_count[level] == 0:
            return 0
        self.guest_count[level] = self.guest_count[level] - 1
        return _textualize_guest(level, self.guest_count[level])

    def get_player_status(self, id: int) -> bool:
        return self.session.query(Player).filter(Player.id == id).first().status

    def toggle_player_status(self, id: int) -> DisplayPlayer:
        player = self.session.query(Player).filter(Player.id == id).first()
        player.status = not player.status
        self.session.commit()
        return DisplayPlayer(player)

    def get_all_players(self) -> list[DisplayPlayer]:
        all_players = [
            DisplayPlayer(p)
            for p in self.session.query(Player)
            .order_by(Player.first, Player.last)
            .all()
        ]
        return all_players

    def get_possible_game_count(self) -> int:
        total_players = len(self.get_players())
        possible_games = floor(total_players / PLAYER_PER_COURT)
        return possible_games

    def get_players(self) -> list[Player]:
        active_players = (
            self.session.query(Player)
            .order_by(Player.first, Player.last)
            .filter(not_(Player.status == 0))
            .all()
        )
        guests = generate_guests(self.guest_count)
        return active_players + guests

    def get_guests(self):
        return {
            level: _textualize_guest(level, self.guest_count[level])
            for level in self.guest_count
        }

    def increment_game_count(self, player_ids: list[int]):
        players = self.session.query(Player).filter(Player.id.in_(player_ids))
        for player in players:
            player.count += 1
        self.session.commit()

    def reset_game_count(self):
        players = self.session.query(Player)
        for player in players:
            player.count = 0
        self.session.commit()

    def reset_all_players(self):
        players = self.session.query(Player)
        for player in players:
            player.status = 0
        self.session.commit()