from typing import List, Union, Type, Optional
from peewee import (
    SqliteDatabase,
    PostgresqlDatabase,
    MySQLDatabase,
    Model,
    CharField,
    IntegerField,
    BooleanField,
    ForeignKeyField,
    TextField
)

"""
**IMPORTANT**:

never delete, modify the datatype or add constrains to ANY existing collumns,
between the versions, that gets pushed out to the users.
Else my function can't update legacy databases, to new databases, 
while keeping the data of the old ones.

EVEN if that means to for example keep decimal values stored in strings.
(not in my codebase though.)
"""


class BaseModel(Model):
    class Meta:
        database = None

    @classmethod
    def Use(cls, database: Union[SqliteDatabase, PostgresqlDatabase, MySQLDatabase]) -> Model:
        cls._meta.database = database
        return cls
    
    def use(self, database: Union[SqliteDatabase, PostgresqlDatabase, MySQLDatabase]) -> Model:
        self._meta.database = database
        return self


class Album(BaseModel):
    """A class representing an album in the music database."""

    title: str = CharField(null=True)
    label: str = CharField(null=True)
    album_status: str = CharField(null=True)
    language: str = CharField(null=True)
    date: str = CharField(null=True)
    date_format: str = CharField(null=True)
    country: str = CharField(null=True)
    barcode: str = CharField(null=True)
    albumsort: int = IntegerField(null=True)
    is_split: bool = BooleanField(default=False)


class Artist(BaseModel):
    """A class representing an artist in the music database."""

    name: str = CharField()


class Song(BaseModel):
    """A class representing a song in the music database."""

    name: str = CharField(null=True)
    isrc: str = CharField(null=True)
    length: int = IntegerField(null=True)
    tracksort: int = IntegerField(null=True)
    genre: str = CharField(null=True)
    # album: ForeignKeyField = ForeignKeyField(Album, backref='songs')


class Source(BaseModel):
    """A class representing a source of a song in the music database."""
    ContentTypes = Union[Song, Album, Artist]

    page: str = CharField()
    url: str = CharField()

    content_type: str = CharField()
    content_id: int = IntegerField()
    content: ForeignKeyField = ForeignKeyField('self', backref='content_items', null=True)

    @property
    def content_object(self) -> Union[Song, Album, Artist]:
        """Get the content associated with the source as an object."""
        if self.content_type == 'Song':
            return Song.get(Song.id == self.content_id)
        elif self.content_type == 'Album':
            return Album.get(Album.id == self.content_id)
        elif self.content_type == 'Artist':
            return Artist.get(Artist.id == self.content_id)
        else:
            return None

    @content_object.setter
    def content_object(self, value: Union[Song, Album, Artist]) -> None:
        """Set the content associated with the source as an object."""
        self.content_type = value.__class__.__name__
        self.content_id = value.id


class Target(BaseModel):
    """A class representing a target of a song in the music database."""

    file: str = CharField()
    path: str = CharField()
    song = ForeignKeyField(Song, backref='targets')


class Lyrics(BaseModel):
    """A class representing lyrics of a song in the music database."""

    text: str = TextField()
    language: str = CharField()
    song = ForeignKeyField(Song, backref='lyrics')


class SongArtist(BaseModel):
    """A class representing the relationship between a song and an artist."""

    song: ForeignKeyField = ForeignKeyField(Song, backref='song_artists')
    artist: ForeignKeyField = ForeignKeyField(Artist, backref='song_artists')
    is_feature: bool = BooleanField(default=False)


class AlbumArtist(BaseModel):
    """A class representing the relationship between an album and an artist."""

    album: ForeignKeyField = ForeignKeyField(Album, backref='album_artists')
    artist: ForeignKeyField = ForeignKeyField(Artist, backref='album_artists')


ALL_MODELS = [
    Song, 
    Album, 
    Artist,
    Source,
    Lyrics,
    AlbumArtist,
    Target,
    SongArtist
]


if __name__ == "__main__":
    database_1 = SqliteDatabase(":memory:")
    database_1.create_tables([Song.Use(database_1)])
    database_2 = SqliteDatabase(":memory:")
    database_2.create_tables([Song.Use(database_2)])

    # creating songs, adding it to db_2 if i is even, else to db_1
    for i in range(100):
        song = Song(name=str(i) + "hs")

        db_to_use = database_2 if i % 2 == 0 else database_1
        song.use(db_to_use).save()

    print("database 1")
    for song in Song.Use(database_1).select():
        print(song.name)

    print("database 2")
    for song in Song.Use(database_1).select():
        print(song.name)