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

import glob
import os

from core import config
from core import filetools
from core import videolibrarytools
from core import logger
from core import scrapertools
from core.item import Item
from platformcode import platformtools


def mainlist(item):
    logger.info()

    itemlist = list()
    itemlist.append(Item(channel=item.channel, action="list_movies", title="Películas",
                         category="Videoteca de películas",
                         thumbnail=config.get_thumb("thumb_videolibrary_movie.png")))
    itemlist.append(Item(channel=item.channel, action="list_tvshows", title="Series",
                         category="Videoteca de series",
                         thumbnail=config.get_thumb("thumb_videolibrary_tvshow.png")))

    return itemlist


def channel_config(item):
    return platformtools.show_channel_settings(channelpath=os.path.join(config.get_runtime_path(), "channels",
                                                                        item.channel),
                                               caption="configuración -- Videoteca")


def list_movies(item):
    logger.info()
    itemlist = []

    for f in glob.glob(filetools.join(videolibrarytools.MOVIES_PATH, u'/*/*.nfo')):
        nfo_path = f
        head_nfo, new_item = videolibrarytools.read_nfo(nfo_path)

        new_item.nfo = nfo_path
        new_item.path = filetools.dirname(f)
        new_item.thumbnail = new_item.contentThumbnail
        new_item.text_color = "blue"

        if not filetools.exists(filetools.join(videolibrarytools.MOVIES_PATH, new_item.strm_path)):
            # Si se ha eliminado el strm desde la bilbioteca de kodi, no mostrarlo
            continue

        # Menu contextual: Marcar como visto/no visto
        visto = new_item.library_playcounts.get(os.path.splitext(f)[0], 0)
        new_item.infoLabels["playcount"] = visto
        if visto > 0:
            texto_visto = "Marcar película como no vista"
            contador = 0
        else:
            texto_visto = "Marcar película como vista"
            contador = 1

        # Menu contextual: Eliminar serie/canal
        num_canales = len(new_item.library_urls)
        if "downloads" in new_item.library_urls:
            num_canales -= 1
        if num_canales > 1:
            texto_eliminar = "Eliminar película/canal"
            multicanal = True
        else:
            texto_eliminar = "Eliminar esta película"
            multicanal = False

        new_item.context = [{"title": texto_visto,
                             "action": "mark_content_as_watched",
                             "channel": "videolibrary",
                             "playcount": contador},
                            {"title": texto_eliminar,
                             "action": "delete",
                             "channel": "videolibrary",
                             "multicanal": multicanal}]
        # ,{"title": "Cambiar contenido (PENDIENTE)",
        # "action": "",
        # "channel": "videolibrary"}]
        # logger.debug("new_item: " + new_item.tostring('\n'))
        itemlist.append(new_item)

    return sorted(itemlist, key=lambda it: it.title.lower())


def list_tvshows(item):
    logger.info()
    itemlist = []

    # Obtenemos todos los tvshow.nfo de la videoteca de SERIES recursivamente
    for f in glob.glob(filetools.join(videolibrarytools.TVSHOWS_PATH, u'/*/tvshow.nfo')):
        # logger.debug("file es %s" % f)

        head_nfo, item_tvshow = videolibrarytools.read_nfo(f)
        item_tvshow.title = item_tvshow.contentTitle
        item_tvshow.path = filetools.join(videolibrarytools.TVSHOWS_PATH, item_tvshow.path)
        item_tvshow.nfo = f

        # Menu contextual: Marcar como visto/no visto
        visto = item_tvshow.library_playcounts.get(item_tvshow.contentTitle, 0)
        item_tvshow.infoLabels["playcount"] = visto
        if visto > 0:
            texto_visto = "Marcar serie como no vista"
            contador = 0
        else:
            texto_visto = "Marcar serie como vista"
            contador = 1

        # Menu contextual: Buscar automáticamente nuevos episodios o no
        if item_tvshow.active and int(item_tvshow.active) > 0:
            texto_update = "Buscar automáticamente nuevos episodios: Desactivar"
            value = 0
            item_tvshow.text_color = "green"
        else:
            texto_update = "Buscar automáticamente nuevos episodios: Activar"
            value = 1
            item_tvshow.text_color = "0xFFDF7401"

        # Menu contextual: Eliminar serie/canal
        num_canales = len(item_tvshow.library_urls)
        if "downloads" in item_tvshow.library_urls:
            num_canales -= 1
        if num_canales > 1:
            texto_eliminar = "Eliminar serie/canal"
            multicanal = True
        else:
            texto_eliminar = "Eliminar esta serie"
            multicanal = False

        item_tvshow.context = [{"title": texto_visto,
                                "action": "mark_content_as_watched",
                                "channel": "videolibrary",
                                "playcount": contador},
                               {"title": texto_update,
                                "action": "mark_tvshow_as_updatable",
                                "channel": "videolibrary",
                                "active": value},
                               {"title": texto_eliminar,
                                "action": "delete",
                                "channel": "videolibrary",
                                "multicanal": multicanal},
                               {"title": "Buscar nuevos episodios ahora",
                                "action": "update_tvshow",
                                "channel": "videolibrary"}]
        # ,{"title": "Cambiar contenido (PENDIENTE)",
        # "action": "",
        # "channel": "videolibrary"}]

        # logger.debug("item_tvshow:\n" + item_tvshow.tostring('\n'))
        itemlist.append(item_tvshow)

    if itemlist:
        itemlist = sorted(itemlist, key=lambda it: it.title.lower())

        itemlist.append(Item(channel=item.channel, action="update_videolibrary", thumbnail=item.thumbnail,
                             title="Buscar nuevos episodios y actualizar videoteca", folder=False))

    return itemlist


def get_seasons(item):
    logger.info()
    # logger.debug("item:\n" + item.tostring('\n'))
    itemlist = []
    dict_temp = {}

    # Menu contextual: Releer tvshow.nfo
    head_nfo, item_nfo = videolibrarytools.read_nfo(item.nfo)

    # Miramos las temporadas que estén marcadas como vistas
    if not hasattr(item_nfo, 'library_playcounts'):
        item_nfo.library_playcounts = {}

    if config.get_setting("no_pile_on_seasons", "videolibrary") == 2:  # Siempre
        return get_episodes(item)

    for f in glob.glob1(item.path, u'*.json'):
        season = f.split('x')[0]
        dict_temp[season] = "Temporada %s" % season

    if config.get_setting("no_pile_on_seasons", "videolibrary") == 1 and len(dict_temp) == 1:  # Sólo si hay una temporada
        return get_episodes(item)
    else:

        # TODO mostrar los episodios de la unica temporada "no vista", en vez de mostrar el Item "temporada X" previo
        # si está marcado "ocultar los vistos" en el skin, se ejecutaria esto
        #     se comprueba cada temporada en dict_temp si está visto.
        #          si hay una sola temporada y no_pile_on_seasons == 1, se devuelve get(episodios)
        #          si está todo visto, hacemos como actualmente <-- el else no se hace nada.. CREO
        # if config.get_setting("no_pile_on_seasons", "videolibrary") == 1 and len(dict_temp_Visible) == 1:  # Sólo si hay una temporada

        # Creamos un item por cada temporada
        for season, title in dict_temp.items():
            new_item = item.clone(action="get_episodes", title=title, contentSeason=season,
                                  filtrar_season=True)

            # Menu contextual: Marcar la temporada como vista o no
            visto = item_nfo.library_playcounts.get("season %s" % season, 0)
            new_item.infoLabels["playcount"] = visto
            if visto > 0:
                texto = "Marcar temporada como no vista"
                value = 0
            else:
                texto = "Marcar temporada como vista"
                value = 1
            new_item.context = [{"title": texto,
                                 "action": "mark_season_as_watched",
                                 "channel": "videolibrary",
                                 "playcount": value}]

            # logger.debug("new_item:\n" + new_item.tostring('\n'))
            itemlist.append(new_item)

        if len(itemlist) > 1:
            itemlist = sorted(itemlist, key=lambda it: int(it.contentSeason))

        if config.get_setting("show_all_seasons", "videolibrary"):
            new_item = item.clone(action="get_episodes", title="*Todas las temporadas")
            new_item.infoLabels["playcount"] = 0
            itemlist.insert(0, new_item)

    return itemlist


def get_episodes(item):
    logger.info()
    # logger.debug("item:\n" + item.tostring('\n'))
    itemlist = []

    # Menu contextual: Releer tvshow.nfo
    head_nfo, item_nfo = videolibrarytools.read_nfo(item.nfo)

    # Crear un item en la lista para cada strm encontrado
    for f in glob.glob1(item.path, u'*.strm'):
        season_episode = scrapertools.get_season_and_episode(f)
        if not season_episode:
            # El fichero no incluye el numero de temporada y episodio
            continue
        season, episode = season_episode.split("x")
        # Si hay q filtrar por temporada, ignoramos los capitulos de otras temporadas
        if item.filtrar_season and int(season) != int(item.contentSeason):
            continue

        # Obtener los datos del season_episode.nfo
        nfo_path = filetools.join(item.path, f).replace('.strm', '.nfo')
        head_nfo, epi = videolibrarytools.read_nfo(nfo_path)

        # Fijar el titulo del capitulo si es posible
        if epi.contentTitle:
            title_episodie = epi.contentTitle.strip()
        else:
            title_episodie = "Temporada %s Episodio %s" % \
                             (epi.contentSeason, str(epi.contentEpisodeNumber).zfill(2))

        epi.contentTitle = "%sx%s" % (epi.contentSeason, str(epi.contentEpisodeNumber).zfill(2))
        epi.title = "%sx%s - %s" % (epi.contentSeason, str(epi.contentEpisodeNumber).zfill(2), title_episodie)

        if item_nfo.library_filter_show:
            epi.library_filter_show = item_nfo.library_filter_show

        # Menu contextual: Marcar episodio como visto o no
        visto = item_nfo.library_playcounts.get(season_episode, 0)
        epi.infoLabels["playcount"] = visto
        if visto > 0:
            texto = "Marcar episodio como no visto"
            value = 0
        else:
            texto = "Marcar episodio como visto"
            value = 1
        epi.context = [{"title": texto,
                        "action": "mark_content_as_watched",
                        "channel": "videolibrary",
                        "playcount": value,
                        "nfo": item.nfo}]

        # logger.debug("epi:\n" + epi.tostring('\n'))
        itemlist.append(epi)

    return sorted(itemlist, key=lambda it: (int(it.contentSeason), int(it.contentEpisodeNumber)))


def findvideos(item):
    logger.info()
    # logger.debug("item:\n" + item.tostring('\n'))

    itemlist = []
    list_canales = {}
    item_local = None

    if not item.contentTitle or not item.strm_path:
        logger.debug("No se pueden buscar videos por falta de parametros")
        return []

    content_title = filter(lambda c: c not in ":*?<>|\/", item.contentTitle.strip().lower())

    if item.contentType == 'movie':
        item.strm_path = filetools.join(videolibrarytools.MOVIES_PATH, item.strm_path)
        path_dir = os.path.dirname(item.strm_path)
        item.nfo = filetools.join(path_dir, os.path.basename(path_dir) + ".nfo")
    else:
        item.strm_path = filetools.join(videolibrarytools.TVSHOWS_PATH, item.strm_path)
        path_dir = os.path.dirname(item.strm_path)
        item.nfo = filetools.join(path_dir, 'tvshow.nfo')

    for fd in filetools.listdir(path_dir):
        if fd.endswith('.json'):
            contenido, nom_canal = fd[:-6].split('[')
            if (contenido.startswith(content_title) or item.contentType == 'movie') and nom_canal not in \
                    list_canales.keys():
                list_canales[nom_canal] = filetools.join(path_dir, fd)

    num_canales = len(list_canales)
    # logger.debug(str(list_canales))
    if 'downloads' in list_canales:
        json_path = list_canales['downloads']
        item_json = Item().fromjson(filetools.read(json_path))
        item_json.contentChannel = "local"
        # Soporte para rutas relativas en descargas
        if filetools.is_relative(item_json.url):
            item_json.url = filetools.join(videolibrarytools.LIBRARY_PATH, item_json.url)

        del list_canales['downloads']

        # Comprobar q el video no haya sido borrado
        if filetools.exists(item_json.url):
            item_local = item_json.clone(action='play')
            itemlist.append(item_local)
        else:
            num_canales -= 1

    filtro_canal = ''
    if num_canales > 1 and config.get_setting("ask_channel", "videolibrary"):
        opciones = ["Mostrar solo los enlaces de %s" % k.capitalize() for k in list_canales.keys()]
        opciones.insert(0, "Mostrar todos los enlaces")
        if item_local:
            opciones.append(item_local.title)

        from platformcode import platformtools
        index = platformtools.dialog_select(config.get_localized_string(30163), opciones)
        if index < 0:
            return []

        elif item_local and index == len(opciones) - 1:
            filtro_canal = 'downloads'
            platformtools.play_video(item_local)

        elif index > 0:
            filtro_canal = opciones[index].replace("Mostrar solo los enlaces de ", "")
            itemlist = []

    for nom_canal, json_path in list_canales.items():
        if filtro_canal and filtro_canal != nom_canal.capitalize():
            continue

        # Importamos el canal de la parte seleccionada
        try:
            channel = __import__('channels.%s' % nom_canal, fromlist=["channels.%s" % nom_canal])
        except ImportError:
            exec "import channels." + nom_canal + " as channel"

        item_json = Item().fromjson(filetools.read(json_path))
        list_servers = []

        try:
            # FILTERTOOLS
            # si el canal tiene filtro se le pasa el nombre que tiene guardado para que filtre correctamente.
            if "list_language" in item_json:
                # si se viene desde la videoteca del addon
                if "library_filter_show" in item:
                    item_json.show = item.library_filter_show.get(nom_canal, "")

            # Ejecutamos find_videos, del canal o común
            if hasattr(channel, 'findvideos'):
                from core import servertools
                list_servers = getattr(channel, 'findvideos')(item_json)
                list_servers = servertools.filter_servers(list_servers)
            else:
                from core import servertools
                list_servers = servertools.find_video_items(item_json)
        except Exception, ex:
            logger.error("Ha fallado la funcion findvideos para el canal %s" % nom_canal)
            template = "An exception of type %s occured. Arguments:\n%r"
            message = template % (type(ex).__name__, ex.args)
            logger.error(message)

        # Cambiarle el titulo a los servers añadiendoles el nombre del canal delante y
        # las infoLabels y las imagenes del item si el server no tiene
        for server in list_servers:
            if not server.action:  # Ignorar las etiquetas
                continue

            server.contentChannel = server.channel
            server.channel = "videolibrary"
            server.nfo = item.nfo
            server.strm_path = item.strm_path

            # Se añade el nombre del canal si se desea
            if config.get_setting("quit_channel_name", "videolibrary") == 0:
                server.title = "%s: %s" % (nom_canal.capitalize(), server.title)

            server.infoLabels = item_json.infoLabels

            if not server.thumbnail:
                server.thumbnail = item.thumbnail

            # logger.debug("server:\n%s" % server.tostring('\n'))
            itemlist.append(server)

    # return sorted(itemlist, key=lambda it: it.title.lower())
    return itemlist


def play(item):
    logger.info()
    # logger.debug("item:\n" + item.tostring('\n'))

    if not item.contentChannel == "local":
        channel = __import__('channels.%s' % item.contentChannel, fromlist=["channels.%s" % item.contentChannel])
        if hasattr(channel, "play"):
            itemlist = getattr(channel, "play")(item)

        else:
            itemlist = [item.clone()]
    else:
        itemlist = [item.clone(url=item.url, server="local")]

    # Para enlaces directo en formato lista
    if isinstance(itemlist[0], list):
        item.video_urls = itemlist
        itemlist = [item]

    # Esto es necesario por si el play del canal elimina los datos
    for v in itemlist:
        if isinstance(v, Item):
            v.nfo = item.nfo
            v.strm_path = item.strm_path
            v.infoLabels = item.infoLabels
            if item.contentTitle:
                v.title = item.contentTitle
            else:
                if item.contentType == "episode":
                    v.title = "Episodio %s" % item.contentEpisodeNumber
            v.thumbnail = item.thumbnail
            v.contentThumbnail = item.thumbnail

    return itemlist


def update_videolibrary(item):
    logger.info()

    # Actualizar las series activas sobreescribiendo
    import videolibrary_service
    videolibrary_service.check_for_update(overwrite=True)

    # Eliminar las carpetas de peliculas que no contengan archivo strm
    for raiz, subcarpetas, ficheros in filetools.walk(videolibrarytools.MOVIES_PATH):
        strm = False
        for f in ficheros:
            if f.endswith(".strm"):
                strm = True
                break

        if ficheros and not strm:
            logger.debug("Borrando carpeta de pelicula eliminada: %s" % raiz)
            filetools.rmdirtree(raiz)


# metodos de menu contextual
def update_tvshow(item):
    logger.info()
    # logger.debug("item:\n" + item.tostring('\n'))

    heading = 'Actualizando serie....'
    p_dialog = platformtools.dialog_progress_bg('alfa', heading)
    p_dialog.update(0, heading, item.contentSerieName)

    import videolibrary_service
    if videolibrary_service.update(item.path, p_dialog, 1, 1, item, False) and config.is_xbmc():
        from platformcode import xbmc_videolibrary
        xbmc_videolibrary.update(folder=filetools.basename(item.path))

    p_dialog.close()


def mark_content_as_watched(item):
    logger.info()
    # logger.debug("item:\n" + item.tostring('\n'))

    if filetools.exists(item.nfo):
        head_nfo, it = videolibrarytools.read_nfo(item.nfo)

        if item.contentType == 'movie':
            name_file = os.path.splitext(os.path.basename(item.nfo))[0]
        elif item.contentType == 'episode':
            name_file = "%sx%s" % (item.contentSeason, str(item.contentEpisodeNumber).zfill(2))
        else:
            name_file = item.contentTitle

        if not hasattr(it, 'library_playcounts'):
            it.library_playcounts = {}
        it.library_playcounts.update({name_file: item.playcount})

        # se comprueba que si todos los episodios de una temporada están marcados, se marque tb la temporada
        if item.contentType != 'movie':
            it = check_season_playcount(it, item.contentSeason)

        # Guardamos los cambios en item.nfo
        if filetools.write(item.nfo, head_nfo + it.tojson()):
            item.infoLabels['playcount'] = item.playcount

            if item.contentType == 'tvshow':
                # Actualizar toda la serie
                new_item = item.clone(contentSeason=-1)
                mark_season_as_watched(new_item)

            if config.is_xbmc() and item.contentType == 'episode':
                from platformcode import xbmc_videolibrary
                xbmc_videolibrary.mark_content_as_watched_on_kodi(item, item.playcount)

            platformtools.itemlist_refresh()


def mark_season_as_watched(item):
    logger.info()
    # logger.debug("item:\n" + item.tostring('\n'))

    # Obtener el diccionario de episodios marcados
    tvshow_path = filetools.join(item.path, 'tvshow.nfo')
    head_nfo, it = videolibrarytools.read_nfo(tvshow_path)
    if not hasattr(it, 'library_playcounts'):
        it.library_playcounts = {}

    # Marcamos cada uno de los episodios encontrados de esta temporada
    episodios_marcados = 0
    for f in glob.glob1(item.path, u'*.strm'):
        # if f.endswith(".strm"):
        season_episode = scrapertools.get_season_and_episode(f)
        if not season_episode:
            # El fichero no incluye el numero de temporada y episodio
            continue
        season, episode = season_episode.split("x")

        if int(item.contentSeason) == -1 or int(season) == int(item.contentSeason):
            name_file = os.path.splitext(os.path.basename(f))[0]
            it.library_playcounts[name_file] = item.playcount
            episodios_marcados += 1

    if episodios_marcados:
        if int(item.contentSeason) == -1:
            # Añadimos todas las temporadas al diccionario item.library_playcounts
            for k in it.library_playcounts.keys():
                if k.startswith("season"):
                    it.library_playcounts[k] = item.playcount
        else:
            # Añadimos la temporada al diccionario item.library_playcounts
            it.library_playcounts["season %s" % item.contentSeason] = item.playcount

            # se comprueba que si todas las temporadas están vistas, se marque la serie como vista
            it = check_tvshow_playcount(it, item.contentSeason)

        # Guardamos los cambios en tvshow.nfo
        filetools.write(tvshow_path, head_nfo + it.tojson())
        item.infoLabels['playcount'] = item.playcount

        if config.is_xbmc():
            # Actualizamos la BBDD de Kodi
            from platformcode import xbmc_videolibrary
            xbmc_videolibrary.mark_season_as_watched_on_kodi(item, item.playcount)

    platformtools.itemlist_refresh()


def mark_tvshow_as_updatable(item):
    logger.info()
    head_nfo, it = videolibrarytools.read_nfo(item.nfo)
    it.active = item.active
    filetools.write(item.nfo, head_nfo + it.tojson())

    platformtools.itemlist_refresh()


def delete(item):
    def delete_all(_item):
        filetools.rmdirtree(_item.path)

        if config.is_xbmc():
            import xbmc
            # esperamos 3 segundos para dar tiempo a borrar los ficheros
            xbmc.sleep(3000)
            # TODO mirar por qué no funciona al limpiar en la videoteca de Kodi al añadirle un path
            # limpiamos la videoteca de Kodi
            from platformcode import xbmc_videolibrary
            xbmc_videolibrary.clean()

        logger.info("Eliminados todos los enlaces")
        platformtools.itemlist_refresh()

    # logger.info(item.contentTitle)
    # logger.debug(item.tostring('\n'))

    if item.contentType == 'movie':
        heading = "Eliminar película"
    else:
        heading = "Eliminar serie"

    if item.multicanal:
        # Obtener listado de canales
        opciones = ["Eliminar solo los enlaces de %s" % k.capitalize() for k in item.library_urls.keys() if
                    k != "downloads"]
        opciones.insert(0, heading)

        index = platformtools.dialog_select(config.get_localized_string(30163), opciones)

        if index == 0:
            # Seleccionado Eliminar pelicula/serie
            delete_all(item)

        elif index > 0:
            # Seleccionado Eliminar canal X
            canal = opciones[index].replace("Eliminar solo los enlaces de ", "").lower()

            num_enlaces = 0
            for fd in filetools.listdir(item.path):
                if fd.endswith(canal + '].json'):
                    if filetools.remove(filetools.join(item.path, fd)):
                        num_enlaces += 1

            if num_enlaces > 0:
                # Actualizar .nfo
                head_nfo, item_nfo = videolibrarytools.read_nfo(item.nfo)
                del item_nfo.library_urls[canal]
                filetools.write(item.nfo, head_nfo + item_nfo.tojson())

            msg_txt = "Eliminados %s enlaces del canal %s" % (num_enlaces, canal)
            logger.info(msg_txt)
            platformtools.dialog_notification(heading, msg_txt)
            platformtools.itemlist_refresh()

    else:
        if platformtools.dialog_yesno(heading,
                                      "¿Realmente desea eliminar '%s' de su videoteca?" % item.infoLabels['title']):
            delete_all(item)


def check_season_playcount(item, season):
    logger.info()

    if season:
        episodios_temporada = 0
        episodios_vistos_temporada = 0
        for key, value in item.library_playcounts.iteritems():
            if key.startswith("%sx" % season):
                episodios_temporada += 1
                if value > 0:
                    episodios_vistos_temporada += 1

        if episodios_temporada == episodios_vistos_temporada:
            # se comprueba que si todas las temporadas están vistas, se marque la serie como vista
            item.library_playcounts.update({"season %s" % season: 1})
        else:
            # se comprueba que si todas las temporadas están vistas, se marque la serie como vista
            item.library_playcounts.update({"season %s" % season: 0})

    return check_tvshow_playcount(item, season)


def check_tvshow_playcount(item, season):
    logger.info()
    if season:
        temporadas_serie = 0
        temporadas_vistas_serie = 0
        for key, value in item.library_playcounts.iteritems():
            if key == ("season %s" % season):
                temporadas_serie += 1
                if value > 0:
                    temporadas_vistas_serie += 1

        if temporadas_serie == temporadas_vistas_serie:
            item.library_playcounts.update({item.title: 1})
        else:
            item.library_playcounts.update({item.title: 0})

    else:
        playcount = item.library_playcounts.get(item.title, 0)
        item.library_playcounts.update({item.title: playcount})

    return item