import pytest

from backend.model.student import Student
from backend.model.tribe import Tribe
from backend.repository.abstract_repository import AbstractRepository
from backend.repository.student_sqlite_repository import StudentRepositoryError
from backend.repository.tribe_sqlite_repository import TribeRepositoryError
from backend.service import services
from backend.service.services import TribeExists
from tests.model.fakes import build_tribes


class FakeTribeRepository(AbstractRepository):
    def __init__(self, tribes: list[Tribe] = []) -> None:
        self._tribes = {t.name: t for t in tribes}

    def add(self, tribe: Tribe) -> None:
        if tribe.name not in self._tribes.keys():
            self._tribes[tribe.name] = tribe
        else:
            raise TribeRepositoryError(f"{tribe} already exists")

    def update(self, name: str, tribe: Tribe) -> None:
        try:
            self._tribes.pop(name)
            self._tribes[tribe.name] = tribe
        except KeyError:
            raise TribeRepositoryError(f"The tribe {tribe} does not exists")

    def list(self) -> list[Tribe]:
        return list(self._tribes.values())

    def get(self, name: str) -> Tribe:
        try:
            return self._tribes[name]
        except KeyError:
            raise TribeRepositoryError(f"The tribe {tribe} does not exists")

    def delete(self, name: str) -> None:
        try:
            self._tribes.pop(name)
        except KeyError:
            raise KeyError(f"The tribe {tribe} does not exists")


class FakeStudentRepository(AbstractRepository):
    def __init__(self, students: list[Student] = []) -> None:
        self._students = {s.id: s for s in students}

    def add(self, student: Student) -> None:
        if student.id not in self._students.keys():
            self._students[student.id] = student
        raise StudentRepositoryError(f"{student} already exists")

    def update(self, id: str, student: Student) -> None:
        try:
            self._students.pop(id)
            self._students[student.id] = student
        except KeyError:
            raise StudentRepositoryError(f"The student {student} does not exists")

    def list(self) -> list[Student]:
        return list(self._students.values())

    def get(self, id: str) -> Student:
        try:
            return self._students[id]
        except KeyError:
            raise KeyError(f"The student {student} does not exists")

    def delete(self, id: str) -> None:
        try:
            self._students.pop(id)
        except KeyError:
            raise StudentRepositoryError(f"The student {student} does not exists")


class FakeConn:
    committed = False

    def commit(self):
        self.committed = True

    def reset_commit(self):
        self.committed = False


def test_add_tribe():
    tribe_repo = FakeTribeRepository()
    tribe = build_tribes(1)[0]
    conn = FakeConn()
    services.add_tribe(
        name=tribe.name, level=tribe.level, tribe_repo=tribe_repo, conn=conn
    )

    assert conn.committed == True
    assert tribe_repo.list() == [tribe]


def test_add_tribe_fail_exists():
    tribe_repo = FakeTribeRepository()
    tribe = build_tribes(1)[0]
    conn = FakeConn()
    services.add_tribe(
        name=tribe.name, level=tribe.level, tribe_repo=tribe_repo, conn=conn
    )
    conn.reset_commit()

    with pytest.raises(TribeExists):
        services.add_tribe(
            name=tribe.name, level=tribe.level, tribe_repo=tribe_repo, conn=conn
        )

    assert conn.committed == False