from sqlite3 import Connection, Cursor
from database import SmartCursor
import random


class GameTableException(Exception):
    def __init__(self, message):
        super().__init__(self, message)


class GameTable:
    _game_table_id: int
    _game_table_name: str
    _game_table_link: str
    _active: bool
    _version: int
    _docker_id: str
    _created: bool
    _updated: bool
    _delete: bool

    def __init__(
        self,
        game_table_id: int,
        game_table_name: str,
        game_table_link: str,
        active: bool,
        version: int,
        docker_id: int,
        created: bool = False,
        updated: bool = False,
        delete: bool = False,
    ):
        self._game_table_id = game_table_id
        self._game_table_name = game_table_name
        self._game_table_link = game_table_link
        self._active = active
        self._version = version
        self._docker_id = docker_id
        self._created = created
        self._updated = updated
        self._delete = delete

    def toJson(self):
        return {
            "id": self._game_table_id,
            "table_name": self._game_table_name,
            "table_link": self._game_table_link,
            "version": self._version,
            "active": self._active,
        }

    def commit(self, cursor):
        if not self._created:

            self._game_table_id = cursor.execute("""SELECT MAX(game_table_id) + 1 FROM game_tables""").fetchone()[0]

            cursor.execute(
                """INSERT INTO game_tables
                   (game_table_id, game_table_name, game_table_link, version, active, docker_id)
                   VALUES (?, ?, ?, ?, ?, ?)""",
                (
                    self._game_table_id,
                    self._game_table_name,
                    self._game_table_link,
                    self._version,
                    self._active,
                    self._docker_id,
                ),
            )
            self._created = True
            self._updated = True
            return
        if not self._updated:
            cursor.execute(
                """UPDATE game_tables
                   SET game_table_name = ?, game_table_link = ?, version = ?, active = ?, docker_id = ?
                   WHERE game_table_id = ?""",
                (
                    self._game_table_name,
                    self._game_table_link,
                    self._version,
                    self._active,
                    self._docker_id,
                    self._game_table_id,
                ),
            )
            self._updated = True
            return
        if self._delete:
            cursor.execute(
                "DELETE FROM game_tables WHERE game_table_id = ?",
                (self._game_table_id,),
            )
            self._created = False
            self._updated = True
            self._delete = False

    def delete(self):
        if not self._created:
            raise GameTableException("Cannot delete a table if it is not created.")
        if not self._updated:
            raise GameTableException("Cannot delete a table if it is dirty.")
        self._delete = True

    @property
    def game_table_id(self):
        return self._game_table_id

    @game_table_id.setter
    def set_game_table_id(self, game_table_id: int):
        self._updated = False
        self._game_table_id = game_table_id

    @property
    def game_table_name(self):
        return self._game_table_name

    @game_table_name.setter
    def game_table_name(self, game_table_name: str):
        self._updated = False
        self._game_table_name = game_table_name

    @property
    def game_table_link(self):
        return self._game_table_link

    @game_table_link.setter
    def game_table_link(self, game_table_link):
        self._updated = False
        self._game_table_link = game_table_link

    @property
    def version(self):
        return self._version

    @version.setter
    def version(self, version: int):
        self._updated = False
        self._version = version

    @property
    def active(self):
        return self._active

    @active.setter
    def active(self, active: bool):
        self._updated = False
        self._active = active

    @property
    def docker_id(self):
        return self._docker_id

    @docker_id.setter
    def docker_id(self, docker_id: int):
        self._upadted = False
        self._docker_id = docker_id


class GameService:
    connection: Connection

    def __init__(self, connection: Connection):
        self.connection = connection

    def read_by_id(self, game_table_id, cursor=None):
        with SmartCursor(cursor, self.connection) as smartCursor:
            rows = smartCursor.execute(
                """SELECT game_table_id, game_table_name, game_table_link, active, version, docker_id
                   FROM game_tables
                   WHERE game_table_id = ?""",
                (game_table_id,),
            ).fetchone()

            if len(rows) == 0:
                return None

            return GameTable(
                game_table_id=rows[0],
                game_table_name=rows[1],
                game_table_link=rows[2],
                active=rows[3],
                version=rows[4],
                docker_id=rows[5],
                created=True,
                updated=True,
                delete=False,
            )

    def read_all(self, cursor=None):
        with SmartCursor(cursor, self.connection) as smartCursor:
            rows = smartCursor.execute(
                "SELECT game_table_id, game_table_name, game_table_link, active, version, docker_id FROM game_tables"
            ).fetchall()
        return [
            GameTable(
                game_table_id=row[0],
                game_table_name=row[1],
                game_table_link=row[2],
                active=row[3],
                version=row[4],
                docker_id=row[5],
                created=True,
                updated=True,
                delete=False,
            )
            for row in rows
        ]

    def read_active(self, cursor=None):
        with SmartCursor(cursor, self.connection) as smartCursor:
            rows = smartCursor.execute(
                "SELECT game_table_id, game_table_name, game_table_link, active, version, docker_id FROM game_tables WHERE active != 0"
            ).fetchall()
        return [
            GameTable(
                game_table_id=row[0],
                game_table_name=row[1],
                game_table_link=row[2],
                active=row[3],
                version=row[4],
                docker_id=row[5],
                created=True,
                updated=True,
                delete=False,
            )
            for row in rows
        ]