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

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

    def __init__(
        self,
        game_table_id: int,
        game_table_name: str,
        game_table_link: str,
        active: bool,
        docker_id: int,
        created: bool = False,
        updated: 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._docker_id = docker_id
        self._created = created
        self._updated = updated

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

    def commit(self, cursor):
        if not self._created:
            if self._game_table_id == 0:
                self._game_table_id = random.randint(1, 999999999)
            cursor.execute(
                """INSERT INTO game_tables
                   (game_table_id, game_table_name, game_table_link, active, docker_id)
                   VALUES (?, ?, ?, ?, ?)""",
                (
                    self._game_table_id,
                    self._game_table_name,
                    self._game_table_link,
                    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 = ?, active = ?, docker_id = ?
                   WHERE game_table_id = ?""",
                (
                    self._game_table_name,
                    self._game_table_link,
                    self._active,
                    self._docker_id,
                    self._game_table_id,
                ),
            )
            self._updated = True
            return

    @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 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, docker_id
                   FROM game_tables
                   WHERE game_table_id = ?""",
                (game_table_id,),
            ).fetchone()

        if len(rows) == 0:
            return None

        return GameTable(rows[0], rows[1], rows[2], rows[3], rows[4], True, True)

    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, docker_id FROM game_tables"
            ).fetchall()
        return [
            GameTable(row[0], row[1], row[2], row[3], row[4], True, True)
            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, docker_id FROM game_tables WHERE active != 0"
            ).fetchall()
        return [
            GameTable(row[0], row[1], row[2], row[3], row[4], True, True)
            for row in rows
        ]