import base64
from dataclasses import dataclass
from typing import Optional

from pure_protobuf.dataclasses_ import field, message
from pure_protobuf.types import int64

def b64e(b, padding=True):
    return base64.urlsafe_b64encode(b).decode('ascii') \
            .replace("=", "%3D" if padding else "")

# SEARCH {{{
@message
@dataclass
class Extras:
    dont_fix_spelling: Optional[bool] = field(1, default=None)
@message
@dataclass
class Filters: # adapted from invidious
    date:      Optional[int64] = field(1, default=None)
    type:      Optional[int64] = field(2, default=None)
    length:    Optional[int64] = field(3, default=None)
    is_hd:     Optional[bool]  = field(4, default=None)
    subtitles: Optional[bool]  = field(5, default=None)
    ccommons:  Optional[bool]  = field(6, default=None)
    is_3d:     Optional[bool]  = field(7, default=None)
    live:      Optional[bool]  = field(8, default=None)
    purchased: Optional[bool]  = field(9, default=None)
    is_4k:     Optional[bool]  = field(14, default=None)
    is_360:    Optional[bool]  = field(15, default=None)
    location:  Optional[bool]  = field(23, default=None)
    is_hdr:    Optional[bool]  = field(25, default=None)
@message
@dataclass
class SearchRequest:
    sorted: Optional[int64] = field(1, default=None)
    filter: Optional[Filters] = field(2, default=None)
    extras: Optional[Extras] = field(8, default=None)

def make_sp(sort=None, date=None, type=None, len=None, features=[], extras=[]):
    sortorder  = dict(relevance=0, rating=1, date=2, views=3)
    datefilter = dict(hour=1, day=2, week=3, month=4, year=5)
    typefilter = dict(video=1, channel=2, playlist=3, movie=4, show=5)
    lenfilter  = dict(short=1, long=2)

    return b64e(SearchRequest(
        sorted=sortorder.get(sort),
        filter=Filters(
            date=datefilter.get(date),
            type=typefilter.get(type),
            length=lenfilter.get(len),
            **{f:True for f in features},
        ) if date or type or len or features else None,
        extras=Extras(**{f:True for f in extras}),
    ).dumps())
# }}} SEARCH

# CHANNEL v1/v3 {{{
@message
@dataclass
class ChannelDataInner:
    offset: int64 = field(1)
@message
@dataclass
class ChannelDataContainer:
    data: str = field(1)  # base64 of ChannelDataInner
@message
@dataclass
class Subparams:
    type_s: str = field(2)
    type_i: Optional[int64] = field(4)
    page: Optional[str] = field(15)
    sort: Optional[int64] = field(3, default=None)
    unknown_const1: int64 = field(7, default=1)
    unknown_const2: int64 = field(23, default=0)
    # usually returns gridResponses. to switch to listResponses (cargo-culting
    # invidious, playlist continuations (not yet supported) require list):
    list_or_grid: Optional[int64] = field(6,default=2) # 2=list, None/1=grid
    # invidious sets those, but no idea why:
    #field12:int64 = field(12,default=1)
    #field13:str = field(13,default="") # playlists in list mode don't work without this
    field61: Optional[str] = field(61, default=None) # base64 channelData
@message
@dataclass
class Params:
    subject: str = field(2) # ucid/plid
    params: str = field(3)  # b64e encoded
    query: Optional[str] = field(11, default=None) # channel search
@message
@dataclass
class Continuation:
    params: Params = field(80226972)
def make_channel_params(subject, typ="videos", page=1, sort=None, query=None, v3=False):
    typestr = dict(videos="videos", playlists="playlists", search="search")
    typeint = dict(videos=0, playlists=1, search=None) # not supporting autogen'd
    sortorder = dict(popular=1, oldest=2, newest=3)
    if typ == "playlists":
        sortorder = dict(oldest=2, newest=3, modified=4)
    elif typ == "search":
        sortorder = dict()

    return b64e(Continuation(
        params=Params(
            subject=subject,
            params=b64e(Subparams(
                type_s=typestr.get(typ),
                type_i=typeint.get(typ),
                sort=sortorder.get(sort),
                page=str(page) if not v3 and page else None,
                field61=b64e(
                    ChannelDataContainer(
                        data=b64e(
                            ChannelDataInner(
                                offset=(page-1)*30
                            ).dumps(), padding=False
                        )
                    ).dumps(), padding=False
                ) if v3 else None
            ).dumps()),
            query=query,
        ),
    ).dumps())
# }}} CHANNEL v1/v3

# PLAYLIST {{{
@message
@dataclass
class PlaylistData:
    offset: int64 = field(1)
@message
@dataclass
class PlaylistSubparams:
    data: str = field(15)
def make_playlist_params(playlist_id, offset):
    if playlist_id.startswith("UC"):
        playlist_id = f"UU{playlist_id[2:]}" # "Uploads from <username>"

    return b64e(Continuation(
        params=Params(
            subject="VL" + playlist_id,
            params=b64e(PlaylistSubparams(
                data="PT:" + b64e(PlaylistData(
                    offset=offset,
                ).dumps(), padding=False)
            ).dumps()),
        ),
    ).dumps())
# }}} PLAYLIST