#!/usr/bin/env python
# coding: utf-8

import pluginInterfaces as pi
import utils

import mimetypes
import json
import logging
import datetime
import pytz
from os.path import splitext, basename, abspath
from tzlocal import get_localzone

from configparser import RawConfigParser
from requests_oauthlib import OAuth2Session
from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
from oauthlib.oauth2 import LegacyApplicationClient
from clint.textui.progress import Bar as ProgressBar
from yapsy.PluginManager import PluginManagerSingleton

logger = logging.getLogger('Prismedia')
upload_finished = False


class Peertube(pi.IPlatformPlugin):
    """
    Plugin to upload to the Peertube platform.
    The connections files should be set as # TODO: EXPLAIN HOW TO SETUP THE SECRET FILES
    - `publish-at-peertube=DATE`: overrides the default `publish-at=DATE` for this platform. # TODO: Maybe we will use a [<plugin_name>] section on the config fire, explain that.
    """
    NAME = "peertube"    # TODO: find if it is possible to get the plugin’s name from inside the plugin
    SECRETS_FILE = "peertube_secret"
    PRIVACY = {
        "public": 1,
        "unlisted": 2,
        "private": 3
    }

    CATEGORY = {
        "music": 1,
        "films": 2,
        "vehicles": 3,
        "sport": 5,
        "travels": 6,
        "gaming": 7,
        "people": 8,
        "comedy": 9,
        "entertainment": 10,
        "news": 11,
        "how to": 12,
        "education": 13,
        "activism": 14,
        "science & technology": 15,
        "science": 15,
        "technology": 15,
        "animals": 16
    }

    LANGUAGE = {
        "arabic": "ar",
        "english": "en",
        "french": "fr",
        "german": "de",
        "hindi": "hi",
        "italian": "it",
        "japanese": "ja",
        "korean": "ko",
        "mandarin": "zh",
        "portuguese": "pt",
        "punjabi": "pa",
        "russian": "ru",
        "spanish": "es"
    }

    def __init__(self):
        self.channelCreate = False
        self.oauth = {}
        self.secret = {}

    def prepare_options(self, video, options):
        pluginManager = PluginManagerSingleton.get()
        # TODO: get the `publish-at-peertube=DATE` option
        # TODO: get the `channel` and `channel-create` options
        pluginManager.registerOptionFromPlugin("Platform", self.NAME, "publish-at", "2034-05-07T19:00:00")
        pluginManager.registerOptionFromPlugin("Platform", self.NAME, "channel", "toto")
        pluginManager.registerOptionFromPlugin("Platform", self.NAME, "channel-create", False)
        video.platform[self.NAME].channel = ""

        self.secret = RawConfigParser()
        self.secret.read(self.SECRETS_FILE)
        self.get_authenticated_service()

        return True

    def get_authenticated_service(self):
        instance_url = str(self.secret.get('peertube', 'peertube_url')).rstrip("/")

        oauth_client = LegacyApplicationClient(
            client_id=str(self.secret.get('peertube', 'client_id'))
        )
        self.oauth = OAuth2Session(client=oauth_client)
        self.oauth.fetch_token(
            token_url=str(instance_url + '/api/v1/users/token'),
            # lower as peertube does not store uppercase for pseudo
            username=str(self.secret.get('peertube', 'username').lower()),
            password=str(self.secret.get('peertube', 'password')),
            client_id=str(self.secret.get('peertube', 'client_id')),
            client_secret=str(self.secret.get('peertube', 'client_secret'))
        )

    def convert_peertube_date(self, date):
        date = datetime.datetime.strptime(date, '%Y-%m-%dT%H:%M:%S')
        tz = get_localzone()
        tz = pytz.timezone(str(tz))
        return tz.localize(date).isoformat()

    def get_default_channel(self, user_info):
        return user_info['videoChannels'][0]['id']

    def get_channel_by_name(self, user_info, video):
        for channel in user_info["videoChannels"]:
            if channel['displayName'] == video.platform[self.NAME].channel:
                return channel['id']

    def create_channel(self, instance_url, video):
        template = ('Peertube: Channel %s does not exist, creating it.')
        logger.info(template % (video.platform[self.NAME].channel))
        channel_name = utils.cleanString(video.platform[self.NAME].channel)
        # Peertube allows 20 chars max for channel name
        channel_name = channel_name[:19]
        data = '{"name":"' + channel_name + '", \
                "displayName":"' + video.platform[self.NAME].channel + '", \
                "description":null, \
                "support":null}'

        headers = {
            'Content-Type': "application/json; charset=UTF-8"
        }
        try:
            response = self.oauth.post(instance_url + "/api/v1/video-channels/",
                                       data=data.encode('utf-8'),
                                       headers=headers)
        except Exception as e:
            logger.error("Peertube: " + utils.get_exception_string(e))

        if response is not None:
            if response.status_code == 200:
                jresponse = response.json()
                jresponse = jresponse['videoChannel']
                return jresponse['id']
            if response.status_code == 409:
                logger.critical('Peertube: It seems there is a conflict with an existing channel named '
                                + channel_name + '.'
                                                 ' Please beware Peertube internal name is compiled from 20 firsts characters of channel name.'
                                                 ' Also note that channel name are not case sensitive (no uppercase nor accent)'
                                                 ' Please check your channel name and retry.')
                exit(1)
            else:
                logger.critical(('Peertube: Creating channel failed with an unexpected response: '
                                 '%s') % response)
                exit(1)

    def get_default_playlist(self, user_info):
        return user_info['videoChannels'][0]['id']

    def get_playlist_by_name(self, instance_url, username, video):
        start = 0
        user_playlists = json.loads(self.oauth.get(
            instance_url + "/api/v1/accounts/" + username + "/video-playlists?start=" + str(
                start) + "&count=100").content)
        total = user_playlists["total"]
        data = user_playlists["data"]
        # We need to iterate on pagination as peertube returns max 100 playlists (see #41)
        while start < total:
            for playlist in data:
                if playlist['displayName'] == video.playlistName:
                    return playlist['id']
            start = start + 100
            user_playlists = json.loads(self.oauth.get(
                instance_url + "/api/v1/accounts/" + username + "/video-playlists?start=" + str(
                    start) + "&count=100").content)
            data = user_playlists["data"]

    def create_playlist(self, instance_url, video, channel):
        template = ('Peertube: Playlist %s does not exist, creating it.')
        logger.info(template % (str(video.playlistName)))
        # We use files for form-data Content
        # see https://requests.readthedocs.io/en/latest/user/quickstart/#post-a-multipart-encoded-file
        # None is used to mute "filename" field
        files = {'displayName': (None, str(video.playlistName)),
                 'privacy': (None, "1"),
                 'description': (None, "null"),
                 'videoChannelId': (None, str(channel)),
                 'thumbnailfile': (None, "null")}

        try:
            response = self.oauth.post(instance_url + "/api/v1/video-playlists/",
                                       files=files)
        except Exception as e:
            logger.error("Peertube: " + utils.get_exception_string(e))

        if response is not None:
            if response.status_code == 200:
                jresponse = response.json()
                jresponse = jresponse['videoPlaylist']
                return jresponse['id']
            else:
                logger.critical(('Peertube: Creating the playlist failed with an unexpected response: '
                                 '%s') % response)
                exit(1)

    def set_playlist(self, instance_url, video_id, playlist_id):
        logger.info('Peertube: add video to playlist.')
        data = '{"videoId":"' + str(video_id) + '"}'

        headers = {
            'Content-Type': "application/json"
        }

        try:
            response = self.oauth.post(instance_url + "/api/v1/video-playlists/" + str(playlist_id) + "/videos",
                                       data=data,
                                       headers=headers)
        except Exception as e:
            logger.error("Peertube: " + utils.get_exception_string(e))

        if response is not None:
            if response.status_code == 200:
                logger.info('Peertube: Video is successfully added to the playlist.')
            else:
                logger.critical(('Peertube: Configuring the playlist failed with an unexpected response: '
                                 '%s') % response)
                exit(1)

    def upload_video(self, video, options):

        def get_userinfo(base_url):
            return json.loads(self.oauth.get(base_url + "/api/v1/users/me").content)

        def get_file(video_path):
            mimetypes.init()
            return (basename(video_path), open(abspath(video_path), 'rb'),
                    mimetypes.types_map[splitext(video_path)[1]])

        path = video.path
        instance_url = str(self.secret.get('peertube', 'peertube_url')).rstrip('/')
        user_info = get_userinfo(instance_url)
        username = str(self.secret.get('peertube', 'username').lower())

        # We need to transform fields into tuple to deal with tags as
        # MultipartEncoder does not support list refer
        # https://github.com/requests/toolbelt/issues/190 and
        # https://github.com/requests/toolbelt/issues/205
        fields = [
            ("name", video.name),
            ("licence", "1"),  # TODO: get licence from video object
            ("description", video.description),
            ("category", str(self.CATEGORY[video.category])),
            ("language", str(self.LANGUAGE[video.language])),
            ("commentsEnabled", "0" if video.disableComments else "1"),
            ("nsfw", "1" if video.nsfw else "0"),
            ("videofile", get_file(path))
        ]

        tag_number = 0
        for strtag in video.tags:
            tag_number = tag_number + 1
            # Empty tag crashes Peertube, so skip them
            if strtag == "":
                continue
            # Tag more than 30 chars crashes Peertube, so skip tags
            if len(strtag) >= 30:
                logger.warning(
                    "Peertube: Sorry, Peertube does not support tag with more than 30 characters, please reduce tag: " + strtag)
                logger.warning("Peertube: Meanwhile, this tag will be skipped")
                continue
            # Peertube supports only 5 tags at the moment
            if tag_number > 5:
                logger.warning("Peertube: Sorry, Peertube support 5 tags max, additional tag will be skipped")
                logger.warning("Peertube: Skipping tag " + strtag)
                continue
            fields.append(("tags[]", strtag))

        # If peertubeAt exists, use instead of publishAt
        if video.platform[self.NAME].publishAt:
            publishAt = video.platform[self.NAME].publishAt
        elif video.publishAt:
            publishAt = video.publishAt

        if 'publishAt' in locals():
            publishAt = convert_peertube_date(publishAt)
            fields.append(("scheduleUpdate[updateAt]", publishAt))
            fields.append(("scheduleUpdate[privacy]", str(self.PRIVACY["public"])))
            fields.append(("privacy", str(self.PRIVACY["private"])))
        else:
            fields.append(("privacy", str(self.PRIVACY[video.privacy])))

        if video.originalDate:
            originalDate = convert_peertube_date(video.originalDate)
            fields.append(("originallyPublishedAt", originalDate))

        if video.thumbnail:
            fields.append(("thumbnailfile", get_file(video.thumbnail)))
            fields.append(("previewfile", get_file(video.thumbnail)))

        if hasattr(video.platform[self.NAME], "channel"):  # TODO: Should always be present
            channel_id = self.get_channel_by_name(user_info, video)
            if not channel_id and self.channelCreate:
                channel_id = self.create_channel(instance_url, video)
            elif not channel_id:
                logger.warning("Peertube: Channel `" + video.platform[
                    self.NAME].channel + "` is unknown, using default channel.")  # TODO: debate if we should have the same message and behavior than playlist: "does not exist, please set --channelCreate"
                channel_id = self.get_default_channel(user_info)
        else:
            channel_id = self.get_default_channel(user_info)

        fields.append(("channelId", str(channel_id)))

        if video.playlistName:
            playlist_id = get_playlist_by_name(instance_url, username, video)
            if not playlist_id and video.playlistCreate:
                playlist_id = create_playlist(instance_url, video, channel_id)
            elif not playlist_id:
                logger.critical(
                    "Peertube: Playlist `" + video.playlistName + "` does not exist, please set --playlistCreate"
                                                                  " if you want to create it")
                exit(1)

        encoder = MultipartEncoder(fields)
        if options.get('--quiet'):
            multipart_data = encoder
        else:
            progress_callback = self.create_callback(encoder, options.get('--progress'))
            multipart_data = MultipartEncoderMonitor(encoder, progress_callback)

        headers = {
            'Content-Type': multipart_data.content_type
        }
        response = self.oauth.post(instance_url + "/api/v1/videos/upload",
                                   data=multipart_data,
                                   headers=headers)

        if response is not None:
            if response.status_code == 200:
                jresponse = response.json()
                jresponse = jresponse['video']
                uuid = jresponse['uuid']
                video_id = str(jresponse['id'])

                logger.info("Peertube: Video was successfully uploaded.")
                template_url = "%s/videos/watch/%s"
                video.platform[self.NAME].url = template_url % (instance_url, uuid)
                logger.info("Peertube: Watch it at " + video.platform[self.NAME].url + ".")
                # Upload is successful we may set playlist
                if 'playlist_id' in locals():
                    set_playlist(instance_url, video_id, playlist_id)
            else:
                logger.critical(('Peertube: The upload failed with an unexpected response: '
                                 '%s') % response)
                exit(1)


    def create_callback(self, encoder, progress_type):
        upload_size_MB = encoder.len * (1 / (1024 * 1024))

        if progress_type is None or "percentage" in progress_type.lower():
            progress_lambda = lambda x: int((x / encoder.len) * 100) # Default to percentage
        elif "bigfile" in progress_type.lower():
            progress_lambda = lambda x: x * (1 / (1024 * 1024)) # MB
        elif "accurate" in progress_type.lower():
            progress_lambda = lambda x: x * (1 / (1024)) # kB
        else:
            # Should not happen outside of development when adding partly a progress type
            logger.critical("Peertube: Unknown progress type `" + progress_type + "`")
            exit(1)

        bar = ProgressBar(expected_size=progress_lambda(encoder.len), label=f"Peertube upload progress ({upload_size_MB:.2f}MB) ", filled_char='=')

        def callback(monitor):
            # We want the condition to capture the varible from the parent scope, not a local variable that is created after
            global upload_finished
            progress = progress_lambda(monitor.bytes_read)

            bar.show(progress)

            if monitor.bytes_read == encoder.len:
                if not upload_finished:
                    # We get two time in the callback with both bytes equals, skip the first
                    upload_finished = True
                else:
                    # Print a blank line to not (partly) override the progress bar
                    print()
                    logger.info("Peertube: Upload finish, Processing…")

        return callback

    def heartbeat(self):
        """
        If needed for your platform, use a bit of the api so the platform is aware the keys are still in use.
        """
        print("heartbeat for peertube (nothing to do)")
        pass

    # def run(options):
    def upload(self, video, options):
        logger.info('Peertube: Uploading video...')
        self.upload_video(video, options)