# -*- coding: utf-8 -*-

###############################################################################

from utils import kodiSQL
import logging

###############################################################################

log = logging.getLogger("PLEX."+__name__)

###############################################################################


class Get_Plex_DB():
    """
    Usage: with Get_Plex_DB() as plexcursor:
               plexcursor.do_something()

    On exiting "with" (no matter what), commits get automatically committed
    and the db gets closed
    """
    def __enter__(self):
        self.plexconn = kodiSQL('plex')
        self.plexcursor = Plex_DB_Functions(self.plexconn.cursor())
        return self.plexcursor

    def __exit__(self, type, value, traceback):
        self.plexconn.commit()
        self.plexconn.close()


class Plex_DB_Functions():

    def __init__(self, plexcursor):

        self.plexcursor = plexcursor

    def getViews(self):

        views = []

        query = ' '.join((

            "SELECT view_id",
            "FROM view"
        ))
        self.plexcursor.execute(query)
        rows = self.plexcursor.fetchall()
        for row in rows:
            views.append(row[0])
        return views

    def getAllViewInfo(self):

        plexcursor = self.plexcursor
        views = []

        query = ' '.join((

            "SELECT view_id, view_name, media_type",
            "FROM view"
        ))
        plexcursor.execute(query)
        rows = plexcursor.fetchall()
        for row in rows:
            views.append({'id': row[0],
                          'name': row[1],
                          'itemtype': row[2]})
        return views

    def getView_byId(self, viewid):


        query = ' '.join((

            "SELECT view_name, media_type, kodi_tagid",
            "FROM view",
            "WHERE view_id = ?"
        ))
        self.plexcursor.execute(query, (viewid,))
        view = self.plexcursor.fetchone()
        
        return view

    def getView_byType(self, mediatype):

        views = []

        query = ' '.join((

            "SELECT view_id, view_name, media_type",
            "FROM view",
            "WHERE media_type = ?"
        ))
        self.plexcursor.execute(query, (mediatype,))
        rows = self.plexcursor.fetchall()
        for row in rows:
            views.append({

                'id': row[0],
                'name': row[1],
                'itemtype': row[2]
            })

        return views

    def getView_byName(self, tagname):

        query = ' '.join((

            "SELECT view_id",
            "FROM view",
            "WHERE view_name = ?"
        ))
        self.plexcursor.execute(query, (tagname,))
        try:
            view = self.plexcursor.fetchone()[0]
        
        except TypeError:
            view = None

        return view

    def addView(self, plexid, name, mediatype, tagid):

        query = (
            '''
            INSERT INTO view(
                view_id, view_name, media_type, kodi_tagid)

            VALUES (?, ?, ?, ?)
            '''
        )
        self.plexcursor.execute(query, (plexid, name, mediatype, tagid))

    def updateView(self, name, tagid, mediafolderid):

        query = ' '.join((

            "UPDATE view",
            "SET view_name = ?, kodi_tagid = ?",
            "WHERE view_id = ?"
        ))
        self.plexcursor.execute(query, (name, tagid, mediafolderid))

    def removeView(self, viewid):

        query = ' '.join((

            "DELETE FROM view",
            "WHERE view_id = ?"
        ))
        self.plexcursor.execute(query, (viewid,))

    def getItem_byFileId(self, fileId, kodiType):
        """
        Returns the Plex itemId by using the Kodi fileId. VIDEO ONLY

        kodiType: 'movie', 'episode', ...
        """
        query = ' '.join((
            "SELECT emby_id",
            "FROM emby",
            "WHERE kodi_fileid = ? AND media_type = ?"
        ))
        try:
            self.plexcursor.execute(query, (fileId, kodiType))
            item = self.plexcursor.fetchone()[0]
            return item
        except:
            return None

    def getMusicItem_byFileId(self, fileId, kodiType):
        """
        Returns the Plex itemId by using the Kodi fileId. MUSIC ONLY

        kodiType: 'song'
        """
        query = ' '.join((
            "SELECT emby_id",
            "FROM emby",
            "WHERE kodi_id = ? AND media_type = ?"
        ))
        try:
            self.plexcursor.execute(query, (fileId, kodiType))
            item = self.plexcursor.fetchone()[0]
            return item
        except:
            return None

    def getItem_byId(self, plexid):

        query = ' '.join((

            "SELECT kodi_id, kodi_fileid, kodi_pathid, parent_id, media_type, emby_type",
            "FROM emby",
            "WHERE emby_id = ?"
        ))
        try:
            self.plexcursor.execute(query, (plexid,))
            item = self.plexcursor.fetchone()
            return item
        except: return None

    def getItem_byWildId(self, plexid):

        query = ' '.join((

            "SELECT kodi_id, media_type",
            "FROM emby",
            "WHERE emby_id LIKE ?"
        ))
        self.plexcursor.execute(query, (plexid+"%",))
        return self.plexcursor.fetchall()

    def getItem_byView(self, mediafolderid):

        query = ' '.join((

            "SELECT kodi_id",
            "FROM emby",
            "WHERE media_folder = ?"
        ))
        self.plexcursor.execute(query, (mediafolderid,))
        return self.plexcursor.fetchall()

    def getPlexId(self, kodiid, mediatype):
        """
        Returns the Plex ID usind the Kodiid. Result:
            (Plex Id, Parent's Plex Id)
        """
        query = ' '.join((
            "SELECT emby_id, parent_id",
            "FROM emby",
            "WHERE kodi_id = ? AND media_type = ?"
        ))
        try:
            self.plexcursor.execute(query, (kodiid, mediatype))
            item = self.plexcursor.fetchone()
            return item
        except:
            return None

    def getItem_byKodiId(self, kodiid, mediatype):

        query = ' '.join((

            "SELECT emby_id, parent_id",
            "FROM emby",
            "WHERE kodi_id = ?",
            "AND media_type = ?"
        ))
        self.plexcursor.execute(query, (kodiid, mediatype,))
        return self.plexcursor.fetchone()

    def getItem_byParentId(self, parentid, mediatype):

        query = ' '.join((

            "SELECT emby_id, kodi_id, kodi_fileid",
            "FROM emby",
            "WHERE parent_id = ?",
            "AND media_type = ?"
        ))
        self.plexcursor.execute(query, (parentid, mediatype,))
        return self.plexcursor.fetchall()

    def getItemId_byParentId(self, parentid, mediatype):

        query = ' '.join((

            "SELECT emby_id, kodi_id",
            "FROM emby",
            "WHERE parent_id = ?",
            "AND media_type = ?"
        ))
        self.plexcursor.execute(query, (parentid, mediatype,))
        return self.plexcursor.fetchall()

    def getChecksum(self, mediatype):

        query = ' '.join((

            "SELECT emby_id, checksum",
            "FROM emby",
            "WHERE emby_type = ?"
        ))
        self.plexcursor.execute(query, (mediatype,))
        return self.plexcursor.fetchall()

    def getMediaType_byId(self, plexid):

        query = ' '.join((

            "SELECT emby_type",
            "FROM emby",
            "WHERE emby_id = ?"
        ))
        self.plexcursor.execute(query, (plexid,))
        try:
            itemtype = self.plexcursor.fetchone()[0]
        
        except TypeError:
            itemtype = None

        return itemtype

    def sortby_mediaType(self, itemids, unsorted=True):

        sorted_items = {}
        
        for itemid in itemids:
            mediatype = self.getMediaType_byId(itemid)
            if mediatype:
                sorted_items.setdefault(mediatype, []).append(itemid)
            elif unsorted:
                sorted_items.setdefault('Unsorted', []).append(itemid)

        return sorted_items

    def addReference(self, plexid, kodiid, embytype, mediatype, fileid=None, pathid=None,
                        parentid=None, checksum=None, mediafolderid=None):
        query = (
            '''
            INSERT OR REPLACE INTO emby(
                emby_id, kodi_id, kodi_fileid, kodi_pathid, emby_type, media_type, parent_id,
                checksum, media_folder)

            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
            '''
        )
        self.plexcursor.execute(query, (plexid, kodiid, fileid, pathid, embytype, mediatype,
            parentid, checksum, mediafolderid))

    def updateReference(self, plexid, checksum):

        query = "UPDATE emby SET checksum = ? WHERE emby_id = ?"
        self.plexcursor.execute(query, (checksum, plexid))

    def updateParentId(self, plexid, parent_kodiid):
        
        query = "UPDATE emby SET parent_id = ? WHERE emby_id = ?"
        self.plexcursor.execute(query, (parent_kodiid, plexid))

    def removeItems_byParentId(self, parent_kodiid, mediatype):

        query = ' '.join((

            "DELETE FROM emby",
            "WHERE parent_id = ?",
            "AND media_type = ?"
        ))
        self.plexcursor.execute(query, (parent_kodiid, mediatype,))

    def removeItem_byKodiId(self, kodiid, mediatype):

        query = ' '.join((

            "DELETE FROM emby",
            "WHERE kodi_id = ?",
            "AND media_type = ?"
        ))
        self.plexcursor.execute(query, (kodiid, mediatype,))

    def removeItem(self, plexid):

        query = "DELETE FROM emby WHERE emby_id = ?"
        self.plexcursor.execute(query, (plexid,))

    def removeWildItem(self, plexid):

        query = "DELETE FROM emby WHERE emby_id LIKE ?"
        self.plexcursor.execute(query, (plexid+"%",))

    def itemsByType(self, plextype):
        """
        Returns a list of dictionaries for all Kodi DB items present for
        plextype. One dict is of the type

        {
            'plexId':       the Plex id
            'kodiId':       the Kodi id
            'kodi_type':    e.g. 'movie', 'tvshow'
            'plex_type':    e.g. 'Movie', 'Series', the input plextype
        }
        """
        query = ' '.join((
            "SELECT emby_id, kodi_id, media_type",
            "FROM emby",
            "WHERE emby_type = ?",
        ))
        self.plexcursor.execute(query, (plextype, ))
        result = []
        for row in self.plexcursor.fetchall():
            result.append({
                'plexId': row[0],
                'kodiId': row[1],
                'kodi_type': row[2],
                'plex_type': plextype
            })
        return result