from typing import Optional
from pydantic import BaseModel

"""
Karma
"""


class ValidKarmaUpdateRequest(BaseModel):
    """
    Requires authentication
    - **granter**: who updated the karma
    - **keyword**: keyword to update karma for
    - **flag**: either 0 (decrement) for --, or 1 (increment) for ++
    """

    granter: str
    keyword: str
    flag: int


class ValidKarmaRetrievalRequest(BaseModel):
    """
    - **keyword**: keyword to retrieve karma value of
    """

    keyword: str


class ValidTopKarmaRequest(BaseModel):
    """
    - **n**: Number of top results to return (default: 10)
    """

    n: Optional[int] = 10


"""
LastFM
"""


class LastFMException(Exception):
    pass


class ValidArtistSearchRequest(BaseModel):
    """
    - **a**: artist name
    """

    a: str

    model_config = {
        "json_schema_extra": {
            "examples": [
                {
                    "a": "eminem",
                }
            ]
        }
    }


class ValidAlbumDetailRequest(BaseModel):
    """
    - **a**: artist name
    - **release**: album/release name (as sourced from here/LastFM)
    """

    a: str
    release: str

    model_config = {
        "json_schema_extra": {
            "examples": [
                {
                    "a": "eminem",
                    "release": "houdini",
                }
            ]
        }
    }


class ValidTrackInfoRequest(BaseModel):
    """
    - **a**: artist name
    - **t**: track
    """

    a: str
    t: str

    model_config = {
        "json_schema_extra": {
            "examples": [
                {
                    "a": "eminem",
                    "t": "rap god",
                }
            ]
        }
    }


"""
Rand Msg
"""


class RandMsgRequest(BaseModel):
    """
    - **short**: Short randmsg?
    """

    short: Optional[bool] = False


"""
YT
"""


class ValidYTSearchRequest(BaseModel):
    """
    - **t**: title to search
    """

    t: str = "rick astley - never gonna give you up"


"""
XC
"""


class ValidXCRequest(BaseModel):
    """
    - **key**: valid XC API key
    - **bid**: bot id
    - **cmd**: bot command
    - **data**: command data
    """

    key: str
    bid: int
    cmd: str
    data: Optional[dict]


"""
Transcriptions
"""


class ValidShowEpisodeListRequest(BaseModel):
    """
    - **s**: show id
    """

    s: int


class ValidShowEpisodeLineRequest(BaseModel):
    """
    - **s**: show id
    - **e**: episode id
    """

    s: int
    e: int


"""
Lyric Search
"""


class ValidLyricRequest(BaseModel):
    """
    - **a**: artist
    - **s**: song
    - **t**: track (artist and song combined) [used only if a & s are not used]
    - **extra**: include extra details in response [optional, default: false]
    - **lrc**: Request LRCs?
    - **sub**: text to search within lyrics, if found lyrics will begin at found verse [optional]
    - **src**: the script/utility which initiated the request
    - **excluded_sources**: sources to exclude (new only)
    """

    a: Optional[str] = None
    s: Optional[str] = None
    t: Optional[str] = None
    sub: Optional[str] = None
    extra: Optional[bool] = False
    lrc: Optional[bool] = False
    src: str
    excluded_sources: Optional[list] = None

    model_config = {
        "json_schema_extra": {
            "examples": [
                {
                    "a": "eminem",
                    "s": "rap god",
                    "src": "WEB",
                    "extra": True,
                    "lrc": False,
                    "excluded_sources": [],
                }
            ]
        }
    }


class ValidTypeAheadRequest(BaseModel):
    """
    - **query**: query string
    """

    query: str


"""
Radio
"""


class RadioException(Exception):
    pass


class ValidRadioSongRequest(BaseModel):
    """
    - **key**: API Key
    - **artist**: artist to search
    - **song**: song to search
    - **artistsong**: may be used IN PLACE OF artist/song to perform a combined/string search in the format "artist - song"
    - **alsoSkip**: Whether to skip immediately to this track [not implemented]
    """

    key: str
    artist: Optional[str] = None
    song: Optional[str] = None
    artistsong: Optional[str] = None
    alsoSkip: Optional[bool] = False


class ValidRadioTypeaheadRequest(BaseModel):
    """
    - **query**: Typeahead query
    """

    query: str


class ValidRadioQueueGetRequest(BaseModel):
    """
    - **key**: API key (optional, needed if specifying a non-default limit)
    - **limit**: optional, default: 15k
    """

    key: Optional[str] = None
    limit: Optional[int] = 15_000


class ValidRadioNextRequest(BaseModel):
    """
    - **key**: API Key
    - **skipTo**: UUID to skip to [optional]
    """

    key: str
    skipTo: Optional[str] = None


class ValidRadioReshuffleRequest(ValidRadioNextRequest):
    """
    - **key**: API Key
    """


class ValidRadioQueueShiftRequest(BaseModel):
    """
    - **key**: API Key
    - **uuid**: UUID to shift
    - **next**: Play next if true, immediately if false, default False
    """

    key: str
    uuid: str
    next: Optional[bool] = False


class ValidRadioQueueRemovalRequest(BaseModel):
    """
    - **key**: API Key
    - **uuid**: UUID to remove
    """

    key: str
    uuid: str