import os
import sys
import platform
import traceback
import subprocess
import sqlite3
from datetime import datetime

from flask import render_template, jsonify

from framework import db, path_app_root, path_data, socketio
from framework.common.plugin import LogicModuleBase, default_route_socketio

from .plugin import Plugin
from .my_youtube_dl import MyYoutubeDL, Status

logger = Plugin.logger
package_name = Plugin.package_name
ModelSetting = Plugin.ModelSetting


class LogicMain(LogicModuleBase):
    db_default = {
        "db_version": "2",
        "youtube_dl_package": "1",
        "ffmpeg_path": ""
        if platform.system() != "Windows"
        else os.path.join(path_app_root, "bin", "Windows", "ffmpeg.exe"),
        "temp_path": os.path.join(path_data, "download_tmp"),
        "save_path": os.path.join(path_data, "download"),
        "default_filename": "",
        "proxy": "",
    }

    def __init__(self, plugin):
        super(LogicMain, self).__init__(plugin, None)
        self.name = package_name  # 모듈명
        default_route_socketio(plugin, self)

    def plugin_load(self):
        try:
            # youtube-dl 업데이트
            youtube_dl = Plugin.youtube_dl_packages[
                int(ModelSetting.get("youtube_dl_package"))
            ]
            logger.debug(f"{youtube_dl} upgrade")
            logger.debug(
                subprocess.check_output(
                    [sys.executable, "-m", "pip", "install", "--upgrade", youtube_dl],
                    universal_newlines=True,
                )
            )
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())

    def process_menu(self, sub, req):
        try:
            arg = {
                "package_name": package_name,
                "sub": sub,
                "template_name": f"{package_name}_{sub}",
                "package_version": Plugin.plugin_info["version"],
            }

            if sub == "setting":
                arg.update(ModelSetting.to_dict())
                arg["package_list"] = Plugin.youtube_dl_packages
                arg["youtube_dl_version"] = LogicMain.get_youtube_dl_version()
                arg["DEFAULT_FILENAME"] = LogicMain.get_default_filename()

            elif sub == "download":
                default_filename = ModelSetting.get("default_filename")
                arg["filename"] = (
                    default_filename
                    if default_filename
                    else LogicMain.get_default_filename()
                )
                arg["preset_list"] = LogicMain.get_preset_list()
                arg["postprocessor_list"] = LogicMain.get_postprocessor_list()

            elif sub == "thumbnail":
                default_filename = ModelSetting.get("default_filename")
                arg["filename"] = (
                    default_filename
                    if default_filename
                    else LogicMain.get_default_filename()
                )

            elif sub == "sub":
                default_filename = ModelSetting.get("default_filename")
                arg["filename"] = (
                    default_filename
                    if default_filename
                    else LogicMain.get_default_filename()
                )

            elif sub == "list":
                pass

            return render_template(f"{package_name}_{sub}.html", arg=arg)
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())
            return render_template("sample.html", title=f"{package_name} - {sub}")

    def process_ajax(self, sub, req):
        try:
            logger.debug("AJAX: %s, %s", sub, req.values)
            ret = {"ret": "success"}

            if sub == "ffmpeg_version":
                path = req.form["path"]
                output = subprocess.check_output([path, "-version"])
                output = output.decode().replace("\n", "<br>")
                ret["data"] = output

            elif sub == "download":
                postprocessor = req.form["postprocessor"]
                video_convertor, extract_audio = LogicMain.get_postprocessor()
                preferedformat = None
                preferredcodec = None
                preferredquality = None
                if postprocessor in video_convertor:
                    preferedformat = postprocessor
                elif postprocessor in extract_audio:
                    preferredcodec = postprocessor
                    preferredquality = 192
                youtube_dl = LogicMain.download(
                    plugin=package_name,
                    url=req.form["url"],
                    filename=req.form["filename"],
                    temp_path=ModelSetting.get("temp_path"),
                    save_path=ModelSetting.get("save_path"),
                    format=req.form["format"],
                    preferedformat=preferedformat,
                    preferredcodec=preferredcodec,
                    preferredquality=preferredquality,
                    proxy=ModelSetting.get("proxy"),
                    ffmpeg_path=ModelSetting.get("ffmpeg_path")
                    if req.form["ffmpeg_path"] != "ffmpeg"
                    else None,
                )
                youtube_dl.start()
                LogicMain.socketio_emit("add", youtube_dl)

            elif sub == "thumbnail":
                youtube_dl = LogicMain.thumbnail(
                    plugin=package_name,
                    url=req.form["url"],
                    filename=req.form["filename"],
                    temp_path=ModelSetting.get("temp_path"),
                    save_path=ModelSetting.get("save_path"),
                    all_thumbnails=req.form["all_thumbnails"],
                    proxy=ModelSetting.get("proxy"),
                    ffmpeg_path=ModelSetting.get("ffmpeg_path")
                    if req.form["ffmpeg_path"] != "ffmpeg"
                    else None,
                )
                youtube_dl.start()
                LogicMain.socketio_emit("add", youtube_dl)

            elif sub == "sub":
                youtube_dl = LogicMain.sub(
                    plugin=package_name,
                    url=req.form["url"],
                    filename=req.form["filename"],
                    temp_path=ModelSetting.get("temp_path"),
                    save_path=ModelSetting.get("save_path"),
                    all_subs=req.form["all_subs"],
                    sub_lang=req.form["sub_lang"],
                    auto_sub=req.form["auto_sub"],
                    proxy=ModelSetting.get("proxy"),
                    ffmpeg_path=ModelSetting.get("ffmpeg_path")
                    if req.form["ffmpeg_path"] != "ffmpeg"
                    else None,
                )
                youtube_dl.start()
                LogicMain.socketio_emit("add", youtube_dl)

            elif sub == "list":
                ret["data"] = []
                for i in LogicMain.youtube_dl_list:
                    data = LogicMain.get_data(i)
                    if data is not None:
                        ret["data"].append(data)

            elif sub == "all_stop":
                for i in LogicMain.youtube_dl_list:
                    i.stop()

            elif sub == "stop":
                index = int(req.form["index"])
                LogicMain.youtube_dl_list[index].stop()

            return jsonify(ret)
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())
            return jsonify({"ret": "danger", "msg": str(error)})

    def migration(self):
        try:
            db_version = ModelSetting.get_int("db_version")
            connect = sqlite3.connect(
                os.path.join(path_data, "db", f"{package_name}.db")
            )

            if db_version < 2:
                logger.debug("youtube-dlc uninstall")
                logger.debug(
                    subprocess.check_output(
                        [sys.executable, "-m", "pip", "uninstall", "-y", "youtube-dlc"],
                        universal_newlines=True,
                    )
                )

            connect.commit()
            connect.close()
            ModelSetting.set("db_version", LogicMain.db_default["db_version"])
            db.session.flush()
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())

    youtube_dl_list = []

    @staticmethod
    def get_youtube_dl_version():
        try:
            return MyYoutubeDL.get_version()
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())
            return "패키지 임포트 실패"

    @staticmethod
    def get_default_filename():
        return MyYoutubeDL.DEFAULT_FILENAME

    @staticmethod
    def get_preset_list():
        return [
            ["bestvideo+bestaudio/best", "최고 화질"],
            ["bestvideo[height<=1080]+bestaudio/best[height<=1080]", "1080p"],
            ["worstvideo+worstaudio/worst", "최저 화질"],
            ["bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]", "최고 화질(mp4)"],
            [
                "bestvideo[ext=mp4][height<=1080]+bestaudio[ext=m4a]/best[ext=mp4][height<=1080]",
                "1080p(mp4)",
            ],
            ["bestvideo[filesize<50M]+bestaudio/best[filesize<50M]", "50MB 미만"],
            ["bestaudio/best", "오디오만"],
            ["_custom", "사용자 정의"],
        ]

    @staticmethod
    def get_postprocessor_list():
        return [
            ["", "후처리 안함", None],
            ["mp4", "MP4", "비디오 변환"],
            ["flv", "FLV", "비디오 변환"],
            ["webm", "WebM", "비디오 변환"],
            ["ogg", "Ogg", "비디오 변환"],
            ["mkv", "MKV", "비디오 변환"],
            ["ts", "TS", "비디오 변환"],
            ["avi", "AVI", "비디오 변환"],
            ["wmv", "WMV", "비디오 변환"],
            ["mov", "MOV", "비디오 변환"],
            ["gif", "GIF", "비디오 변환"],
            ["mp3", "MP3", "오디오 추출"],
            ["aac", "AAC", "오디오 추출"],
            ["flac", "FLAC", "오디오 추출"],
            ["m4a", "M4A", "오디오 추출"],
            ["opus", "Opus", "오디오 추출"],
            ["vorbis", "Vorbis", "오디오 추출"],
            ["wav", "WAV", "오디오 추출"],
        ]

    @staticmethod
    def get_postprocessor():
        video_convertor = []
        extract_audio = []
        for i in LogicMain.get_postprocessor_list():
            if i[2] == "비디오 변환":
                video_convertor.append(i[0])
            elif i[2] == "오디오 추출":
                extract_audio.append(i[0])
        return video_convertor, extract_audio

    @staticmethod
    def download(**kwagrs):
        try:
            logger.debug(kwagrs)
            plugin = kwagrs["plugin"]
            url = kwagrs["url"]
            filename = kwagrs["filename"]
            temp_path = kwagrs["temp_path"]
            save_path = kwagrs["save_path"]
            opts = {}
            if "format" in kwagrs and kwagrs["format"]:
                opts["format"] = kwagrs["format"]
            postprocessor = []
            if "preferedformat" in kwagrs and kwagrs["preferedformat"]:
                postprocessor.append(
                    {
                        "key": "FFmpegVideoConvertor",
                        "preferedformat": kwagrs["preferedformat"],
                    }
                )
            if "preferredcodec" in kwagrs and kwagrs["preferredcodec"]:
                postprocessor.append(
                    {
                        "key": "FFmpegExtractAudio",
                        "preferredcodec": kwagrs["preferredcodec"],
                        "preferredquality": str(kwagrs["preferredquality"]),
                    }
                )
            if postprocessor:
                opts["postprocessors"] = postprocessor
            if "playlist" in kwagrs and kwagrs["playlist"]:
                if kwagrs["playlist"] == "reverse":
                    opts["playlistreverse"] = True
                elif kwagrs["playlist"] == "random":
                    opts["playlistrandom"] = True
                else:
                    opts["playlist_items"] = kwagrs["playlist"]
            if "archive" in kwagrs and kwagrs["archive"]:
                opts["download_archive"] = kwagrs["archive"]
            if "proxy" in kwagrs and kwagrs["proxy"]:
                opts["proxy"] = kwagrs["proxy"]
            if "ffmpeg_path" in kwagrs and kwagrs["ffmpeg_path"]:
                opts["ffmpeg_location"] = kwagrs["ffmpeg_path"]
            if "cookiefile" in kwagrs and kwagrs["cookiefile"]:
                opts["cookiefile"] = kwagrs["cookiefile"]
            dateafter = kwagrs.get("dateafter")
            youtube_dl = MyYoutubeDL(
                plugin, "video", url, filename, temp_path, save_path, opts, dateafter
            )
            youtube_dl.key = kwagrs.get("key")
            LogicMain.youtube_dl_list.append(youtube_dl)  # 리스트 추가
            return youtube_dl
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())
            return None

    @staticmethod
    def thumbnail(**kwagrs):
        try:
            logger.debug(kwagrs)
            plugin = kwagrs["plugin"]
            url = kwagrs["url"]
            filename = kwagrs["filename"]
            temp_path = kwagrs["temp_path"]
            save_path = kwagrs["save_path"]
            opts = {"skip_download": True}
            if (
                "all_thumbnails" in kwagrs
                and str(kwagrs["all_thumbnails"]).lower() != "false"
            ):
                opts["write_all_thumbnails"] = True
            else:
                opts["writethumbnail"] = True
            if "playlist" in kwagrs and kwagrs["playlist"]:
                if kwagrs["playlist"] == "reverse":
                    opts["playlistreverse"] = True
                elif kwagrs["playlist"] == "random":
                    opts["playlistrandom"] = True
                else:
                    opts["playlist_items"] = kwagrs["playlist"]
            if "archive" in kwagrs and kwagrs["archive"]:
                opts["download_archive"] = kwagrs["archive"]
            if "proxy" in kwagrs and kwagrs["proxy"]:
                opts["proxy"] = kwagrs["proxy"]
            if "ffmpeg_path" in kwagrs and kwagrs["ffmpeg_path"]:
                opts["ffmpeg_location"] = kwagrs["ffmpeg_path"]
            if "cookiefile" in kwagrs and kwagrs["cookiefile"]:
                opts["cookiefile"] = kwagrs["cookiefile"]
            dateafter = kwagrs.get("dateafter")
            youtube_dl = MyYoutubeDL(
                plugin,
                "thumbnail",
                url,
                filename,
                temp_path,
                save_path,
                opts,
                dateafter,
            )
            youtube_dl.key = kwagrs.get("key")
            LogicMain.youtube_dl_list.append(youtube_dl)  # 리스트 추가
            return youtube_dl
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())
            return None

    @staticmethod
    def sub(**kwagrs):
        try:
            logger.debug(kwagrs)
            plugin = kwagrs["plugin"]
            url = kwagrs["url"]
            filename = kwagrs["filename"]
            temp_path = kwagrs["temp_path"]
            save_path = kwagrs["save_path"]
            opts = {"skip_download": True}
            sub_lang = map(
                lambda x: x.strip(), kwagrs["sub_lang"].split(",")
            )  # 문자열을 리스트로 변환
            if "all_subs" in kwagrs and str(kwagrs["all_subs"]).lower() != "false":
                opts["allsubtitles"] = True
            else:
                opts["subtitleslangs"] = sub_lang
            if "auto_sub" in kwagrs and str(kwagrs["auto_sub"]).lower() != "false":
                opts["writeautomaticsub"] = True
            else:
                opts["writesubtitles"] = True
            if "playlist" in kwagrs and kwagrs["playlist"]:
                if kwagrs["playlist"] == "reverse":
                    opts["playlistreverse"] = True
                elif kwagrs["playlist"] == "random":
                    opts["playlistrandom"] = True
                else:
                    opts["playlist_items"] = kwagrs["playlist"]
            if "archive" in kwagrs and kwagrs["archive"]:
                opts["download_archive"] = kwagrs["archive"]
            if "proxy" in kwagrs and kwagrs["proxy"]:
                opts["proxy"] = kwagrs["proxy"]
            if "ffmpeg_path" in kwagrs and kwagrs["ffmpeg_path"]:
                opts["ffmpeg_location"] = kwagrs["ffmpeg_path"]
            if "cookiefile" in kwagrs and kwagrs["cookiefile"]:
                opts["cookiefile"] = kwagrs["cookiefile"]
            dateafter = kwagrs.get("dateafter")
            youtube_dl = MyYoutubeDL(
                plugin, "subtitle", url, filename, temp_path, save_path, opts, dateafter
            )
            youtube_dl.key = kwagrs.get("key")
            LogicMain.youtube_dl_list.append(youtube_dl)  # 리스트 추가
            return youtube_dl
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())
            return None

    @staticmethod
    def get_data(youtube_dl):
        try:
            data = {}
            data["plugin"] = youtube_dl.plugin
            data["url"] = youtube_dl.url
            data["filename"] = youtube_dl.filename
            data["temp_path"] = youtube_dl.temp_path
            data["save_path"] = youtube_dl.save_path
            data["index"] = youtube_dl.index
            data["status_str"] = youtube_dl.status.name
            data["status_ko"] = str(youtube_dl.status)
            data["end_time"] = ""
            data["extractor"] = youtube_dl.type + (
                " - " + youtube_dl.info_dict["extractor"]
                if youtube_dl.info_dict["extractor"] is not None
                else ""
            )
            data["title"] = (
                youtube_dl.info_dict["title"]
                if youtube_dl.info_dict["title"] is not None
                else youtube_dl.url
            )
            data["uploader"] = (
                youtube_dl.info_dict["uploader"]
                if youtube_dl.info_dict["uploader"] is not None
                else ""
            )
            data["uploader_url"] = (
                youtube_dl.info_dict["uploader_url"]
                if youtube_dl.info_dict["uploader_url"] is not None
                else ""
            )
            data["downloaded_bytes_str"] = ""
            data["total_bytes_str"] = ""
            data["percent"] = "0"
            data["eta"] = (
                youtube_dl.progress_hooks["eta"]
                if youtube_dl.progress_hooks["eta"] is not None
                else ""
            )
            data["speed_str"] = (
                LogicMain.human_readable_size(youtube_dl.progress_hooks["speed"], "/s")
                if youtube_dl.progress_hooks["speed"] is not None
                else ""
            )
            if youtube_dl.status == Status.READY:  # 다운로드 전
                data["start_time"] = ""
                data["download_time"] = ""
            else:
                if youtube_dl.end_time is None:  # 완료 전
                    download_time = datetime.now() - youtube_dl.start_time
                else:
                    download_time = youtube_dl.end_time - youtube_dl.start_time
                    data["end_time"] = youtube_dl.end_time.strftime("%m-%d %H:%M:%S")
                if None not in (
                    youtube_dl.progress_hooks["downloaded_bytes"],
                    youtube_dl.progress_hooks["total_bytes"],
                ):  # 둘 다 값이 있으면
                    data["downloaded_bytes_str"] = LogicMain.human_readable_size(
                        youtube_dl.progress_hooks["downloaded_bytes"]
                    )
                    data["total_bytes_str"] = LogicMain.human_readable_size(
                        youtube_dl.progress_hooks["total_bytes"]
                    )
                    data[
                        "percent"
                    ] = f"{(float(youtube_dl.progress_hooks['downloaded_bytes']) / float(youtube_dl.progress_hooks['total_bytes']) * 100):.2f}"
                data["start_time"] = youtube_dl.start_time.strftime("%m-%d %H:%M:%S")
                data[
                    "download_time"
                ] = f"{int(download_time.seconds / 60):02d}:{int(download_time.seconds % 60):02d}"
            return data
        except Exception as error:
            logger.error("Exception:%s", error)
            logger.error(traceback.format_exc())
            return None

    @staticmethod
    def get_info_dict(url, proxy):
        return MyYoutubeDL.get_info_dict(url, proxy)

    @staticmethod
    def human_readable_size(size, suffix=""):
        for unit in ("Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB"):
            if size < 1024.0:
                return f"{size:3.1f} {unit}{suffix}"
            size /= 1024.0
        return f"{size:.1f} YB{suffix}"

    @staticmethod
    def socketio_emit(cmd, data):
        socketio.emit(
            cmd, LogicMain.get_data(data), namespace=f"/{package_name}", broadcast=True
        )