#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, unicode_literals

from ..plex_db import PlexDB
from ..plex_api import API
from .. import plex_functions as PF, utils, kodi_db, variables as v, app

# Our PKC playqueues (3 instances of PlayQueue())
PLAYQUEUES = []


class PlayqueueError(Exception):
    """
    Exception for our playqueue constructs
    """
    pass


class PlaylistItem(object):
    """
    Object to fill our playqueues and playlists with.

    id = None          [int] Plex playlist/playqueue id, e.g. playQueueItemID
    plex_id = None     [int] Plex unique item id, "ratingKey"
    plex_type = None   [str] Plex type, e.g. 'movie', 'clip'
    plex_uuid = None   [str] Plex librarySectionUUID
    kodi_id = None     [int] Kodi unique kodi id (unique only within type!)
    kodi_type = None   [str] Kodi type: 'movie'
    file = None        [str] Path to the item's file. STRING!!
    uri = None         [str] Weird Plex uri path involving plex_uuid. STRING!
    guid = None        [str] Weird Plex guid
    xml = None         [etree] XML from PMS, 1 lvl below <MediaContainer>
    playmethod = None  [str] either 'DirectPlay', 'DirectStream', 'Transcode'
    playcount = None   [int] how many times the item has already been played
    offset = None      [int] the item's view offset UPON START in Plex time
    part = 0           [int] part number if Plex video consists of mult. parts
    force_transcode    [bool] defaults to False

    PlaylistItem compare as equal, if they
    - have the same plex_id
    - OR: have the same kodi_id AND kodi_type
    - OR: have the same file
    """
    def __init__(self, plex_id=None, plex_type=None, xml_video_element=None,
                 kodi_id=None, kodi_type=None, kodi_item=None, grab_xml=False,
                 lookup_kodi=True):
        """
        Pass grab_xml=True in order to get Plex metadata from the PMS while
        passing a plex_id.
        Pass lookup_kodi=False to NOT check the plex.db for kodi_id and
        kodi_type if they're missing (won't be done for clips anyway)
        """
        self.name = None
        self.id = None
        self.plex_id = plex_id
        self.plex_type = plex_type
        self.plex_uuid = None
        self.kodi_id = kodi_id
        self.kodi_type = kodi_type
        self.file = None
        if kodi_item:
            self.kodi_id = utils.cast(int, kodi_item.get('id'))
            self.kodi_type = kodi_item.get('type')
            self.file = kodi_item.get('file')
        self.uri = None
        self.guid = None
        self.xml = None
        self.playmethod = None
        self.playcount = None
        self.offset = None
        self.part = 0
        self.force_transcode = False
        # Shall we ask user to resume this item?
        #   None: ask user to resume
        #   False: do NOT resume, don't ask user
        #   True: do resume, don't ask user
        self.resume = None
        if self.plex_id is None:
            self._from_plex_db()
        if grab_xml and self.plex_id is not None and xml_video_element is None:
            xml_video_element = PF.GetPlexMetadata(plex_id)
            try:
                xml_video_element = xml_video_element[0]
            except (TypeError, IndexError):
                xml_video_element = None
        if xml_video_element is not None:
            self.from_xml(xml_video_element)
        if (lookup_kodi and (self.kodi_id is None or self.kodi_type is None) and
                self.plex_type != v.PLEX_TYPE_CLIP):
            with PlexDB(lock=False) as plexdb:
                db_item = plexdb.item_by_id(self.plex_id, self.plex_type)
            if db_item is not None:
                self.kodi_id = db_item['kodi_id']
                self.kodi_type = db_item['kodi_type']
                self.plex_type = db_item['plex_type']
                self.plex_uuid = db_item['section_uuid']
        if (lookup_kodi and (self.kodi_id is None or self.kodi_type is None) and
                self.plex_type != v.PLEX_TYPE_CLIP):
            self._guess_id_from_file()
            self._from_plex_db()
        self._set_uri()

    def __eq__(self, other):
        if self.plex_id is not None and other.plex_id is not None:
            return self.plex_id == other.plex_id
        elif (self.kodi_id is not None and other.kodi_id is not None and
              self.kodi_type and other.kodi_type):
            return (self.kodi_id == other.kodi_id and
                    self.kodi_type == other.kodi_type)
        elif self.file and other.file:
            return self.file == other.file
        raise RuntimeError('PlaylistItems not fully defined: %s, %s' %
                           (self, other))

    def __ne__(self, other):
        return not self == other

    def __unicode__(self):
        return ("{{"
                "'name': '{self.name}', "
                "'id': {self.id}, "
                "'plex_id': {self.plex_id}, "
                "'plex_type': '{self.plex_type}', "
                "'kodi_id': {self.kodi_id}, "
                "'kodi_type': '{self.kodi_type}', "
                "'file': '{self.file}', "
                "'uri': '{self.uri}', "
                "'guid': '{self.guid}', "
                "'playmethod': '{self.playmethod}', "
                "'playcount': {self.playcount}, "
                "'offset': {self.offset}, "
                "'force_transcode': {self.force_transcode}, "
                "'part': {self.part}"
                "}}".format(self=self))

    def __str__(self):
        return unicode(self).encode('utf-8')
    __repr__ = __str__

    def _from_plex_db(self):
        """
        Uses self.kodi_id and self.kodi_type to look up the item in the Plex
        DB. Thus potentially sets self.plex_id, plex_type, plex_uuid
        """
        if self.kodi_id is None or not self.kodi_type:
            return
        with PlexDB(lock=False) as plexdb:
            db_item = plexdb.item_by_kodi_id(self.kodi_id, self.kodi_type)
        if db_item:
            self.plex_id = db_item['plex_id']
            self.plex_type = db_item['plex_type']
            self.plex_uuid = db_item['section_uuid']

    def from_xml(self, xml_video_element):
        """
        xml_video_element: etree xml piece 1 level underneath <MediaContainer>
        item.id will only be set if you passed in an xml_video_element from
        e.g. a playQueue
        """
        api = API(xml_video_element)
        self.name = api.title()
        self.plex_id = api.plex_id()
        self.plex_type = api.plex_type()
        self.id = api.item_id()
        self.guid = api.guid_html_escaped()
        self.playcount = api.viewcount()
        self.offset = api.resume_point()
        self.xml = xml_video_element
        if self.kodi_id is None or not self.kodi_type:
            self._from_plex_db()
        self._set_uri()

    def from_kodi(self, playlist_item):
        """
        playlist_item: dict contains keys 'id', 'type', 'file' (if applicable)

        Will thus set the attributes kodi_id, kodi_type, file, if applicable
        If kodi_id & kodi_type are provided, plex_id and plex_type will be
        looked up (if not already set)
        """
        self.kodi_id = utils.cast(int, playlist_item.get('id'))
        self.kodi_type = playlist_item.get('type')
        self.file = playlist_item.get('file')
        if self.plex_id is None and self.kodi_id is not None and self.kodi_type:
            self._from_plex_db()
        if self.plex_id is None and self.file:
            try:
                query = self.file.split('?', 1)[1]
            except IndexError:
                query = ''
            query = dict(utils.parse_qsl(query))
            self.plex_id = utils.cast(int, query.get('plex_id'))
            self.plex_type = query.get('itemType')
        self._set_uri()

    def _set_uri(self):
        if self.plex_id is None and self.file is not None:
            self.uri = ('library://whatever/item/%s'
                        % utils.quote(self.file, safe=''))
        elif self.plex_id is not None and self.plex_uuid is not None:
            self.uri = ('library://%s/item/library%%2Fmetadata%%2F%s' %
                        (self.plex_uuid, self.plex_id))
        elif self.plex_id is not None:
            self.uri = ('library://%s/item/library%%2Fmetadata%%2F%s' %
                        (self.plex_id, self.plex_id))
        else:
            self.uri = None

    def _guess_id_from_file(self):
        """
        If self.file is set, will try to guess kodi_id and kodi_type from the
        filename and path using the Kodi video and music databases
        """
        if not self.file:
            return
        # Special case playlist startup - got type but no id
        if (not app.SYNC.direct_paths and app.SYNC.enable_music and
                self.kodi_type == v.KODI_TYPE_SONG and
                self.file.startswith('http')):
            self.kodi_id, _ = kodi_db.kodiid_from_filename(self.file,
                                                           v.KODI_TYPE_SONG)
            return
        # Need more info since we don't have kodi_id nor type. Use file path.
        if (self.file.startswith('plugin') or
                (self.file.startswith('http') and not
                 self.file.startswith('http://127.0.0.1:%s' % v.WEBSERVICE_PORT))):
            return
        # Try the VIDEO DB first - will find both movies and episodes
        self.kodi_id, self.kodi_type = kodi_db.kodiid_from_filename(
            self.file, db_type='video')
        if self.kodi_id is None:
            # No movie or episode found - try MUSIC DB now for songs
            self.kodi_id, self.kodi_type = kodi_db.kodiid_from_filename(
                self.file, db_type='music')
        self.kodi_type = None if self.kodi_id is None else self.kodi_type

    def plex_stream_index(self, kodi_stream_index, stream_type):
        """
        Pass in the kodi_stream_index [int] in order to receive the Plex stream
        index.

            stream_type:    'video', 'audio', 'subtitle'

        Returns None if unsuccessful
        """
        stream_type = v.PLEX_STREAM_TYPE_FROM_STREAM_TYPE[stream_type]
        count = 0
        if kodi_stream_index == -1:
            # Kodi telling us "it's the last one"
            iterator = list(reversed(self.xml[0][self.part]))
            kodi_stream_index = 0
        else:
            iterator = self.xml[0][self.part]
        # Kodi indexes differently than Plex
        for stream in iterator:
            if (stream.attrib['streamType'] == stream_type and
                    'key' in stream.attrib):
                if count == kodi_stream_index:
                    return stream.attrib['id']
                count += 1
        for stream in iterator:
            if (stream.attrib['streamType'] == stream_type and
                    'key' not in stream.attrib):
                if count == kodi_stream_index:
                    return stream.attrib['id']
                count += 1

    def kodi_stream_index(self, plex_stream_index, stream_type):
        """
        Pass in the kodi_stream_index [int] in order to receive the Plex stream
        index.

            stream_type:    'video', 'audio', 'subtitle'

        Returns None if unsuccessful
        """
        stream_type = v.PLEX_STREAM_TYPE_FROM_STREAM_TYPE[stream_type]
        count = 0
        for stream in self.xml[0][self.part]:
            if (stream.attrib['streamType'] == stream_type and
                    'key' in stream.attrib):
                if stream.attrib['id'] == plex_stream_index:
                    return count
                count += 1
        for stream in self.xml[0][self.part]:
            if (stream.attrib['streamType'] == stream_type and
                    'key' not in stream.attrib):
                if stream.attrib['id'] == plex_stream_index:
                    return count
                count += 1


class PlaylistItemDummy(PlaylistItem):
    """
    Let e.g. Kodimonitor detect that this is a dummy item
    """
    def __init__(self, *args, **kwargs):
        super(PlaylistItemDummy, self).__init__(*args, **kwargs)
        self.name = 'PKC Dummy playqueue item'
        self.id = 0
        self.plex_id = 0