import socketio
from yt_dlp import YoutubeDL
import json
import asyncio
import tornado
import requests
import os
import random
import uuid
import zipfile
import datetime
from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip
from moviepy.editor import VideoFileClip
from pygifsicle import optimize
from mutagen.easyid3 import EasyID3
import sentry_sdk


# TODO: auto-reload/reload on webhook using gitpython

# README: functionality is described once per documentation in order to leave as
# little clutter as possible

# Global configuration variable
conf = {}

# Load configuratin at runtime
with open(".conf.json", "r") as f:
    conf = json.loads(f.read())

# If using bugcatcher such as Glitchtip/Sentry set it up
if conf["bugcatcher"]:
    sentry_sdk.init(conf["bugcatcherdsn"])

# Function to download proxies from plain url, this is useful for me, but
# if other people need to utilize a more complex method of downloading proxies
# I recommend implementing it and doing a merge request
def dlProxies():
    r = requests.get(conf["proxyListURL"])
    with open("proxies.txt", "w") as f:
        rlist = r.text.split("\n")
        rlistfixed = []
        for p in rlist[:-1]:
            pl = p.replace("\n", "").replace("\r", "").split(":")
            proxy = "{0}:{1}@{2}:{3}".format(pl[2], pl[3], pl[0], pl[1])
            rlistfixed.append(proxy)
        f.write("\n".join(rlistfixed))
    print("Proxies refreshed!")

# If using proxy list url and there's no proxies file, download proxies at runtime
if conf["proxyListURL"] != False:
    if not os.path.exists("proxies.txt"):
        dlProxies()

# Function to initialize response to client
# Takes method and spinnerid
# spinnerid is the id of the spinner object to remove on the ui, none is fine here
def resInit(method, spinnerid):
    res = {
        "method": method,
        "error": True,
        "spinnerid": spinnerid
    }
    return res

# create a Socket.IO server
sio = socketio.AsyncServer(cors_allowed_origins=conf["allowedorigins"], async_mode="tornado")

# Socketio event, takes the client id and a json payload
# Converts link to mp3 file
@sio.event
async def toMP3(sid, data):
    # Initialize response, if spinnerid data doesn't exist it will just set it to none
    res = resInit("toMP3", data.get("spinnerid"))
    # Try/catch loop will send error message to client on error
    try:
        # Get video url from data
        url = data["url"]
        # Get information about the video via yt-dlp to make future decisions
        info = getInfo(url)
        # Return an error if the video is longer than the configured maximum video length
        if info["duration"] > conf["maxLength"]:
            raise ValueError("Video is longer than configured maximum length")
        else:
            # Get file system safe title for video    
            title = makeSafe(info["title"])
            # Download video as MP3 from given url and get the final title of the video
            ftitle = download(url, True, title, "mp3")
            # Tell the client there is no error
            res["error"] = False
            # Give the client the download link
            res["link"] = conf["url"] + "/downloads/" + ftitle + ".mp3"
            # Give the client the initial safe title just for display on the ui
            res["title"] = title
            # If there is id3 metadata apply this metadata to the file
            if data["id3"] != None:
                # We use EasyID3 here as, well, it's easy, if you need to add more fields
                # please read the mutagen documentation for this here:
                # https://mutagen.readthedocs.io/en/latest/user/id3.html
                audio = EasyID3("downloads/" + ftitle + ".mp3")
                for key, value in data["id3"].items():
                    if value != "" and value != None:
                        audio[key] = value
                audio.save()
            # Emit result to client
            await sio.emit("done", res, sid)
    except Exception as e:
        # Get text of error
        res["details"] = str(e)
        await sio.emit("done", res, sid)

# Downloads playlist as a zip of MP3s
@sio.event
async def playlist(sid, data):
    res = resInit("playlist", data.get("spinnerid"))
    try:
        purl = data["url"]
        # Get playlist info
        info = getInfo(purl)
        # Create playlist title from the file system safe title and a random uuid
        # The uuid is to prevent two users from accidentally overwriting each other's files (very unlikely due to cleanup but still possible)
        ptitle = makeSafe(info["title"]) + str(uuid.uuid4())
        # If the number of entries is larger than the configured maximum playlist length throw an error
        if len(info["entries"]) > conf["maxPlaylistLength"]:
            raise ValueError("Playlist is longer than configured maximum length")
        else:
            # Check the length of all videos in the playlist, if any are longer than the configured maximum
            # length for playlist videos throw an error
            for v in info["entries"]:
                if v["duration"] > conf["maxLengthPlaylistVideo"]:
                    raise ValueError("Video in playlist is longer than configured maximum length")
            # Iterate through all videos on the playlist, download each one as an MP3 and then write it to the playlist zip file
            for v in info["entries"]:
                #TODO: make generic
                vid = v["id"]
                vurl = "https://www.youtube.com/watch?v=" + vid
                title = makeSafe(v["title"])
                ftitle = download(vurl, True, title, "mp3")
                with zipfile.ZipFile("downloads/" + ptitle + '.zip', 'a') as myzip:
                    myzip.write("downloads/" + ftitle + ".mp3")
            res["error"] = False
            res["link"] = conf["url"] + "/downloads/" + ptitle + ".zip"
            res["title"] = title
            await sio.emit("done", res, sid)

    except Exception as e:
        res["details"] = str(e)
        await sio.emit("done", res, sid)

# Two step event
# 1. Get list of subtitles
# 2. Download chosen subtitle file
@sio.event
async def subtitles(sid, data):
    res = resInit("subtitles", data.get("spinnerid"))
    try:
        step = int(data["step"])
        url = data["url"]
        # Step 1 of subtitles is to get the list of subtitles available and return them
        if step == 1:
            info = getInfo(url, getSubtitles=True)
            title = makeSafe(info["title"])
            res["error"] = False
            res["title"] = title
            # List of subtitle keys for picking subtitles
            res["select"] = list(info["subtitles"].keys())
            # Step for front end use, the value here doesn't really matter, the variable just has to exist to tell the ui to move to step 2 when the method is called again
            res["step"] = 0
            # Again details doesn't need a value it just needs to exist to let the front end know to populate the details column with a select defined by the list provided by select
            res["details"] = ""
            await sio.emit("done", res, sid)
        # Step 2 of subtitles is to download the subtitles to the server and provide that link to the user
        elif step == 2:
            # Get the selected subtitles by language code
            languageCode = data["languageCode"]
            # Check if the user wants to download autosubs
            autoSub = data["autoSub"]
            info = getInfo(url)
            title = makeSafe(info["title"])
            # Download the subtitles
            # Unfortunately at the moment this requires downloading the lowest quality stream as well, in the future some modification to yt-dlp might be necessary to avoid this
            ftitle = download(url, False, title, "subtitles", languageCode=languageCode, autoSub=autoSub)
            res["error"] = False
            res["link"] = conf["url"] + "/downloads/" + ftitle + "." + languageCode + ".vtt"
            res["title"] = title
            await sio.emit("done", res, sid)
    except Exception as e:
        res["details"] = str(e)
        await sio.emit("done", res, sid)

# Event to clip a given stream and return the clip to the user, the user can optionally convert this clip into a gif
@sio.event
async def clip(sid, data):
    res = resInit("clip", data.get("spinnerid"))
    try:
        url = data["url"]
        info = getInfo(url)
        # Check if directURL is in the data from the client
        # directURL defines a video url to download from directly instead of through yt-dlp
        directURL = False
        if "directURL" in data.keys():
            directURL = data["directURL"]
        # Check if user wants to create a gif
        gif = False
        if "gif" in data.keys():
            gif = True
        # Get the format id the user wants for downloading a given stream from a given video
        format_id = False
        if "format_id" in data.keys():
            format_id = data["format_id"]
        if info["duration"] > conf["maxLength"]:
            raise ValueError("Video is longer than configured maximum length")
        # Get the start and end time for the clip
        timeA = int(data["timeA"])
        timeB = int(data["timeB"])
        # If we're making a gif make sure the clip is not longer than the maximum gif length
        # Please be careful with gif lengths, if you set this too high you may end up with huge gifs hogging the server
        if gif and ((timeB - timeA) > conf["maxGifLength"]):
            raise ValueError("Range is too large for gif")
        title = makeSafe(info["title"])
        # If the directURL is set download directly
        if directURL != False:
            ititle = title + "." + info["ext"]
            downloadDirect(directURL, "downloads/" + ititle)      
        # Otherwise download the video through yt-dlp
        # If there's no format id just get the default video
        else:
            if format_id != False:
                ititle = download(url, False, title, "mp4", extension=info["ext"], format_id=format_id)
            else:
                ititle = download(url, False, title, "mp4", extension=info["ext"])
        if gif:
            # Clip video and then convert it to a gif
            (VideoFileClip("downloads/" + ititle)).subclip(timeA, timeB).write_gif("downloads/" + title + "." + str(uuid.uuid4()) + ".clipped.gif")
            # Optimize the gif
            optimize("downloads/" + title + ".clipped.gif")
        else:
            # Clip the video and return the mp4 of the clip
            ffmpeg_extract_subclip("downloads/" + ititle, timeA, timeB, targetname="downloads/" + title + "." + str(uuid.uuid4()) + ".clipped.mp4")
        res["error"] = False
        # Set the extension to use either to mp4 or gif depending on whether the user wanted a gif
        # The extension is just for creating the url for the clip
        extension = "mp4"
        if gif:
            extension = "gif"
        res["link"] = conf["url"] + "/downloads/" + title + ".clipped." + extension
        res["title"] = title
        await sio.emit("done", res, sid)
    except Exception as e:
        res["details"] = str(e)
        await sio.emit("done", res, sid)

# Generic event to get all the information provided by yt-dlp for a given url
@sio.event
async def getInfoEvent(sid, data):
    # Unlike other events we set the method here from the passed method in order to make this generic and flexible
    res = resInit(data["method"], data.get("spinnerid"))
    try:
        url = data["url"]
        info = getInfo(url)
        if data["method"] == "streams":
            res["details"] = ""
            res["select"] = ""
        title = makeSafe(info["title"])
        res["error"] = False
        res["title"] = title
        res["info"] = info
        await sio.emit("done", res, sid)
    except Exception as e:
        res["details"] = str(e)
        await sio.emit("done", res, sid)

# Get limits of server for display in UI
@sio.event
async def limits(sid, data):
    res = resInit("limits", data.get("spinnerid"))
    try:
        limits = [
            "maxLength",
            "maxPlaylistLength",
            "maxGifLength",
            "maxGifResolution",
            "maxLengthPlaylistVideo"
        ]
        res["limits"] = [{"limitid": limit, "limitvalue": conf[limit]} for limit in limits]
        res["error"] = False
        await sio.emit("done", res, sid)
    except Exception as e:
        res["details"] = str(e)
        await sio.emit("done", res, sid)

# Generic download method
def download(url, isAudio, title, codec, languageCode=None, autoSub=False, extension=False, format_id=False):
    # Used to avoid filename conflicts
    ukey = str(uuid.uuid4())
    # Set the location/name of the output file
    ydl_opts = {
        'outtmpl': 'downloads/' + title + "." + ukey
    }
    # Add extension to filepath if set
    if extension != False:
        ydl_opts["outtmpl"] += "." + extension
    # If this is audio setup for getting the best audio with the given codec
    if isAudio:
        ydl_opts['format'] = "bestaudio/best"
        ydl_opts['postprocessors'] = [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': codec,
            'preferredquality': '192',
        }]
    # Otherwise...
    else:
        # Check if there's a format id, if so set the download format to that format id
        if format_id != False:
            ydl_opts['format'] = format_id
        # Otherwise if we're downloading subtitles...
        elif codec == "subtitles":
            # Set up to write the subtitles to disk
            ydl_opts["writesubtitles"] = True
            # Further settings to write subtitles
            ydl_opts['subtitle'] = '--write-sub --sub-lang ' + languageCode
            # If the user wants to download auto subtitles set the subtitle field to do so
            if autoSub:
                ydl_opts['subtitle'] = "--write-auto-sub " + ydl_opts["subtitle"]
            ydl_opts['format'] = "worst"
        # Otherwise just download the best video
        else:
            ydl_opts['format'] = "bestvideo/best"
    # If there is a proxy list url set up, set yt-dlp to use a random proxy
    if conf["proxyListURL"] != False:
        ydl_opts['proxy'] = getProxy()
    # Finally, actually download the file/s
    with YoutubeDL(ydl_opts) as ydl:
        if codec == "subtitles":
            ydl.extract_info(url, download=True)
        else:
            ydl.download([url])
    # Construct and return the filepath for the downloaded file
    res = title + "." + ukey
    if extension != False:
        res += "." + extension
    return res

# Download file directly, with random proxy if set up
def downloadDirect(url, filename):
    if conf["proxyListURL"] != False:
        proxies = {'https': 'https://' + getProxy()}
        with requests.get(url, proxies=proxies, stream=True) as r:
            r.raise_for_status()
            with open(filename, 'wb') as f:
                for chunk in r.iter_content(chunk_size=8192): 
                    f.write(chunk)
    else:
        with requests.get(url, stream=True) as r:
            r.raise_for_status()
            with open(filename, 'wb') as f:
                for chunk in r.iter_content(chunk_size=8192): 
                    f.write(chunk)

# Generic method to get sanitized information about the given url, with a random proxy if set up
# Try to write subtitles if requested
def getInfo(url, getSubtitles=False):
    info = {
        "writesubtitles": getSubtitles
    }
    if conf["proxyListURL"] != False:
        info['proxy'] = getProxy()
    with YoutubeDL({}) as ydl:
        info = ydl.extract_info(url, download=False)
        info = ydl.sanitize_info(info)
    return info

# Make title file system safe
# https://stackoverflow.com/questions/7406102/create-sane-safe-filename-from-any-unsafe-string
def makeSafe(filename):
    return "".join([c for c in filename if c.isalpha() or c.isdigit() or c==' ']).rstrip()

# Get random proxy from proxy list
def getProxy():
    proxy = ""
    with open("proxies.txt", "r") as f:
        proxy = random.choice(f.read().split("\n"))
    return proxy

# Refresh proxies every hour
async def refreshProxies():
    while True:
        dlProxies()
        await asyncio.sleep(3600)

# Clean all files that are older than an hour out of downloads every hour
async def clean():
    while True:
        for f in os.listdir("./downloads"):
            fmt = datetime.datetime.fromtimestamp(os.path.getmtime('downloads/' + f))
            if (datetime.datetime.now() - fmt).total_seconds() > 7200:
                os.remove("downloads/" + f)
        print("Cleaned!")
        await asyncio.sleep(3600)

def make_app():
    return tornado.web.Application([
        (r'/downloads/(.*)', tornado.web.StaticFileHandler, {'path': "./downloads"}),
        (r"/socket.io/", socketio.get_tornado_handler(sio))
    ])

# Main method
async def main():
    # If proxies are configured set up the refresh proxies task
    if conf["proxyListURL"] != False:
        task = asyncio.create_task(refreshProxies())
        # This is needed to get the async task running
        await asyncio.sleep(0)
    # Set up cleaning task
    task2 = asyncio.create_task(clean())
    await asyncio.sleep(0)
    # Generic tornado setup
    app = make_app()
    app.listen(8888)
    await asyncio.Event().wait()

if __name__ == "__main__":
    asyncio.run(main())