import os
from typing import List

import sqlalchemy.engine
from sqlalchemy import String, create_engine, URL, Table, Column, ForeignKey
from sqlalchemy.orm import DeclarativeBase, Mapped, relationship, Session
from sqlalchemy.sql.expression import select
from sqlalchemy.testing.schema import mapped_column

from config.config import ConfigLoader

def get_engine() -> sqlalchemy.engine.Engine:
    url_obj = URL.create(
        "postgresql",
        username=os.environ.get('POSTGRES_USER'),
        password=os.environ.get('POSTGRES_PASSWORD'),
        database=os.environ.get('POSTGRES_DB'),
        host=ConfigLoader.get_config_loader().database_host,
        port=ConfigLoader.get_config_loader().database_port
    )
    e = create_engine(url_obj)
    return e

class Base(DeclarativeBase):
    pass

mc_users_on_mc_server = Table(
    "mc_users_on_mc_server",
    Base.metadata,
    Column("minecraft_user", ForeignKey("minecraft_users.uuid"), primary_key=True),
    Column("minecraft_server", ForeignKey("minecraft_servers.domain"), primary_key=True)
)

class DiscordUser(Base):
    __tablename__ = "discord_users"

    snowflake_id: Mapped[str] = mapped_column(primary_key=True)
    handle: Mapped[str] = mapped_column(String(32))

    minecraft_user_uuid = mapped_column(ForeignKey("minecraft_users.uuid"))

    def __repr__(self):
        return f"User(snowflake_id={self.snowflake_id}, handle={self.handle})"

class MinecraftUser(Base):
    __tablename__ = "minecraft_users"

    uuid: Mapped[String] = mapped_column(String(32), primary_key=True)
    user_name: Mapped[String] = mapped_column(String(16), primary_key=True)

    #discord_user = mapped_column(ForeignKey("discord_users.snowflake_id"))
    minecraft_servers: Mapped[List["MinecraftServer"]] = relationship(secondary=mc_users_on_mc_server, back_populates="minecraft_users")

    def __repr__(self):
        return f"MCUser(uuid={self.uuid}, user_name={self.user_name})"

class MinecraftServer(Base):
    __tablename__ = "minecraft_servers"

    domain: Mapped[str] = mapped_column(String(64), primary_key=True)
    minecraft_users: Mapped[List["MinecraftUser"]] = relationship(secondary=mc_users_on_mc_server, back_populates="minecraft_servers")

    def __repr__(self):
        return f"MinecraftServer(domain={self.domain}, discord_user={self.discord_user})"

if __name__ == "__main__":
    url_obj = URL.create(
        "postgresql",
        username=os.environ.get('POSTGRES_USER'),
        password=os.environ.get('POSTGRES_PASSWORD'),
        database=os.environ.get('POSTGRES_DB'),
        host=ConfigLoader.get_config_loader().database_host,
        port=ConfigLoader.get_config_loader().database_port
    )
    engine = create_engine(url_obj, echo=True)

    with Session(engine) as session:
        pass
        #mc_server = MinecraftServer(domain="feather-mc.pandro.de")
        #uuid = MinecraftAPI.get_uuid_from_user_name("Pandr0")
        #mc_user = MinecraftUser(uuid=uuid,
        #                        user_name="Pandr0"
        #                        )
        #disc_user = DiscordUser(snowflake_id="682326483921797146",
        #                        handle="pandro_",
        #                        minecraft_user_uuid=mc_user.uuid)
        #stmt = update(mc_users_on_mc_server).where().values()
        #session.execute(stmt)
        #stmt = insert(mc_users_on_mc_server).values(minecraft_user=uuid, minecraft_server="feather-mc.pandro.de")
        #session.execute(stmt)
        #session.commit()
        stmt = select(MinecraftUser).where(MinecraftUser.user_name == "Pandr0")
        mc_user = session.execute(stmt).first()[0]
        stmt = select(MinecraftServer).where(MinecraftServer.minecraft_users.any(MinecraftUser.user_name == "Pandr0"))  # TODO figure out how to query minecraft servers with a given minecraft user
        result = session.execute(stmt).all()

    print(f"PG user: {os.environ.get('POSTGRES_USER')}")
    #print(f"PG pw: {os.environ.get('POSTGRES_PASSWORD')}")
    print(f"PG db: {os.environ.get('POSTGRES_DB')}")