# -*- coding: utf-8 -*-
import re
from core import filetools, jsontools, trakt_tools
from core.tmdb import Tmdb
from core.scrapertools import htmlclean, decodeHtmlentities
from core.support import thumb, typo, match, Item
from platformcode import config, platformtools
from platformcode import logger

info_language = ["de", "en", "es", "fr", "it", "pt"] # from videolibrary.json
def_lang = info_language[config.get_setting("info_language", "videolibrary")]

langs = ['auto', 'de', 'fr', 'pt', 'it', 'es-MX', 'ca', 'en', 'es']
langt = langs[config.get_setting('tmdb', "tvmoviedb")]
if langt == 'auto': langt = def_lang
langt_alt = langs[config.get_setting('tmdb_alternativo', "tvmoviedb")]
# langs = ['auto', 'co', 'cl', 'ar', 'mx', 'en', 'es']
# langf = langs[config.get_setting('filmaff', "tvmoviedb")]
# if langf == 'auto': langf = 'en'
langs = ['auto', 'de-de', 'fr-fr', 'pt-pt', 'it-it', 'es-MX', 'ca-es', 'en', 'es']
langi = langs[config.get_setting('imdb', "tvmoviedb")]
if langi == 'auto': langi = def_lang

adult_mal = config.get_setting('adult_mal', "tvmoviedb")
mal_ck = "MzE1MDQ2cGQ5N2llYTY4Z2xwbGVzZjFzbTY="
images_predef = "https://raw.githubusercontent.com/master-1970/resources/master/images/genres/"
default_fan = filetools.join(config.get_runtime_path(), "fanart.jpg")


def mainlist(item):
    logger.debug()
    itemlist = [
            # TMDB
            # item.clone(title=typo(config.get_localized_string(70021), 'bold'), action=""),
            item.clone(title=config.get_localized_string(70021) % (config.get_localized_string(30122), 'TMDB'), action="tmdb", args="movie", thumbnail=thumb('search_movie')),
            item.clone(title=config.get_localized_string(70021) % (config.get_localized_string(30123), 'TMDB'), action="tmdb", args="tv", thumbnail=thumb('search_tvshow')),
            # Filmaffinity
            # itemlist.append(item.clone(title=typo(config.get_localized_string(70024), 'bold'), action=""))
            # itemlist.append(item.clone(title=config.get_localized_string(70022), action="filmaf", args="movie", thumbnail=thumb('search_movie')))
            # itemlist.append(item.clone(title=config.get_localized_string(70023), action="filmaf", args="tv", thumbnail=thumb('search_tvshow')))
            # IMDB
            # item.clone(title=typo(config.get_localized_string(70025), 'bold'), action=""),
            item.clone(title=config.get_localized_string(70021) % (config.get_localized_string(30122), 'IMDB'), action="imdb", args="movie", url='&title_type=feature,tv_movie', thumbnail=thumb('search_movie')),
            item.clone(title=config.get_localized_string(70021) % (config.get_localized_string(30123), 'IMDB'), action="imdb", args="tv", url='&title_type=tv_series,tv_special,mini_series', thumbnail=thumb('search_tvshow')),
            item.clone(title=config.get_localized_string(70415), action="trakt", thumbnail="http://i.imgur.com/5sQjjuk.png"),
            item.clone(title=config.get_localized_string(70026), action="mal", thumbnail="http://i.imgur.com/RhsYWmd.png"),
            item.clone(title=typo(config.get_localized_string(70027), 'color kod'), action="configuracion", folder=False)
        ]
    return itemlist


def configuracion(item):
    ret = platformtools.show_channel_settings()
    platformtools.itemlist_refresh()
    return ret

def search_star(item):
    logger.debug()

    itemlist = []
    item.type='movie'
    itemlist.extend(search_(item))
    item.type='tvshow'
    itemlist.extend(search_(item))
    return itemlist

def search_(item):
    text = platformtools.dialog_input(heading=item.title)
    if text:
        if "imdb" in item.url:
            item.url = item.url.format(text.replace(" ", "+"))
            item.action = "list_imdb"
            return list_imdb(item)
        # if "filmaffinity" in item.url:
        #     item.url += text.replace(" ", "+")
        #     item.action = "list_fa"
        #     return list_fa(item)
        if "myanimelist" in item.url:
            item.url += text.replace(" ", "%20")
            item.url += "&type=0&score=0&status=0&p=0&r=0&sm=0&sd=0&sy=0&em=0&ed=0&ey=0&c[0]=a&c[1]=b&c[2]=c&c[3]=d&c[4]=f&gx=0"
            item.action = "searching_mal"
            return searching_mal(item)

        item.search['query'] = text
        item.action = "list_tmdb"

        if item.star == True:
            types = ['movie','tv']
            itemlist = []
            for type in types:
                item.contentType = type
                item.search['type']=type
                itemlist.extend(list_tmdb(item))
            return itemlist
        else:
            return list_tmdb(item)


def searcing(item):
    logger.debug()

    new_item = Item(title=item.contentTitle, text=item.contentTitle.replace("+", " "), mode=item.contentType, infoLabels=item.infoLabels)

    from specials import search
    return search.channel_search(new_item)


def tmdb(item):
    item.contentType = item.args.replace("tv", "tvshow")

    itemlist = []

    itemlist.append(item.clone(title=config.get_localized_string(70028), action="list_tmdb", search={'url': item.args + "/popular", 'language': langt, 'page': 1}))
    itemlist.append(item.clone(title=config.get_localized_string(70029), action="list_tmdb", search={'url': item.args + "/top_rated", 'language': langt, 'page': 1}))

    if item.args == "movie": itemlist.append(item.clone(title=config.get_localized_string(70030), action="list_tmdb", search={'url': item.args + "/now_playing", 'language': langt, 'page': 1}))
    else: itemlist.append(item.clone(title=config.get_localized_string(70031), action="list_tmdb", search={'url': item.args + "/on_the_air", 'language': langt, 'page': 1}))

    itemlist.append(item.clone(title=config.get_localized_string(70032), action="indices_tmdb"))
    itemlist.append(item.clone(title=config.get_localized_string(70042), action="indices_tmdb"))

    if item.args == "movie":
        itemlist.append(item.clone(title=config.get_localized_string(70033), action="list_tmdb", search={'url': 'person/popular', 'language': langt, 'page': 1}))
        itemlist.append(item.clone(title=config.get_localized_string(70034), action="list_tmdb", search={'url': item.args + "/upcoming", 'language': langt, 'page': 1}))

    if config.get_platform() != "plex":
        title = item.contentType.replace("movie", config.get_localized_string(70283)).replace("tvshow", "serie")
        itemlist.append(item.clone(title=config.get_localized_string(70035) % title, action="search_", search={'url': 'search/%s' % item.args, 'language': langt, 'page': 1}))

        itemlist.append(item.clone(title=config.get_localized_string(70036), action="search_", search={'url': 'search/person', 'language': langt, 'page': 1}))
        if item.args == "movie": itemlist.append(item.clone(title=config.get_localized_string(70037), action="search_", search={'url': "search/person", 'language': langt, 'page': 1}, crew=True))

    itemlist.append(item.clone(title=typo(config.get_localized_string(70038),'color kod'), action="filter", ))
    itemlist.append(item.clone(title=typo(config.get_localized_string(70039),'color kod'), action="filter", ))

    return thumb(itemlist)


def imdb(item):
    item.contentType = item.args.replace("tv", "tvshow")

    itemlist = []
    itemlist.append(item.clone(title=config.get_localized_string(70028), action="list_imdb"))
    itemlist.append(item.clone(title=config.get_localized_string(70029), action="list_imdb", url=item.url + "&num_votes=25000,&sort=user_rating,desc"))
    if item.args == "movie":
        itemlist.append(item.clone(title=config.get_localized_string(70030), action="list_imdb", url="http://www.imdb.com/showtimes/location?ref_=inth_ov_sh_sm"))
    itemlist.append(item.clone(title=config.get_localized_string(70032), action="indices_imdb"))
    itemlist.append(item.clone(title=config.get_localized_string(70042), action="indices_imdb"))

    if item.args == "movie":
        itemlist.append(item.clone(title=config.get_localized_string(70033), action="list_imdb", url="http://www.imdb.com/search/name?gender=male,female&ref_=nv_cel_m_3"))
        itemlist.append(item.clone(title=config.get_localized_string(70034), action="list_imdb", url="http://www.imdb.com/movies-coming-soon/?ref_=shlc_cs"))

    if config.get_platform() != "plex":
        itemlist.append(item.clone(title=config.get_localized_string(30980), action="search_", url="http://www.imdb.com/search/title?title={}" + item.url))
        itemlist.append(item.clone(title=config.get_localized_string(70036), action="search_", url="http://www.imdb.com/search/name?name={}"))

    itemlist.append(item.clone(title=typo(config.get_localized_string(70038),'color kod'), action="filter_imdb", ))

    return thumb(itemlist)


# def filmaf(item):
#     item.contentType = item.args.replace("tv", "tvshow")
#     login, message = login_fa()
#     if def_lang == 'it': langf = 'us'

#     itemlist = []
#     if item.args == "movie":
#         itemlist.append(item.clone(title=config.get_localized_string(70040), action="list_fa", args="top", url="http://m.filmaffinity.com/%s/topgen.php?genre=&country=&fromyear=&toyear=&notvse=1&nodoc=1" % langf))
#         itemlist.append(item.clone(title=config.get_localized_string(70030), action="list_fa", url="http://m.filmaffinity.com/%s/rdcat.php?id=new_th_%s" % (langf, langf)))
#         itemlist.append(item.clone(title=config.get_localized_string(70032), action="indices_fa", url="http://m.filmaffinity.com/%s/topgen.php" % langf))
#     else:
#         itemlist.append(item.clone(title=config.get_localized_string(70040), action="list_fa", args="top", url="http://m.filmaffinity.com/%s/topgen.php?genre=TV_SE&country=&fromyear=&toyear=&nodoc" % langf))
#         itemlist.append(item.clone(title="Series de actualidad", action="list_fa", url="http://m.filmaffinity.com/%s/category.php?id=current_tv" % langf))

#     itemlist.append(item.clone(title=config.get_localized_string(70042), action="indices_fa"))

#     if item.args == "movie":
#         itemlist.append(item.clone(title=config.get_localized_string(70043), action="list_fa", args="estrenos", url="http://m.filmaffinity.com/%s/rdcat.php?id=upc_th_%s" % (langf, langf)))
#         itemlist.append(item.clone(title=config.get_localized_string(70044), action="indices_fa", args="sagas", url="http://www.filmaffinity.com/%s/movie-groups-all.php" % langf))

#     itemlist.append(item.clone(title=config.get_localized_string(70045), action="indices_fa", url='http://m.filmaffinity.com/%s/topics.php' % langf, ))

#     if config.get_platform() != "plex":
#         itemlist.append(item.clone(title=config.get_localized_string(70046), action="search_", url="http://m.filmaffinity.com/%s/search.php?stype=title&stext=" % langf))
#         itemlist.append(item.clone(title=config.get_localized_string(70036), action="search_", url="http://m.filmaffinity.com/%s/search.php?stype=cast&stext=" % langf))
#         itemlist.append(item.clone(title=config.get_localized_string(70047), action="search_", url="http://m.filmaffinity.com/%s/search.php?stype=director&stext=" % langf))

#     itemlist.append(item.clone(title=config.get_localized_string(70038), action="filter_fa", args="top"))
#     itemlist.append(item.clone(title=config.get_localized_string(70048), action="cuenta_fa", ))

#     return thumb(itemlist)


def trakt(item):
    itemlist = []
    token_auth = config.get_setting("token_trakt", "trakt")
    page = "?page=1&limit=20&extended=full"
    if not item.args:
        item.args = "movie"
        # itemlist.append(item.clone(title=typo(config.get_localized_string(70416), 'bold'), action=""))
        itemlist.append(item.clone(title=typo(config.get_localized_string(30122), 'bold') + typo(config.get_localized_string(70049),'[] _'), action="acciones_trakt", url="movies/popular%s" % page))
        itemlist.append(item.clone(title=typo(config.get_localized_string(30122), 'bold') + typo(config.get_localized_string(70050),'[] _'), action="acciones_trakt", url="movies/trending%s" % page))
        itemlist.append(item.clone(title=typo(config.get_localized_string(30122), 'bold') + typo(config.get_localized_string(70053),'[] _'), action="acciones_trakt", url="movies/watched/all%s" % page))
        itemlist.append(item.clone(title=typo(config.get_localized_string(30122), 'bold') + typo(config.get_localized_string(70051),'[] _'), action="acciones_trakt", url="movies/anticipated%s" % page))
        if token_auth: itemlist.append(item.clone(title=typo(config.get_localized_string(30122), 'bold') + typo(config.get_localized_string(70052),'[] _'), action="acciones_trakt",url="recommendations/movies?limit=100&extended=full", pagina=0))
        # itemlist.append(item.clone(title=typo(config.get_localized_string(70417), 'bold'), action="",))
        item.args = "show"
        itemlist.append(item.clone(title=typo(config.get_localized_string(30123), 'bold') + typo(config.get_localized_string(70049),'[] _'), action="acciones_trakt", url="shows/popular%s" % page))
        itemlist.append(item.clone(title=typo(config.get_localized_string(30123), 'bold') + typo(config.get_localized_string(70050),'[] _'), action="acciones_trakt", url="shows/trending%s" % page))
        itemlist.append(item.clone(title=typo(config.get_localized_string(30123), 'bold') + typo(config.get_localized_string(70053),'[] _'), action="acciones_trakt", url="shows/watched/all%s" % page))
        itemlist.append(item.clone(title=typo(config.get_localized_string(30123), 'bold') + typo(config.get_localized_string(70051),'[] _'), action="acciones_trakt", url="shows/anticipated%s" % page))
        if token_auth: itemlist.append(item.clone(title=typo(config.get_localized_string(30123), 'bold') + typo(config.get_localized_string(70052),'[] _'), action="acciones_trakt", url="recommendations/shows?limit=100&extended=full", pagina=0))
        itemlist.append(item.clone(title=typo(config.get_localized_string(70048), 'color kod'), args="cuenta"))
    else:
        item.args = "movie"
        # A saved token is checked and the authentication process is executed
        if not token_auth:
            folder = (config.get_platform() == "plex")
            itemlist.append(item.clone(title=config.get_localized_string(70054), action="auth_trakt", folder=folder))
        else:

            itemlist.append(item.clone(title=typo(config.get_localized_string(30122),'bold') + typo(config.get_localized_string(70055),'_ []'), action="acciones_trakt", url="users/me/watchlist/movies%s" % page, order="added", how="desc"))
            itemlist.append(item.clone(title=typo(config.get_localized_string(30122),'bold') + typo(config.get_localized_string(70056),'_ []'), action="acciones_trakt", url="users/me/watched/movies%s" % page, order="added", how="desc"))
            itemlist.append(item.clone(title=typo(config.get_localized_string(30122),'bold') + typo(config.get_localized_string(70068),'_ []'), action="acciones_trakt", url="users/me/collection/movies%s" % page, order="added", how="desc"))

            itemlist.append(item.clone(title=typo(config.get_localized_string(30123),'bold') + typo(config.get_localized_string(70055),'_ []'), action="acciones_trakt", url="users/me/watchlist/shows%s" % page, args="show", order="added", how="desc"))
            itemlist.append(item.clone(title=typo(config.get_localized_string(30123),'bold') + typo(config.get_localized_string(70056),'_ []'), action="acciones_trakt", url="users/me/watched/shows%s" % page, args="show", order="added", how="desc"))
            itemlist.append(item.clone(title=typo(config.get_localized_string(30123),'bold') + typo(config.get_localized_string(70068),'_ []'), action="acciones_trakt", url="users/me/collection/shows%s" % page, args="show", order="added", how="desc"))

            itemlist.append(item.clone(title=typo(config.get_localized_string(70057),'color kod bold'), action="acciones_trakt", url="users/me/lists", ))

    return itemlist


def mal(item):
    itemlist = []
    login, message, user = login_mal()
    if login:
        item.login = True

    itemlist.append(item.clone(title=config.get_localized_string(70058), url="https://myanimelist.net/topanime.php?type=tv&limit=0", action="top_mal", contentType="tvshow", args="tv"))
    itemlist.append(item.clone(title=config.get_localized_string(70059), url="https://myanimelist.net/topanime.php?type=movie&limit=0", action="top_mal", contentType="movie", args="movie"))
    itemlist.append(item.clone(title=config.get_localized_string(70061), url="https://myanimelist.net/topanime.php?type=ova&limit=0", action="top_mal", contentType="tvshow", args="tv", tipo="ova"))
    itemlist.append(item.clone(title=config.get_localized_string(70028), url="https://myanimelist.net/topanime.php?type=bypopularity&limit=0", action="top_mal"))
    itemlist.append(item.clone(title=config.get_localized_string(70060), url="https://myanimelist.net/topanime.php?type=upcoming&limit=0", action="top_mal"))
    itemlist.append(item.clone(title=config.get_localized_string(70062), url="", action="indices_mal"))
    itemlist.append(item.clone(title=config.get_localized_string(70063), url="", action="indices_mal"))
    if config.get_platform() != "plex":
        itemlist.append(item.clone(title=config.get_localized_string(70064), url="https://myanimelist.net/anime.php?q=", action="search_"))
    itemlist.append(item.clone(title=typo(config.get_localized_string(70038), 'color kod'), action="filter_mal"))

    itemlist.append(item.clone(title=typo(config.get_localized_string(70057), 'color kod'), action="cuenta_mal"))

    return itemlist


##-------------------- SECTION TMDB ------------------------##
def list_tmdb(item):
    # Main listings of the Tmdb category (Most popular, Most viewed, etc ...)
    itemlist = []
    item.fanart = default_fan
    if not item.pagina:
        item.pagina = 1

    # List of actors
    if 'nm' in item.infoLabels['imdb_id']:
        try:
            ob_tmdb = Tmdb(discover=item.search, tipo=item.args, idioma_busqueda=langt)
            id_cast = ob_tmdb.result["person_results"][0]["id"]
            if item.contentType == "movie": item.search = {'url': 'discover/movie', 'with_cast': id_cast, 'page': item.pagina, 'sort_by': 'primary_release_date.desc', 'language': langt}
            else:item.search = {'url': 'person/%s/tv_credits' % id_cast, 'language': langt}
            ob_tmdb = Tmdb(discover=item.search, tipo=item.args, idioma_busqueda=langt)
        except:
            pass
    else:
        ob_tmdb = Tmdb(discover=item.search, tipo=item.args, idioma_busqueda=langt)

    # Sagas and collections
    if "collection" in item.search["url"]:
        try:
            for parte in ob_tmdb.result["parts"]:
                new_item = item.clone(action="details")
                new_item.infoLabels = ob_tmdb.get_infoLabels(new_item.infoLabels, origen=parte)
                if new_item.infoLabels['thumbnail']: new_item.thumbnail = new_item.infoLabels['thumbnail']
                if new_item.infoLabels['fanart']: new_item.fanart = new_item.infoLabels['fanart']

                if new_item.infoLabels['year']: new_item.title = typo(new_item.contentTitle, 'bold') + ' (%s)' % new_item.infoLabels['year'] + typo(str(new_item.infoLabels['rating']).replace("0.0", ""), '_ color kod')
                else: new_item.title = typo(new_item.contentTitle, 'bold') + ' (%s)' % new_item.infoLabels['year'] + typo(str(new_item.infoLabels['rating']).replace("0.0", ""), '_ color kod')
                itemlist.append(new_item)
            itemlist.sort(key=lambda item: item.infoLabels["year"])
        except:
            pass
    else:
        try:
            orden = False
            # If you do a search for actors or directors, those results are argscted
            if "cast" in ob_tmdb.result and not item.crew:
                ob_tmdb.results = ob_tmdb.result["cast"]
                orden = True
            elif "crew" in ob_tmdb.result and item.crew:
                ob_tmdb.results = ob_tmdb.result["crew"]
                orden = True
            for i in range(0, len(ob_tmdb.results)):
                new_item = item.clone(action="details", url='', infoLabels={'mediatype': item.contentType})
                new_item.infoLabels = ob_tmdb.get_infoLabels(new_item.infoLabels, origen=ob_tmdb.results[i])
                # If there is no synopsis in the chosen language, search in the alternative
                if not new_item.infoLabels["plot"] and not 'person' in item.search["url"]:
                    ob_tmdb2 = Tmdb(id_Tmdb=new_item.infoLabels["tmdb_id"], tipo=item.args, idioma_busqueda=langt_alt)
                    new_item.infoLabels["plot"] = ob_tmdb2.get_sinopsis()
                if new_item.infoLabels['thumbnail']:
                    new_item.thumbnail = new_item.infoLabels['thumbnail']
                elif new_item.infoLabels['profile_path']:
                    new_item.thumbnail = 'https://image.tmdb.org/t/p/original' + new_item.infoLabels['profile_path']
                    new_item.infoLabels['profile_path'] = ''
                    new_item.plot = new_item.infoLabels["biography"]
                    if not item.search.get('with_cast', '') and not item.search.get('with_crew', ''):
                        if item.contentType == "movie":
                            new_item.action = "list_tmdb"
                            cast = 'with_cast'
                            if item.crew:
                                cast = 'with_crew'
                            new_item.search = {'url': 'discover/movie', cast: new_item.infoLabels['tmdb_id'], 'sort_by': 'primary_release_date.desc', 'language': langt, 'page': item.pagina}
                        else:
                            new_item.action = "list_tmdb"
                            new_item.search = {'url': 'person/%s/tv_credits' % new_item.infoLabels['tmdb_id'], 'language': langt}

                elif not new_item.infoLabels['thumbnail'] and not new_item.infoLabels['profile_path']:
                    new_item.thumbnail = ''

                if new_item.infoLabels['fanart']: new_item.fanart = new_item.infoLabels['fanart']

                if not 'person' in item.search["url"] or 'tv_credits' in item.search["url"]:
                    new_item.title = typo(new_item.contentTitle,'bold')
                    if new_item.infoLabels['year']: new_item.title += typo(new_item.infoLabels['year'],'_ () bold')
                    if new_item.infoLabels['rating'] != '0.0': new_item.title += typo(new_item.infoLabels['rating'],'_ [] color kod bold')
                else:
                    # If it is a search for people, a film for which it is known is included in the title and fanart
                    known_for = ob_tmdb.results[i].get("known_for")
                    # type=item.type
                    if known_for:
                        from random import randint
                        random = randint(0, len(known_for) - 1)
                        new_item.title = typo(new_item.contentTitle, 'bold') + typo(known_for[random].get("title", known_for[random].get("name")), '_ () color kod')

                        if known_for[random]["backdrop_path"]:
                            new_item.fanart = 'https://image.tmdb.org/t/p/original' + known_for[random]["backdrop_path"]
                    else:
                        new_item.title = new_item.contentTitle
                itemlist.append(new_item)
        except:
            import traceback
            logger.error(traceback.format_exc())

        if orden:
            itemlist.sort(key=lambda item: item.infoLabels["year"], reverse=True)
        if "page" in item.search and ob_tmdb.total_pages > item.search["page"]:
            item.search["page"] += 1
            itemlist.append(item.clone(title=typo(config.get_localized_string(30992), 'color kod bold'), pagina=item.pagina + 1, thumbnail=thumb()))

    return itemlist


def details(item):
    itemlist = []
    images = {}
    data = ""
    # If it comes from imdb section
    if not item.infoLabels["tmdb_id"]:
        headers = [['Accept-Language', langi]]
        data = match("http://www.imdb.com/title/" + item.infoLabels['imdb_id'], headers=headers).data

        # Imdb images
        pics = match(data, patron=r'showAllVidsAndPics.*?href=".*?(tt\d+)').match
        if pics: images["imdb"] = {'url': 'http://www.imdb.com/_json/title/%s/mediaviewer' % pics}

        ob_tmdb = Tmdb(external_id=item.infoLabels["imdb_id"], external_source="imdb_id", tipo=item.args, idioma_busqueda=langt)
        item.infoLabels["tmdb_id"] = ob_tmdb.get_id()

    ob_tmdb = Tmdb(id_Tmdb=item.infoLabels["tmdb_id"], tipo=item.args, idioma_busqueda=langt)

    try:
        item.infoLabels = ob_tmdb.get_infoLabels(item.infoLabels)
        # If there is no synopsis in the chosen language, search in the alternative
        if not item.infoLabels["plot"]: item.infoLabels["plot"] = ob_tmdb.get_sinopsis(idioma_alternativo=langt_alt)
    except:
        pass
    if not item.fanart and item.infoLabels['fanart']:
        item.fanart = item.infoLabels['fanart']
    if item.infoLabels['thumbnail']:
        item.thumbnail = item.infoLabels['thumbnail']

    # Synopsis, votes from imdb
    if data:
        plot = match(data, patron='class="inline canwrap" itemprop="description">(.*?)</div>').match
        plot = re.sub(r'(?i)<em[^>]+>|\n|\s{2}', ' ', htmlclean(plot)).strip()
        if plot and (item.infoLabels['plot'] and item.infoLabels['plot'] != plot): item.infoLabels['plot'] += " (TMDB)\n" + plot + " (IMDB)"
        elif plot and not item.infoLabels['plot']: item.infoLabels['plot'] = plot

        rating = match(data, patron=r'itemprop="ratingValue">([^<]+)<').match
        if rating: item.infoLabels['rating'] = float(rating.replace(",", "."))

        votos = match(data, patron=r'itemprop="ratingCount">([^<]+)<').match
        if votos: item.infoLabels['votes'] = votos

    if item.infoLabels['tagline']: item.plot= typo(item.infoLabels['tagline'],'bold') + '\n' + item.plot

    title = item.contentType.replace("movie", config.get_localized_string(70283)).replace("tvshow", "serie")
    # from core.support import dbg;dbg()
    if not item.contentTitle: item.contentTitle = item.title.split('(')[0].strip()
    # Search by titles chosen language and / or original version and Spanish
    if config.get_setting('new_search'):
        itemlist.append(item.clone(channel='globalsearch', action="Search", title=config.get_localized_string(70069) % (title, item.contentTitle), search_text=item.contentTitle, text=item.contentTitle, mode='search', type=item.contentType, folder=False))
        if item.infoLabels['originaltitle'] and item.contentTitle != item.infoLabels['originaltitle']:
            itemlist.append(item.clone(channel='globalsearch', action="Search", search_text=item.infoLabels['originaltitle'], title=config.get_localized_string(70070) % item.infoLabels['originaltitle'], mode='search', type=item.contentType, folder=False))
    else:
        itemlist.append(item.clone(channel='search', action="new_search", title=config.get_localized_string(70069) % (title, item.contentTitle), search_text=item.contentTitle, text=item.contentTitle, mode=item.contentType))
        if item.infoLabels['originaltitle'] and item.contentTitle != item.infoLabels['originaltitle']:
            itemlist.append(item.clone(channel='search', action="search", search_text=item.infoLabels['originaltitle'], title=config.get_localized_string(70070) % item.infoLabels['originaltitle'], mode=item.contentType))

    # if langt != "es" and langt != "en" and item.infoLabels["tmdb_id"]:
    #     tmdb_lang = Tmdb(id_Tmdb=item.infoLabels["tmdb_id"], tipo=item.args, idioma_busqueda=def_lang)
    #     if tmdb_lang.result.get("title") and tmdb_lang.result["title"] != item.contentTitle and tmdb_lang.result["title"] != item.infoLabels['originaltitle']:
    #         tmdb_lang = tmdb_lang.result["title"]
    #         itemlist.append(item.clone(channel='search', action="search", title=config.get_localized_string(70066) % tmdb_lang, contentTitle=tmdb_lang, mode=item.contentType))

    # In case of series, option of info by seasons
    if item.contentType == "tvshow" and item.infoLabels['tmdb_id'] and "number_of_seasons" in item.infoLabels:
        itemlist.append(item.clone(action="info_seasons", title=config.get_localized_string(70067) % item.infoLabels["number_of_seasons"]))
    # Option to watch the cast and browse their movies / series
    if item.infoLabels['tmdb_id']:
        itemlist.append(item.clone(action="distribution", title=config.get_localized_string(70071), infoLabels={'tmdb_id': item.infoLabels['tmdb_id'], 'mediatype': item.contentType}))

    if config.is_xbmc():
        item.contextual = True
    itemlist.append(item.clone(channel="trailertools", action="buscartrailer", title=config.get_localized_string(60359)))

    try:
        images['tmdb'] = ob_tmdb.result["images"]
        itemlist.append(item.clone(action="imagenes", title=config.get_localized_string(70316), images=images, args="menu"))
    except:
        pass

    try:
        if item.contentType == "movie" and item.infoLabels["year"] < 2014:
            post_url = "https://theost.com/search/custom/?key=%s&year=%s&country=0&genre=0" % (
            item.infoLabels['originaltitle'].replace(" ", "+"), item.infoLabels["year"])
            url = "https://nl.hideproxy.me/includes/process.php?action=update"
            post = "u=%s&proxy_formdata_server=nl&allowCookies=1&encodeURL=1&encodePage=0&stripObjects=0&stripJS=0&go=" % urllib.quote(
                post_url)
            while True:
                response = httptools.downloadpage(url, post=post, follow_redirects=False)
                if response.headers.get("location"):
                    url = response.headers["location"]
                    post = ""
                else:
                    data_music = response.data
                    break

            url_album = scrapertools.find_single_match(data_music, 'album(?:|s) on request.*?href="([^"]+)"')
            if url_album:
                url_album = "https://nl.hideproxy.me" + url_album
                itemlist.append(item.clone(action="musica_movie", title=config.get_localized_string(70317), url=url_album))
    except:
        pass

    token_auth = config.get_setting("token_trakt", "trakt")
    if token_auth:
        itemlist.append(item.clone(title=config.get_localized_string(70318), action="menu_trakt"))

    # itemlist.append(item.clone(title="", action=""))
    # It is part of a collection
    try:
        if ob_tmdb.result.get("belongs_to_collection"):
            new_item = item.clone(search='', infoLabels={'mediatype': item.contentType})
            saga = ob_tmdb.result["belongs_to_collection"]
            new_item.infoLabels["tmdb_id"] = saga["id"]
            if saga["poster_path"]:
                new_item.thumbnail = 'https://image.tmdb.org/t/p/original' + saga["poster_path"]
            if saga["backdrop_path"]:
                new_item.fanart = 'https://image.tmdb.org/t/p/original' + saga["backdrop_path"]
            new_item.search = {'url': 'collection/%s' % saga['id'], 'language': langt}
            itemlist.append(new_item.clone(title=config.get_localized_string(70327) % saga["name"], action="list_tmdb"))
    except:
        pass

    # Similar Movies / Series and Recommendations
    if item.infoLabels['tmdb_id']:
        item.args = item.contentType.replace('tvshow', 'tv')
        title = title.replace("película", config.get_localized_string(70137)).replace("serie", config.get_localized_string(30123))
        itemlist.append(item.clone(title=config.get_localized_string(70328) % title, action="list_tmdb", search={'url': '%s/%s/similar' % (item.args, item.infoLabels['tmdb_id']), 'language': langt, 'page': 1}, infoLabels={'mediatype': item.contentType}))
        itemlist.append(item.clone(title=config.get_localized_string(70315), action="list_tmdb", search={'url': '%s/%s/recommendations' % (item.args, item.infoLabels['tmdb_id']), 'language': langt, 'page': 1}))

    return itemlist


def distribution(item):
    # Actors and film crew for a movie / series
    itemlist = []
    item.args=item.contentType.replace('tvshow','tv')
    item.search = {'url': '%s/%s/credits' % (item.args, item.infoLabels['tmdb_id'])}
    ob_tmdb = Tmdb(discover=item.search, tipo=item.args, idioma_busqueda=langt)

    try:
        cast = ob_tmdb.result["cast"]
        if cast:
            itemlist.append(item.clone(title=config.get_localized_string(70314), action="", ))
            for actor in cast:
                new_item = item.clone(action="list_tmdb", fanart=default_fan)
                new_item.title = "    " + actor["name"] + " as " + actor["character"]
                if actor["profile_path"]:
                    new_item.thumbnail = 'https://image.tmdb.org/t/p/original' + actor["profile_path"]
                if item.contentType == "movie":
                    new_item.search = {'url': 'discover/movie', 'with_cast': actor['id'],
                                       'language': langt, 'page': 1,
                                       'sort_by': 'primary_release_date.desc'}
                else:
                    new_item.search = {'url': 'person/%s/tv_credits' % actor['id'], 'language': langt}
                itemlist.append(new_item)
    except:
        pass

    try:
        crew = ob_tmdb.result["crew"]
        if crew:
            itemlist.append(item.clone(title=config.get_localized_string(70319), action="", ))
            for c in crew:
                new_item = item.clone(action="list_tmdb", fanart=default_fan)
                new_item.title = "    " + c["job"] + ": " + c["name"]
                if c["profile_path"]:
                    new_item.thumbnail = 'https://image.tmdb.org/t/p/original' + c["profile_path"]
                if item.contentType == "movie":
                    new_item.search = {'url': 'discover/movie', 'with_crew': c['id'], 'page': 1,'sort_by': 'primary_release_date.desc'}
                else:
                    new_item.search = {'url': 'person/%s/tv_credits' % c['id'], 'language': langt}
                    new_item.crew = True
                itemlist.append(new_item)
    except:
        pass

    return itemlist


def info_seasons(item):
    # Season and episode info
    itemlist = []
    ob_tmdb = Tmdb(id_Tmdb=item.infoLabels["tmdb_id"], tipo="tv", idioma_busqueda=langt)
    logger.info(item.infoLabels)

    for temp in range(int(item.infoLabels["number_of_seasons"]), 0, -1):
        temporada = ob_tmdb.get_temporada(temp)
        if temporada:
            new_item = item.clone(action="", mediatype="season")
            new_item.infoLabels['title'] = temporada['name']
            new_item.infoLabels['season'] = temp
            if temporada['overview']:
                new_item.infoLabels['plot'] = temporada['overview']
            if temporada['air_date']:
                date = temporada['air_date'].split('-')
                new_item.infoLabels['aired'] = date[2] + "/" + date[1] + "/" + date[0]
                new_item.infoLabels['year'] = date[0]
            if temporada['poster_path']:
                new_item.infoLabels['poster_path'] = 'https://image.tmdb.org/t/p/original' + temporada['poster_path']
                new_item.thumbnail = new_item.infoLabels['poster_path']
            new_item.title = config.get_localized_string(60027) % temp
            itemlist.append(new_item)

            for epi in range(1, len(temporada["episodes"])):
                episodio = ob_tmdb.get_episodio(temp, epi)
                if episodio:
                    new_item = item.clone(action="", mediatype="episode")
                    new_item.infoLabels['season'] = temp
                    new_item.infoLabels['episode'] = epi
                    new_item.infoLabels['title'] = episodio['episodio_titulo']
                    if episodio['episodio_sinopsis']:
                        new_item.infoLabels['plot'] = episodio['episodio_sinopsis']
                    if episodio['episodio_imagen']:
                        new_item.infoLabels['poster_path'] = episodio['episodio_imagen']
                        new_item.thumbnail = new_item.infoLabels['poster_path']
                    if episodio['episodio_air_date']:
                        new_item.infoLabels['aired'] = episodio['episodio_air_date']
                        new_item.infoLabels['year'] = episodio['episodio_air_date'].rsplit("/", 1)[1]
                    if episodio['episodio_vote_average']:
                        new_item.infoLabels['rating'] = episodio['episodio_vote_average']
                        new_item.infoLabels['votes'] = episodio['episodio_vote_count']
                    new_item.title = "      %sx%s - %s" % (temp, epi, new_item.infoLabels['title'])
                    itemlist.append(new_item)

    return itemlist


def indices_tmdb(item):
    # Indices by gender and year
    itemlist = []
    from datetime import datetime
    if config.get_localized_string(70032) in item.title:
        thumbnail = {}
        url = ('http://api.themoviedb.org/3/genre/%s/list?api_key=a1ab8b8669da03637a4b98fa39c39228&language=%s' % (item.args, langt))
        genres_list = {}
        try:
            for l in jsontools.load(match(url, cookies=False).data)["genres"]:
                genres_list[str(l["id"])] = l["name"]
                if "es" in langt: thumbnail[str(l["id"])] = "%s1/%s.jpg" % (images_predef, l["name"].lower().replace("ó", "o").replace("í", "i").replace(" ", "%20").replace("Aventuras", "Aventura").replace("ú", "u"))
                else: thumbnail[str(l["id"])] = "%s2/%s.jpg" % (images_predef, l["name"])
        except:
            pass

        fecha = datetime.now().strftime('%Y-%m-%d')
        sort_by = 'release_date.desc'
        param_year = 'release_date.lte'
        if item.contentType == 'tvshow':
            sort_by = 'first_air_date.desc'
            param_year = 'air_date.lte'
        for key, value in genres_list.items():
            search = {'url': 'discover/%s' % item.args, 'with_genres': key, 'sort_by': sort_by, param_year: fecha,'language': langt, 'page': 1}
            new_item = item.clone(title=value, thumbnail=thumbnail[key], action="list_tmdb", search=search)
            itemlist.append(new_item)

        itemlist.sort(key=lambda item: item.title)
        thumb(itemlist)
    else:
        year = datetime.now().year + 3
        for i in range(year, 1899, -1):
            if item.contentType == 'tvshow':
                param_year = 'first_air_date_year'
            else:
                param_year = 'primary_release_year'
            search = {'url': 'discover/%s' % item.args, param_year: i, 'language': langt, 'page': 1}
            itemlist.append(item.clone(title=str(i), action='list_tmdb', search=search))

    return itemlist


def filter(item):
    logger.debug()

    from datetime import datetime
    list_controls = []
    valores = {}

    dict_values = None

    list_controls.append({'id': 'years', 'label': config.get_localized_string(60232), 'enabled': True, 'type': 'list', 'default': -1, 'visible': True})
    list_controls[0]['lvalues'] = []
    valores['years'] = []
    year = datetime.now().year + 1
    for i in range(1900, year + 1):
        list_controls[0]['lvalues'].append(str(i))
        valores['years'].append(str(i))
    list_controls[0]['lvalues'].append(config.get_localized_string(70450))
    valores['years'].append('')

    if config.get_localized_string(70038) in item.title:
        # Se utilizan los valores por defecto/guardados
        saved_values = config.get_setting("default_filter_" + item.args, item.channel)
        if saved_values:
            dict_values = saved_values
        url = ('http://api.themoviedb.org/3/genre/%s/list?api_key=f7f51775877e0bb6703520952b3c7840&language=%s' % (item.args, langt))
        try:
            lista = jsontools.load(httptools.downloadpage(url, cookies=False).data)["genres"]
            if lista:
                list_controls.append({'id': 'labelgenre', 'enabled': True, 'type': 'label', 'default': None, 'label': config.get_localized_string(70451), 'visible': True})
                for l in lista:
                    list_controls.append({'id': 'genre' + str(l["id"]), 'label': l["name"], 'enabled': True, 'type': 'bool', 'default': False, 'visible': True})
        except:
            pass

        list_controls.append({'id': 'orden', 'label': config.get_localized_string(70455), 'enabled': True, 'type': 'list', 'default': -1, 'visible': True})
        orden = [config.get_localized_string(70456), config.get_localized_string(70457), config.get_localized_string(70458), config.get_localized_string(70459), config.get_localized_string(70460), config.get_localized_string(70461)]
        if item.args == "movie":
            orden.extend([config.get_localized_string(70462), config.get_localized_string(70463)])
        orden_tmdb = ['popularity.desc', 'popularity.asc', 'release_date.desc', 'release_date.asc', 'vote_average.desc', 'vote_average.asc', 'original_title.asc', 'original_title.desc']
        valores['orden'] = []
        list_controls[-1]['lvalues'] = []
        for i, tipo_orden in enumerate(orden):
            list_controls[-1]['lvalues'].insert(0, tipo_orden)
            valores['orden'].insert(0, orden_tmdb[i])

        list_controls.append({'id': 'espacio', 'label': '', 'enabled': False, 'type': 'label', 'default': None, 'visible': True})
        list_controls.append({'id': 'save', 'label': config.get_localized_string(70464), 'enabled': True, 'type': 'bool', 'default': False, 'visible': True})
    else:
        list_controls.append({'id': 'keyword', 'label': config.get_localized_string(70465), 'enabled': True, 'type': 'text', 'default': '', 'visible': True})

    item.valores = valores
    return platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values, caption=config.get_localized_string(70320), item=item, callback='filtered')


def filtered(item, values):
    values_copy = values.copy()
    # Save the filter to be the one loaded by default
    if "save" in values and values["save"]:
        values_copy.pop("save")
        config.set_setting("default_filter_" + item.args, values_copy, item.channel)

    year = item.valores["years"][values["years"]]
    if config.get_localized_string(70038) in item.title:
        orden = item.valores["orden"][values["orden"]]
        if item.args == "tv": orden = orden.replace('release_date', 'first_air_date')

        genre_ids = []
        for v in values:
            if "genre" in v:
                if values[v]: genre_ids.append(v.replace('genre', ''))
        genre_ids = ",".join(genre_ids)

    if config.get_localized_string(70465).lower() in item.title.lower(): item.search = {'url': 'search/%s' % item.args, 'year': year, 'query': values["keyword"], 'language': langt, 'page': 1}
    elif item.args == "movie": item.search = {'url': 'discover/%s' % item.args, 'sort_by': orden, 'primary_release_year': year, 'with_genres': genre_ids, 'vote_count.gte': '10', 'language': langt, 'page': 1}
    else: item.search = {'url': 'discover/%s' % item.args, 'sort_by': orden, 'first_air_date_year': year, 'with_genres': genre_ids, 'vote_count.gte': '10', 'language': langt, 'page': 1}

    item.action = "list_tmdb"
    return list_tmdb(item)


def musica_movie(item):
    logger.debug()
    itemlist = []
    data = match(item).data
    matches = match(data, patron=r'<td class="left">([^<]+)<br><small>([^<]+)</small>.*?<td>(\d+:\d+).*?<p id="([^"]+)"').matches
    for title, artist, duration, id_p in matches:
        title = typo(title, 'bold') + typo(artist, '_ () bold') + typo(duration, '_ [] color kod bold')
        url = match(data, patron=r"AudioPlayer.embed\('%s'.*?soundFile: '([^']+)'" % id_p).match
        itemlist.append(Item(channel=item.channel, action="play", server="directo", url=url, title=title, thumbnail=item.thumbnail, fanart=item.fanart, ))
    return itemlist


##-------------------- SECTION IMDB ------------------------##
def list_imdb(item):
    # Main method for imdb sections
    itemlist = []

    headers = [['Accept-Language', langi]]
    if "www.imdb.com" in item.url:
        # data = httptools.downloadpage(item.url, headers=headers, replace_headers=True).data
        data = match(item.url, headers=headers).data
    else:
        url = 'http://www.imdb.com/search/title?' + item.url
        # data = httptools.downloadpage(url, headers=headers, replace_headers=True).data
        data = match(url, headers=headers).data
    logger.debug(data)

    # data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
    # data = re.sub(r"\s{2}", " ", data)

    # List of actors
    if 'search/name' in item.url:
        patron = r'src="([^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+><a href="/name/(nm\d+)[^>]+>\s*([^<]+)[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s([^<]+)[^>]+>[^>]+>[^>]+>\s*([^<]+)<'
        matches = match(data, patron=patron).matches
        for thumbnail, imdb_id, title, movie, info in matches:
            new_item = item.clone(action='list_tmdb')
            try:
                if "@" in thumbnail:
                    thumbnail = thumbnail.rsplit('@', 1)[0]
                    thumbnail += "@._UX482.jpg"
                elif "._V1_" in thumbnail:
                    thumbnail = thumbnail.rsplit('._V1_', 1)[0]
                    thumbnail += "._V1_UX482.jpg"
            except:
                pass
            new_item.thumbnail = thumbnail

            info = info.strip()
            if info: new_item.infoLabels['plot'] = htmlclean(info)
            new_item.title = typo(title.strip(), 'bold') + typo(movie.strip(),'_ () color kod bold')
            new_item.infoLabels['imdb_id'] = imdb_id
            new_item.search = {'url': 'find/%s' % imdb_id, 'external_source': 'imdb_id', 'language': langt}
            itemlist.append(new_item)
    else:
        patron = r'(?:<div class="image">|<div class="lister-item-image).*?(?:loadlate="([^"]+)"|src="([^"]+)").*?href=".*?/(tt\d+)[^>]+>([^<]+)</a>(.*?)(?:"text-muted|"outline)[^>]+>\s*([^<]+)<'
        matches = match(data, patron=patron).matches
        for thumbnail, thumb2, imdb_id, title, info, plot in matches:

            new_item = item.clone(action='details')
            new_item.title = typo(title.strip(),'bold')
            if not thumbnail: thumbnail = thumb2
            try:
                if "@" in thumbnail:
                    thumbnail = thumbnail.rsplit('@', 1)[0]
                    thumbnail += "@._UX482.jpg"
                elif "._V1_" in thumbnail:
                    thumbnail = thumbnail.rsplit('._V1_', 1)[0]
                    thumbnail += "._V1_UX482.jpg"
            except:
                pass
            new_item.thumbnail = thumbnail

            new_item.infoLabels['plot'] = htmlclean(plot.strip())

            genres = match(info, patron=r'genre">([^<]+)<').matches
            if genres: new_item.infoLabels["genre"] = ", ".join(genres)
            duration = match(info, patron=r'(\d+) min').match
            if duration: new_item.infoLabels['duration'] = int(duration) * 60

            new_item.infoLabels['year'] = match(new_item.title, patron=r'\((\d{4})').match
            if not new_item.infoLabels['year']:
                new_item.infoLabels['year'] = match(info, patron=r'year.*?\((\d{4})').match
                if new_item.infoLabels['year']: new_item.title += typo(new_item.infoLabels['year'], '_ () bold')

            rating = match(info, patron=r'(?:rating|Metascore).*?<strong>([^<]*)</strong>').match.replace(",", ".")
            if rating:
                if not "." in rating:
                    try: rating = float(rating) / 10
                    except: rating = None
                if rating:
                    new_item.title += typo(str(rating), '_ [] color kod')
                    new_item.infoLabels['rating'] = float(rating)
            new_item.infoLabels['imdb_id'] = imdb_id
            itemlist.append(new_item)

    match_data = match(data, patron=r'<option selected="selected"[^>]+>\s*([A-Za-z]+)[^\d]+(\d+)\s*</option').match
    if match_data:
        itemlist.insert(0, Item(title=typo('%s %s' % match_data, '_ bold color kod'), thumbnail=thumb('year')))

    next_page = match(data, patron=r'<a href="([^"]+)"[^>]*>Next').match
    if next_page:
        next_page = 'http://www.imdb.com' + next_page
        itemlist.append(item.clone(title=typo(config.get_localized_string(30992), 'color kod bold'), url=next_page, thumbnail=thumb()))

    return itemlist


def filter_imdb(item):
    logger.debug()

    from datetime import datetime
    list_controls = []
    valores = {}

    dict_values = None
    # Default / saved values ​​are used
    saved_values = config.get_setting("default_filter_imdb_" + item.args, item.channel)
    if saved_values: dict_values = saved_values

    list_controls = [{'id': 'title', 'label': config.get_localized_string(70505), 'enabled': True, 'type': 'text', 'default': '', 'visible': True},
                     {'id': 'yearsdesde', 'label': config.get_localized_string(70452), 'enabled': True, 'type': 'list', 'default': -1, 'visible': True},
                     {'id': 'yearshasta', 'label': config.get_localized_string(70453), 'enabled': True, 'type': 'list', 'default': -1, 'visible': True}]

    list_controls[1]['lvalues'] = []
    list_controls[2]['lvalues'] = []
    valores['years'] = []
    year = datetime.now().year + 1

    for i in range(1900, year + 1):
        list_controls[1]['lvalues'].append(str(i))
        list_controls[2]['lvalues'].append(str(i))
        valores['years'].append(str(i))
    list_controls[1]['lvalues'].append(config.get_localized_string(70450))
    list_controls[2]['lvalues'].append(config.get_localized_string(70450))
    valores['years'].append('')

    try:
        genres_translate = {'Action': config.get_localized_string(70394), 'Adventure': config.get_localized_string(60267), 'Animation': config.get_localized_string(60268), 'Biography': config.get_localized_string(70403),
                            'Comedy': config.get_localized_string(60270), 'Crime': config.get_localized_string(60271), 'Documentary': config.get_localized_string(70396), 'Family': config.get_localized_string(70399),
                            'Fantasy': config.get_localized_string(60274), 'Film-Noir': config.get_localized_string(70400), 'Game-Show': config.get_localized_string(70401),
                            'History': config.get_localized_string(70405), 'Horror': config.get_localized_string(70013), 'Music': config.get_localized_string(70404), 'Mistery': config.get_localized_string(70402),
                            'News': config.get_localized_string(60279), 'Reality-TV': config.get_localized_string(70406), 'Sci-Fi': config.get_localized_string(70397), 'Sport': config.get_localized_string(70395),
                            'Talk-Show': config.get_localized_string(70398), 'War': config.get_localized_string(70407)}

        data = match("http://www.imdb.com/search/title", cookies=False).data
        # bloque = scrapertools.find_single_match(data, '<h3>Genres</h3>(.*?)</table>')
        matches = match(data, patronBlock=r'<h3>Genres</h3>(.*?)</table>', patron=r' value="([^"]+)"\s*>\s*<label.*?>([^<]+)<').matches
        if matches:
            list_controls.append({'id': 'espacio', 'label': '', 'enabled': False, 'type': 'label', 'default': None, 'visible': True})
            list_controls.append({'id': 'labelgenre', 'enabled': True, 'type': 'label', 'visible': True, 'label': config.get_localized_string(70451),})
            lista = []
            for value, title in matches:
                logger.debug('TITOLO:',title, genres_translate.get(title, title))
                title = genres_translate.get(title, title)
                lista.append([value, title])
            lista.sort(key=lambda lista: lista[1])
            for value, title in lista:
                list_controls.append({'id': 'genre' + value, 'label': title, 'enabled': True, 'type': 'bool', 'default': False, 'visible': True})
    except:
        pass

    list_controls.append({'id': 'espacio', 'label': '', 'enabled': False, 'type': 'label', 'default': None, 'visible': True})
    try:
        # bloque = scrapertools.find_single_match(data, '<h3>Countries</h3>(.*?)Less-Common')
        matches = scrapertools.find_multiple_matches(data, paronBlock=r'<h3>Countries</h3>(.*?)Less-Common', patron=r' value="([^"]+)"\s*>([^<]+)<').matches
        if matches:
            list_controls.append({'id': 'pais', 'label': config.get_localized_string(70466), 'enabled': True, 'type': 'list', 'default': -1, 'visible': True})
            list_controls[-1]['lvalues'] = []
            list_controls[-1]['lvalues'].append(config.get_localized_string(70450))
            valores['pais'] = []
            valores['pais'].append('')
            for valor, titulo in matches:
                list_controls[-1]['lvalues'].insert(0, titulo)
                valores['pais'].insert(0, valor)

    except:
        pass

    list_controls.append({'id': 'orden', 'label': config.get_localized_string(70455), 'enabled': True, 'type': 'list', 'default': -1, 'visible': True})
    orden = [config.get_localized_string(70456), config.get_localized_string(70457), config.get_localized_string(70458), config.get_localized_string(70459), config.get_localized_string(70460), config.get_localized_string(70461),
             config.get_localized_string(70462), config.get_localized_string(70463)]

    orden_imdb = ['moviemeter,asc', 'moviemeter,desc', 'year,desc', 'year,asc', 'user_rating,desc', 'user_rating,asc', 'alpha,asc', 'alpha,desc']
    valores['orden'] = []
    list_controls[-1]['lvalues'] = []
    for i, tipo_orden in enumerate(orden):
        list_controls[-1]['lvalues'].insert(0, tipo_orden)
        valores['orden'].insert(0, orden_imdb[i])

    list_controls.append({'id': 'save', 'label': config.get_localized_string(70464), 'enabled': True, 'type': 'bool', 'default': False, 'visible': True})

    item.valores = valores
    return platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values, caption=config.get_localized_string(70320), item=item, callback='filtered_imdb')


def filtered_imdb(item, values):
    values_copy = values.copy()
    # Save the filter to be the one loaded by default
    if "save" in values and values["save"]:
        values_copy.pop("save")
        config.set_setting("default_filter_imdb_" + item.args, values_copy, item.channel)

    yeard = item.valores["years"][values["yearsdesde"]]
    yearh = item.valores["years"][values["yearshasta"]]
    orden = item.valores["orden"][values["orden"]]
    # pais = item.valores["pais"][values["pais"]]

    genre_ids = []
    for v in values:
        if "genre" in v:
            if values[v]:
                genre_ids.append(v.replace('genre', ''))
    genre_ids = ",".join(genre_ids)
    try:
        votos = int(values["votos"])
    except:
        votos = ""

    item.url = 'http://www.imdb.com/search/title?num_votes=%s,&genres=%s&release_date=%s,%s&sort=%s&title=%s&title_type=' % (str(votos), genre_ids, yeard, yearh, orden, values["title"])
    if item.contentType == "movie": item.url += "feature,tv_movie"
    else: item.url += "tv_series,tv_special,mini_series"

    item.action = "list_imdb"
    return list_imdb(item)


def indices_imdb(item):
    # Imdb indices by year and gender
    itemlist = []
    from datetime import datetime
    if config.get_localized_string(70032) in item.title:
        genres_translate = {'Action': config.get_localized_string(70394), 'Adventure': config.get_localized_string(60267), 'Animation': config.get_localized_string(60268), 'Biography': config.get_localized_string(70403), 'Thriller': config.get_localized_string(70410),
                            'Comedy': config.get_localized_string(60270), 'Crime': config.get_localized_string(60271), 'Documentary': config.get_localized_string(70396), 'Family': config.get_localized_string(70399), 'Romance': config.get_localized_string(70409),
                            'Fantasy': config.get_localized_string(60274), 'Film-Noir': config.get_localized_string(70400), 'Game-Show': config.get_localized_string(70401), 'Drama': config.get_localized_string(70412), 'Western': config.get_localized_string(70411),
                            'History': config.get_localized_string(70405), 'Horror': config.get_localized_string(70013), 'Music': config.get_localized_string(70404), 'Musical': config.get_localized_string(70408),'Mystery': config.get_localized_string(70402),
                            'News': config.get_localized_string(60279), 'Reality-TV': config.get_localized_string(70406), 'Sci-Fi': config.get_localized_string(70397), 'Sport': config.get_localized_string(70395),
                            'Talk-Show': config.get_localized_string(70398), 'War': config.get_localized_string(70407)}
        data = match("http://www.imdb.com/search/title", cookies=False).data
        # bloque = scrapertools.find_single_match(data, '<h3>Genres</h3>(.*?)</table>')
        matches = match(data, patronBlock=r'<h3>Genres</h3>(.*?)</table>', patron=r' value="([^"]+)"\s*>\s*<label.*?>([^<]+)<').matches
        if matches:
            for value, title in matches:
                title = genres_translate.get(title, title)
                thumbnail = "%s2/%s.jpg" % (images_predef, title)
                itemlist.append(item.clone(title=title, action='list_imdb', thumbnail=thumbnail, url='http://www.imdb.com/search/title?genres=%s%s' % (value, item.url)))
                itemlist = thumb(itemlist)
            itemlist.sort(key=lambda item: item.title)
    else:
        year = datetime.now().year + 3
        for i in range(year, 1899, -1):
            itemlist.append(item.clone(title=str(i), action='list_imdb', url='http://www.imdb.com/search/title?release_date=%s,%s%s' % (i, i, item.url)))

    return itemlist


##-------------------- FILMAFFINITY SECTION ------------------------##
# def list_fa(item):
#     # Filmaffinity main listing method
#     itemlist = []

#     # Listings with pagination per post
#     if item.args == "top":
#         if item.page_fa:
#             post = "from=%s" % item.page_fa
#             data = httptools.downloadpage(item.url, post=post).data
#             if item.total > item.page_fa:
#                 item.page_fa += 30
#             else:
#                 item.page_fa = ""
#         else:
#             item.page_fa = 30
#             data = httptools.downloadpage(item.url).data
#             item.total = int(scrapertools.find_single_match(data, 'tmResCount\s*=\s*(\d+)'))
#             if item.total <= item.page_fa:
#                 item.page_fa = ""

#     else:
#         data = httptools.downloadpage(item.url).data
#     data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
#     data = re.sub(r"\s{2}", " ", data)

#     votaciones = []
#     # If it is the premiere section, change the structure of the scraper

#     if item.args == "estrenos":
#         patron = r'fa-calendar-alt">[^>]+>([^<]+)<(.*?)(?:id="main-wrapper-rdcat|class="np-cat-wrapper")'
#         bloks = scrapertools.find_multiple_matches(data, patron)
#         for title, block in bloks:
#             itemlist.append(item.clone(title=title, action='', ))

#             patron = r'href="([^"]+)" title="([^"]+)"><img.*?src="([^"]+)[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*(\d+)[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>([^<]+)[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>\s*(\d+)[^>]+>[^>]+>[^>]+>[^>]+>([^<]+)[^>]+>[^>]+>([^<]+)'
#             matches = match(block, patron=patron).matches
#             # matches = scrapertools.find_multiple_matches(bloque, patron)
#             for url, title, thumb, duration, rating, year, genre, plot in matches:
#                 title = title.strip()
#                 new_item = item.clone(action="details_fa", contentType="movie", args="movie", contentTitle=title)
#                 if not url.startswith("http://m.filmaffinity"): new_item.url = "http://m.filmaffinity.com" + url
#                 else: new_item.url = url

#                 new_item.thumbnail = thumb.replace("msmall", "large")
#                 if not new_item.thumbnail.startswith("http"): new_item.thumbnail = "http://m.filmaffinity.com" + new_item.thumbnail

#                 new_item.title = typo(title,'bold') + typo(rating,'_ [] color kod bold')
#                 new_item.infoLabels['duration'] = int(duration) * 60
#                 new_item.infoLabels['rating'] = float(rating.replace(",", "."))
#                 new_item.infoLabels['year'] = year
#                 new_item.infoLabels['genres'] = [genre]
#                 itemlist.append(new_item)
#     else:
#         patron = '(?:<a class="list-group-item[^"]*" href="([^"]+)">|<a href="([^"]+)" class="list-group-item[^"]*">)' \
#                  '.*?(?:data-src="([^"]+)"|src="((?!/images/empty.gif)[^"]+)").*?' \
#                  '<div class="mc-title.*?>([^<]+)<small>\((\d+)\)</small>.*?(?:<div class="avgrat-box in-block ">' \
#                  '([^<]+)</div>\s*<small class="ratcount-box">(.*?)\s*<|</li>)'
#         matches = scrapertools.find_multiple_matches(data, patron)
#         for url, url2, thumb, thumb2, title, year, rating, votos in matches:
#             title = title.strip()
#             new_item = item.clone(action="details_fa", args="movie")
#             if not url:
#                 url = url2
#             if not url.startswith("http://m.filmaffinity"):
#                 new_item.url = "http://m.filmaffinity.com" + url
#             else:
#                 new_item.url = url

#             if not thumb:
#                 thumb = thumb2
#             new_item.thumbnail = thumb.replace("msmall", "large")
#             if not new_item.thumbnail.startswith("http"):
#                 new_item.thumbnail = "http://m.filmaffinity.com" + new_item.thumbnail

#             new_item.title = title.replace("(Serie de TV)", "").replace("(TV)", "") + "  (%s) %s" \
#                                                                                       % (year, rating)
#             new_item.contentTitle = re.sub(r'(?i)\(serie de tv\)|\(tv\)|\(c\)', '', title)
#             if re.search(r'(?i)serie de tv|\(tv\)', title):
#                 new_item.contentType = "tvshow"
#                 new_item.args = "tv"
#                 new_item.infoLabels["tvshowtitle"] = new_item.contentTitle

#             new_item.infoLabels['year'] = year
#             votaciones.append([rating, votos])
#             if rating:
#                 new_item.infoLabels['rating'] = float(rating.replace(",", "."))
#                 new_item.infoLabels['votes'] = votos
#             itemlist.append(new_item)

#     if len(itemlist) < 31:
#         from core import tmdb
#         tmdb.set_infoLabels_itemlist(itemlist, True)
#         for i, it in enumerate(itemlist):
#             try:
#                 it.infoLabels['votes'] = votaciones[i][1]
#                 it.infoLabels['rating'] = float(votaciones[i][0].replace(",", "."))
#             except:
#                 pass

#     next_page = scrapertools.find_single_match(data, 'aria-label="Next" href="([^"]+)"')
#     if next_page:
#         if not next_page.startswith("http://m.filmaffinity"):
#             next_page = "http://m.filmaffinity.com" + next_page

#         itemlist.append(Item(channel=item.channel, action=item.action, title=config.get_localized_string(70065), url=next_page,
#                              args=item.args))
#     elif item.page_fa:
#         itemlist.append(item.clone(title=config.get_localized_string(70065), ))
#     return itemlist


# def indices_fa(item):
#     # Indexes by gender, year, themes and sagas / collections
#     itemlist = []
#     # dbg()
#     if item.url:
#         data = match(item).data
#         # data = httptools.downloadpage(item.url).data
#         # data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
#         # data = re.sub(r"\s{2}", " ", data)
#     if "sagas" in item.args:
#         matches = match(data, patron=r'<li class="fa-shadow"><a href="([^"]+)">[^>]+>([^<]+)<.*?src="([^"]+)".*?"count-movies">([^<]+)<').matches
#         # patron = '<li class="fa-shadow">.*?href="([^"]+)".*?group-name">([^<]+)<.*?src="([^"]+)".*?"count-movies">([^<]+)<'
#         # matches = scrapertools.find_multiple_matches(data, patron)
#         for url, title, thumbnail, info in matches:
#             new_item = item.clone(action="list_fa")
#             if not url.startswith("http://www.filmaffinity"): new_item.url = "http://m.filmaffinity.com" + url
#             else: new_item.url = url.replace("www.filmaffinity.com", "m.filmaffinity.com")

#             new_item.thumbnail = thumbnail.replace("mmed", "large")
#             new_item.title = typo(title.strip(),'bold') + typo(info, '_ []') 
#             itemlist.append(new_item)

#         next_page = match(data, patron = r'<a href="([^"]+)">&gt;&gt;').match# scrapertools.find_single_match(data, '<a href="([^"]+)">&gt;&gt;')
#         if next_page:
#             if not next_page.startswith("http://www.filmaffinity.com"): next_page = "http://www.filmaffinity.com" + next_page
#             itemlist.append(Item(channel=item.channel, action=item.action, title=typo(config.get_localized_string(30992), 'color kod bold'), url=next_page, args=item.args))
#     elif config.get_localized_string(70032) in item.title:
#         bloque = scrapertools.find_single_match(data, '="genre">.*?</option>(.*?)</select>')
#         matches = scrapertools.find_multiple_matches(bloque, '<option value="([^"]+)">([^<]+)</option>')
#         for valor, titulo in matches:
#             if valor == "TV_SE":
#                 continue
#             new_item = item.clone(title=titulo, action="list_fa", args="top")
#             new_item.url = "http://m.filmaffinity.com/%s/topgen.php?genre=%s&country=&fromyear=&toyear=&nodoc=1" % (langf, valor)
#             if item.contentType == "movie":
#                 new_item.url += "&notvse=1"
#             # generos = ['1/accion.jpg', '1/animacion.jpg', '1/aventura.jpg', '1/guerra.jpg', '1/ciencia%20ficcion.jpg',
#             #            '2/Film-Noir.jpg', '1/comedia.jpg', '0/Unknown.png', '1/documental.jpg', '1/drama.jpg',
#             #            '1/fantasia.jpg', '2/Kids.jpg', '2/Suspense.jpg', '1/musical.jpg', '1/romance.jpg',
#             #            '1/terror.jpg', '1/thriler.jpg', '1/western.jpg']
#             # if langf != "en":
#             #     try:
#             #         new_item.thumbnail = "%s/%s" % (images_predef, generos[len(itemlist)])
#             #     except:
#             #         new_item.thumbnail = "%s1/%s.jpg" % (images_predef, titulo.lower())
#             # else:
#             #     new_item.thumbnail = "%s2/%s.jpg" % (images_predef, titulo)
#             itemlist.append(new_item)
#     elif "Temas" in item.title:
#         bloques = scrapertools.find_multiple_matches(data, '<div class="panel-heading" id="topic_([^"]+)".*?'
#                                                            '<div class="list-group">(.*?)</div>')
#         for letra, bloque in bloques:
#             patron = 'href="([^"]+)">([^<]+)<.*?"badge">(\d+)</span>'
#             matches = scrapertools.find_multiple_matches(bloque, patron)
#             args = len(matches) + 1
#             action = ""
#             folder = True
#             if config.is_xbmc():
#                 action = "move"
#                 folder = False
#             itemlist.append(item.clone(title=letra, action=action, args=args, folder=folder))
#             for url, titulo, numero in matches:
#                 new_item = item.clone(action="temas_fa")
#                 topic_id = scrapertools.find_single_match(url, r"topic=(\d+)")
#                 new_item.url = "http://www.filmaffinity.com/%s/%s&attr=all" % (
#                 langf, url.replace("&nodoc", "").replace("&notvse", ""))
#                 new_item.title = titulo + " (%s)" % numero
#                 itemlist.append(new_item)
#             itemlist = thumb(itemlist)
#     else:
#         from datetime import datetime
#         year = datetime.now().year
#         for i in range(year, 1899, -1):
#             new_item = item.clone(title=str(i), action="list_fa", args="top")
#             genre = ''
#             if item.contentType == "tvshow": genre = 'TV_SE'
#             new_item.url = "http://m.filmaffinity.com/%s/topgen.php?genre=%s&country=&fromyear=%s&toyear=%s&nodoc=1" % (langf, genre, i, i)
#             if item.contentType == "movie": new_item.url += "&notvse=1"
#             itemlist.append(new_item)

#     return itemlist


# def temas_fa(item):
#     # Movies and series by themes
#     itemlist = []

#     data = httptools.downloadpage(item.url).data
#     data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
#     data = re.sub(r"\s{2}", " ", data)
#     item.infoLabels['plot'] = scrapertools.find_single_match(data, '<p class="description">([^<]+)</p>')

#     patron = '<div class="mc-poster">\s*<a href=".*?(\d+)\.html".*?src="([^"]+)".*?' \
#              'href.*?>([^<]+)</a>\s*\((\d+)\)'
#     matches = scrapertools.find_multiple_matches(data, patron)
#     for url, thumb, title, year in matches:
#         title = title.strip()
#         new_item = item.clone(action="details_fa", contentType="movie", args="movie", )
#         new_item.url = "http://m.filmaffinity.com/%s/movie.php?id=%s" % (langf, url)
#         new_item.thumbnail = thumb.replace("msmall", "large")
#         if not new_item.thumbnail.startswith("http"):
#             new_item.thumbnail = "http://www.filmaffinity.com" + new_item.thumbnail
#         new_item.infoLabels["year"] = year
#         new_item.title = title + "  (%s)" % year
#         if re.search(r'(?i)serie de tv|\(tv\)', title):
#             new_item.contentType = "tvshow"
#             new_item.args = "tv"
#         new_item.contentTitle = re.sub(r'(?i)\(serie de tv\)|\(tv\)|\(c\)', '', title)
#         itemlist.append(new_item)

#     next_page = scrapertools.find_single_match(data, '<a href="([^"]+)">&gt;&gt;')
#     if next_page:
#         if not next_page.startswith("http://www.filmaffinity.com"):
#             next_page = "http://www.filmaffinity.com/%s/%s" % (langf, next_page)
#         itemlist.append(Item(channel=item.channel, action=item.action, title=config.get_localized_string(70065), url=next_page))

#     return itemlist


# def details_fa(item):
#     itemlist = []
#     item.plot = ""
#     rating = item.infoLabels['rating']
#     votos = item.infoLabels['votes']

#     data = httptools.downloadpage(item.url).data
#     data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
#     data = re.sub(r"\s{2}", " ", data)

#     # The original title is argscted for possible searches in later tmdb
#     orig_title = scrapertools.find_single_match(data, 'itemprop="datePublished">.*?<dd>([^<]+)</dd>').strip()
#     if item.contentType == "movie":
#         item.infoLabels['originaltitle'] = re.sub(r"(?i)\(TV Series\)|\(S\)|\(TV\)", "", orig_title)
#     else:
#         item.infoLabels['tvshowtitle'] = re.sub(r"(?i)\(TV Series\)|\(S\)|\(TV\)", "", orig_title)
#     item_tmdb = item.clone()

#     if item.contentType == "movie":
#         ob_tmdb = Tmdb(text_buscado=item_tmdb.contentTitle, year=item_tmdb.infoLabels['year'], tipo=item_tmdb.args,
#                        idioma_busqueda=langt)
#         if not ob_tmdb.result:
#             ob_tmdb = Tmdb(text_buscado=item_tmdb.infoLabels['originaltitle'], year=item_tmdb.infoLabels['year'],
#                            tipo=item_tmdb.args, idioma_busqueda=langt)
#     else:
#         ob_tmdb = Tmdb(text_buscado=item_tmdb.contentTitle, tipo=item_tmdb.args, idioma_busqueda=langt)
#         if not ob_tmdb.result:
#             ob_tmdb = Tmdb(text_buscado=item_tmdb.infoLabels['tvshowtitle'], tipo=item_tmdb.args,
#                            idioma_busqueda=langt)

#     if ob_tmdb.result:
#         ob_tmdb = Tmdb(id_Tmdb=ob_tmdb.get_id(), tipo=item_tmdb.args, idioma_busqueda=langt)
#         item.infoLabels = ob_tmdb.get_infoLabels(item.infoLabels)

#         # If there is no synopsis in the chosen language, search in the alternative
#         if not item.infoLabels["plot"]:
#             item.infoLabels["plot"] = ob_tmdb.get_sinopsis(idioma_alternativo=langt_alt)

#     # The filmaffinity plot is concatenated to the tmdb plot if any
#     plot = scrapertools.find_single_match(data, '<dd itemprop="description">(.*?)</dd>')
#     plot = plot.replace("<br><br />", "\n")
#     plot = scrapertools.decodeHtmlentities(plot).replace(" (FILMAFFINITY)", "")
#     if plot and (item.infoLabels['plot'] and item.infoLabels['plot'] != plot):
#         item.infoLabels['plot'] += " (TMDB)\n" + plot + " (FILMAFFINITY)"
#     elif plot and not item.infoLabels['plot']:
#         item.infoLabels['plot'] = plot

#     # It is searched and filled with the filmaffinity info to differentiate it from tmdb
#     if not item.infoLabels['duration']:
#         duration = scrapertools.find_single_match(data, '<dd itemprop="duration">(\d+)')
#         if duration:
#             item.infoLabels['duration'] = int(duration) * 60

#     if not item.infoLabels['genre']:
#         generos = scrapertools.find_multiple_matches(data, 'class="g-t-item">(.*?)</a>')
#         genres = []
#         for g in generos:
#             genres.append(scrapertools.htmlclean(g.strip()))
#         item.infoLabels['genre'] = ", ".join(genres)

#     if not rating:
#         rating = scrapertools.find_single_match(data, 'itemprop="ratingValue".*?>([^<]+)<')
#         if rating:
#             rating = float(rating.replace(",", "."))
#         elif ob_tmdb.result:
#             rating = float(ob_tmdb.result.get('vote_average', 0))
#         item.infoLabels['rating'] = rating

#     if not votos:
#         votos = scrapertools.find_single_match(data, 'itemprop="ratingCount".*?>([^<]+)<')
#         if votos == "0" and ob_tmdb.result:
#             votos = ob_tmdb.result.get('vote_count', '')
#         item.infoLabels['votes'] = votos

#     if item.infoLabels['fanart']:
#         item.fanart = item.infoLabels['fanart']
#     else:
#         item.fanart = scrapertools.find_single_match(data, 'Imagen Principal.*?src: "([^"]+)"')
#     if item.infoLabels['thumbnail']:
#         item.thumbnail = item.infoLabels['thumbnail']

#     if item.infoLabels['tagline']:
#         itemlist.append(item.clone(title="--- %s ---" % item.infoLabels['tagline'], action=""))

#     title = item.contentType.replace("movie", config.get_localized_string(70283)).replace("tvshow", "serie")
#     itemlist.append(item.clone(action="searching", title=config.get_localized_string(70069) % (title, item.contentTitle)))
#     if item.infoLabels['originaltitle'] and item.contentTitle != item.infoLabels['originaltitle']:
#         itemlist.append(item.clone(action="searching", contentTitle=item.infoLabels['originaltitle'],
#                                    title=config.get_localized_string(70070) % item.infoLabels['originaltitle']))

#     if langt != "es" and langt != "en" and item.infoLabels["tmdb_id"]:
#         tmdb_lang = Tmdb(id_Tmdb=item.infoLabels["tmdb_id"], tipo=item.args, idioma_busqueda=def_lang)
#         if tmdb_lang.result.get("title") and tmdb_lang.result["title"] != item.contentTitle:
#             tmdb_lang = tmdb_lang.result["title"]
#             itemlist.append(item.clone(action="searching", title=config.get_localized_string(70066) % tmdb_lang,
#                                        contentTitle=tmdb_lang))

#     if item.contentType == "tvshow" and ob_tmdb.result:
#         itemlist.append(item.clone(action="info_seasons",
#                                    title=config.get_localized_string(70067) % item.infoLabels["number_of_seasons"]))
#     if ob_tmdb.result:
#         itemlist.append(item.clone(action="distribution", title=config.get_localized_string(70071),
#                                    infoLabels={'tmdb_id': item.infoLabels['tmdb_id'],
#                                                'mediatype': item.contentType}))

#     if config.is_xbmc():
#         item.contextual = True
#     trailer_url = scrapertools.find_single_match(data,
#                                                  '<a href="(?:http://m.filmaffinity.com|)/%s/movieTrailer\.php\?id=(\d+)"' % langf)
#     if trailer_url:
#         trailer_url = "http://www.filmaffinity.com/%s/evideos.php?movie_id=%s" % (langf, trailer_url)
#     itemlist.append(item.clone(channel="trailertools", action="buscartrailer", title=config.get_localized_string(30162),
#                                 filmaffinity=trailer_url))

#     url_img = scrapertools.find_single_match(data,
#                                              'href="(?:http://m.filmaffinity.com|)(/%s/movieposters[^"]+)">' % langf)
#     images = {}
#     if ob_tmdb.result and ob_tmdb.result.get("images"):
#         images['tmdb'] = ob_tmdb.result["images"]
#     if url_img:
#         images['filmaffinity'] = {}
#     if images:
#         itemlist.append(item.clone(action="imagenes", title=config.get_localized_string(70316), images=images,
#                                    url=url_img, args="menu"))
#     try:
#         if item.contentType == "movie" and item.infoLabels["year"] < 2014:
#             post_url = "https://theost.com/search/custom/?key=%s&year=%s&country=0&genre=0" % (
#             item.infoLabels['originaltitle'].replace(" ", "+"), item.infoLabels["year"])
#             url = "https://nl.hideproxy.me/includes/process.php?action=update"
#             post = "u=%s&proxy_formdata_server=nl&allowCookies=1&encodeURL=1&encodePage=0&stripObjects=0&stripJS=0&go=" % urllib.quote(
#                 post_url)
#             while True:
#                 response = httptools.downloadpage(url, post=post, follow_redirects=False)
#                 if response.headers.get("location"):
#                     url = response.headers["location"]
#                     post = ""
#                 else:
#                     data_music = response.data
#                     break

#             url_album = scrapertools.find_single_match(data_music, 'album(?:s|) on request.*?href="([^"]+)"')
#             if url_album:
#                 url_album = "https://nl.hideproxy.me" + url_album
#                 itemlist.append(
#                     item.clone(action="musica_movie", title=config.get_localized_string(70317), url=url_album,
#                                ))
#     except:
#         pass

#     token_auth = config.get_setting("token_trakt", "trakt")
#     if token_auth and ob_tmdb.result:
#         itemlist.append(item.clone(title=config.get_localized_string(70323), action="menu_trakt"))
#     # Actions if account is configured in FA (Vote and add / remove in lists)
#     mivoto = scrapertools.find_single_match(data, 'bg-my-rating.*?>\s*(\d+)')
#     itk = scrapertools.find_single_match(data, 'data-itk="([^"]+)"')
#     folder = not config.is_xbmc()
#     if mivoto:
#         item.infoLabels["userrating"] = int(mivoto)
#         new_item = item.clone(action="votar_fa", title=config.get_localized_string(70324) % mivoto,
#                               itk=itk, voto=int(mivoto), folder=folder)
#         new_item.infoLabels["duration"] = ""
#         itemlist.append(new_item)
#     else:
#         if itk:
#             new_item = item.clone(action="votar_fa", title=config.get_localized_string(70325) % title, itk=itk, accion="votar",
#                                   folder=folder)
#             new_item.infoLabels["duration"] = ""
#             itemlist.append(new_item)

#     if itk:
#         itk = scrapertools.find_single_match(data, 'var itk="([^"]+)"')
#         new_item = item.clone(action="acciones_fa", accion="lista_movie", itk=itk,
#                               title=config.get_localized_string(70326))
#         new_item.infoLabels["duration"] = ""
#         itemlist.append(new_item)

#     # If you belong to a saga / collection
#     if ob_tmdb.result:
#         itemlist.append(item.clone(title="", action="", infoLabels={}))
#         if ob_tmdb.result.get("belongs_to_collection"):
#             new_item = item.clone(action="list_tmdb", )
#             saga = ob_tmdb.result["belongs_to_collection"]
#             new_item.infoLabels["tmdb_id"] = saga["id"]
#             if saga["poster_path"]:
#                 new_item.thumbnail = 'https://image.tmdb.org/t/p/original' + saga["poster_path"]
#             if saga["backdrop_path"]:
#                 new_item.fanart = 'https://image.tmdb.org/t/p/original' + saga["backdrop_path"]
#             new_item.search = {'url': 'collection/%s' % saga['id'], 'language': langt}
#             new_item.title = config.get_localized_string(70327) % saga["name"]
#             itemlist.append(new_item)

#         itemlist.append(item.clone(title=config.get_localized_string(70328) % title.capitalize(), action="list_tmdb",
#                                    search={'url': '%s/%s/similar' % (item.args, item.infoLabels['tmdb_id']),
#                                            'language': langt, 'page': 1}, 
#                                    ))
#         itemlist.append(
#             item.clone(title=config.get_localized_string(70315), action="list_tmdb", 
#                        search={'url': '%s/%s/recommendations' % (item.args, item.infoLabels['tmdb_id']),
#                                'language': langt, 'page': 1}, ))

#     return itemlist


# def filter_fa(item):
#     logger.debug()

#     from datetime import datetime
#     list_controls = []
#     valores = {}

#     dict_values = None
#     # Default / saved values ​​are used
#     saved_values = config.get_setting("default_filter_filmaf_" + item.args, item.channel)
#     if saved_values:
#         dict_values = saved_values

#     list_controls.append({'id': 'yearsdesde', 'label': config.get_localized_string(70452), 'enabled': True,
#                           'type': 'list', 'default': -1, 'visible': True})
#     list_controls.append({'id': 'yearshasta', 'label': config.get_localized_string(70453), 'enabled': True,
#                           'type': 'list', 'default': -1, 'visible': True})
#     list_controls[0]['lvalues'] = []
#     list_controls[1]['lvalues'] = []
#     valores['years'] = []
#     year = datetime.now().year
#     for i in range(1900, year + 1):
#         list_controls[0]['lvalues'].append(str(i))
#         list_controls[1]['lvalues'].append(str(i))
#         valores['years'].append(str(i))
#     list_controls[0]['lvalues'].append(config.get_localized_string(70450))
#     list_controls[1]['lvalues'].append(config.get_localized_string(70450))
#     valores['years'].append('')

#     data = httptools.downloadpage("http://m.filmaffinity.com/%s/topgen.php" % langf).data
#     data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
#     data = re.sub(r"\s{2}", " ", data)
#     if item.contentType == "movie":
#         try:
#             bloque = scrapertools.find_single_match(data, 'name="genre">.*?</option>(.*?)</select>')
#             matches = scrapertools.find_multiple_matches(bloque, '<option value="([^"]+)">([^<]+)</option>')
#             if matches:
#                 list_controls.append({'id': 'genero', 'label': config.get_localized_string(70467), 'enabled': True,
#                                       'type': 'list', 'default': -1, 'visible': True})
#                 list_controls[2]['lvalues'] = []
#                 list_controls[2]['lvalues'].append("Todos")
#                 valores['genero'] = []
#                 valores['genero'].append('')
#                 for valor, titulo in matches:
#                     if valor == "TV_SE":
#                         continue
#                     list_controls[2]['lvalues'].insert(0, titulo)
#                     valores['genero'].insert(0, valor)

#         except:
#             pass

#     try:
#         bloque = scrapertools.find_single_match(data, 'name="country">.*?</option>(.*?)</select>')
#         matches = scrapertools.find_multiple_matches(bloque, '<option value="([^"]+)"\s*>([^<]+)</option>')
#         if matches:
#             list_controls.append({'id': 'pais', 'label': config.get_localized_string(70466), 'enabled': True,
#                                   'type': 'list', 'default': -1, 'visible': True})
#             list_controls[-1]['lvalues'] = []
#             list_controls[-1]['lvalues'].append('Todos')
#             valores['pais'] = []
#             valores['pais'].append('')
#             for valor, titulo in matches:
#                 list_controls[-1]['lvalues'].insert(0, titulo)
#                 valores['pais'].insert(0, valor)
#     except:
#         pass

#     list_controls.append({'id': 'espacio', 'label': '', 'enabled': False,
#                           'type': 'label', 'default': None, 'visible': True})
#     list_controls.append({'id': 'save', 'label': config.get_localized_string(70464), 'enabled': True,
#                           'type': 'bool', 'default': False, 'visible': True})

#     item.valores = valores
#     return platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values,
#                                                caption=config.get_localized_string(70320), item=item, callback='filtered_fa')


# def filtered_fa(item, values):
#     values_copy = values.copy()
#     # Save the filter to be the one loaded by default
#     if "save" in values and values["save"]:
#         values_copy.pop("save")
#         config.set_setting("default_filter_filmaf_" + item.args, values_copy, item.channel)

#     yeard = item.valores["years"][values["yearsdesde"]]
#     yearh = item.valores["years"][values["yearshasta"]]
#     pais = item.valores["pais"][values["pais"]]
#     if item.contentType == "movie":
#         genero = item.valores["genero"][values["genero"]]
#     else:
#         genero = "TV_SE"

#     item.url = 'http://m.filmaffinity.com/%s/topgen.php?genre=%s&country=%s&fromyear=%s&toyear=%s&nodoc=1' \
#                % (langf, genero, pais, yeard, yearh)
#     if item.contentType == "movie":
#         item.url += "&notvse=1"
#     item.action = "list_fa"

#     return list_fa(item)


# def login_fa():
#     logger.debug()

#     try:
#         user = config.get_setting("usuariofa", "tvmoviedb")
#         password = config.get_setting("passfa", "tvmoviedb")
#         userid = config.get_setting("userid", "tvmoviedb")
#         if user == "" or password == "":
#             return False, config.get_localized_string(70329)
#         data = httptools.downloadpage("http://m.filmaffinity.com/%s" % langf).data
#         if "modal-menu-user" in data and userid:
#             return True, ""

#         post = "postback=1&rp=&username=%s&password=%s&rememberme=on" % (user, password)
#         data = httptools.downloadpage("https://m.filmaffinity.com/%s/account.ajax.php?action=login" % langf, post=post).data

#         if "Invalid username" in data:
#             logger.error("Error en el login")
#             return False, config.get_localized_string(70330)
#         else:
#             post = "name=user-menu&url=http://m.filmaffinity.com/%s/main.php" % langf
#             data = httptools.downloadpage("http://m.filmaffinity.com/%s/tpl.ajax.php?action=getTemplate" % langf,
#                                           post=post).data
#             userid = scrapertools.find_single_match(data, 'id-user=(\d+)')
#             if userid:
#                 config.set_setting("userid", userid, "tvmoviedb")
#             logger.debug("Login correcto")
#             return True, ""
#     except:
#         import traceback
#         logger.error(traceback.format_exc())
#         return False, config.get_localized_string(70331)


# def cuenta_fa(item):
#     # Filmaffinity account menu
#     itemlist = []
#     login, message = login_fa()
#     if not login:
#         itemlist.append(item.clone(action="", title=message, ))
#     else:
#         userid = config.get_setting("userid", "tvmoviedb")
#         itemlist.append(item.clone(action="acciones_fa", title=config.get_localized_string(70332), accion="votos",
#                                    url="http://m.filmaffinity.com/%s/user_ratings.php?id-user=%s" % (langf, userid)))
#         itemlist.append(item.clone(action="acciones_fa", title=config.get_localized_string(70057), accion="listas",
#                                    url="http://m.filmaffinity.com/%s/mylists.php" % langf))

#     return itemlist


# def acciones_fa(item):
#     # Actions account filmaffinity, vote, view lists or add / remove from list
#     itemlist = []

#     if item.accion == "votos" or item.accion == "lista":
#         data = httptools.downloadpage(item.url).data
#         data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
#         data = re.sub(r"\s{2}", " ", data)
#         bloques = scrapertools.find_multiple_matches(data,
#                                                      'list-group-item(?:[^>]+>\s*<a| rip)(.*?</div>)\s*</div>\s*<div')
#         for bloque in bloques:
#             patron = 'href="([^"]+)".*?data-src="([^"]+)".*?mc-title.*?>([^<]+)' \
#                      '<small>\((\d+)\)</small>.*?(?:<div class="avgrat-box in-block ">' \
#                      '([^<]+)</div>\s*<small class="ratcount-box">(.*?)\s*<|</li>).*?'
#             matches = scrapertools.find_multiple_matches(bloque, patron)
#             mivoto = scrapertools.find_single_match(bloque, 'bg-my-rating[^>]+>(?:\s*<strong>|)([^<]+)<')
#             for url, thumb, title, year, rating, votos in matches:
#                 new_item = item.clone(action="details_fa", )
#                 if not url.startswith("http://m.filmaffinity"):
#                     new_item.url = "http://m.filmaffinity.com" + url
#                 else:
#                     new_item.url = url

#                 new_item.infoLabels["year"] = year
#                 rating = rating.replace(",", ".")
#                 new_item.infoLabels["rating"] = float(rating)
#                 new_item.infoLabels["votes"] = votos.replace(".", "")
#                 if mivoto.isdigit():
#                     new_item.infoLabels["userrating"] = int(mivoto)
#                 new_item.thumbnail = thumb.replace("msmall", "large")
#                 if not new_item.thumbnail.startswith("http"):
#                     new_item.thumbnail = "http://m.filmaffinity.com" + new_item.thumbnail

#                 if re.search(r'(?i)serie de tv|\(tv\)', title):
#                     new_item.contentType = "tvshow"
#                     new_item.args = "tv"
#                 new_item.title = title.strip() + "  (%s) %s/]%s" % (
#                 year, rating, mivoto)
#                 new_item.contentTitle = title.strip()
#                 itemlist.append(new_item)
#     elif item.accion == "listas":
#         orderby = config.get_setting("orderfa", "tvmoviedb")
#         data = httptools.downloadpage(item.url).data
#         data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
#         data = re.sub(r"\s{2}", " ", data)
#         patron = 'list-group-item rip.*?href="([^"]+)".*?<strong>([^<]+)</strong>.*?<em>([^<]+)</em>' \
#                  '.*?(?:<div class="ls-imgs">(.*?)</a>|</a>)'
#         matches = scrapertools.find_multiple_matches(data, patron)
#         for url, title, content, imgs in matches:
#             new_item = item.clone(accion="lista", )
#             if not url.startswith("http://m.filmaffinity.com"):
#                 new_item.url = "http://m.filmaffinity.com%s&orderby=%s" % (url, orderby)
#             else:
#                 new_item.url = "%s&orderby=%s" % (url, orderby)
#             new_item.title = title + "  (%s)" % (content)
#             if imgs:
#                 imagenes = scrapertools.find_multiple_matches(imgs, 'data-src="([^"]+)"')
#                 from random import randint
#                 random = randint(0, len(imagenes) - 1)
#                 new_item.thumbnail = imagenes[random].replace("msmall", "large")
#             itemlist.append(new_item)
#     elif item.accion == "lista_movie":
#         movieid = item.url.rsplit("=", 1)[1]
#         url = "http://m.filmaffinity.com/%s/edtmovielists.php?movie_id=%s" % (langf, movieid)
#         data = httptools.downloadpage(url).data
#         patron = 'data-list-id="([^"]+)"(.*?)<div class="in-block list-name"><strong>([^<]+)<'
#         matches = scrapertools.find_multiple_matches(data, patron)
#         for listid, chequeo, title in matches:
#             new_item = item.clone(folder=not config.is_xbmc())
#             new_item.infoLabels["duration"] = ""
#             new_item.listid = listid
#             if "checked" in chequeo:
#                 new_item.title = "[COLOR %s]%s[/COLOR] %s" % ("green", u"\u0474".encode('utf-8'), title)
#                 new_item.accion = "removeMovieFromList"
#             else:
#                 new_item.title = "%s %s" % ( u"\u04FE".encode('utf-8'), title)
#                 new_item.accion = "addMovieToList"
#             itemlist.append(new_item)
#         new_item = item.clone(action="newlist", title=config.get_localized_string(70333), )
#         new_item.infoLabels["duration"] = ""
#         itemlist.append(new_item)
#     else:
#         url = "http://filmaffinity.com/%s/movieslist.ajax.php" % langf
#         movieid = item.url.rsplit("=", 1)[1]
#         post = "action=%s&listId=%s&movieId=%s&itk=%s" % (item.accion, item.listid, movieid, item.itk)
#         data = jsontools.load(httptools.downloadpage(url, post=post).data)
#         if not item.folder:
#             import xbmc
#             return xbmc.executebuiltin("Container.Refresh")
#         else:
#             if data["result"] == 0:
#                 title = config.get_localized_string(70334)
#             else:
#                 title = config.get_localized_string(70335)
#             itemlist.append(item.clone(action="", title=title))

#     return itemlist


# def votar_fa(item):
#     # Window to select the vote
#     logger.debug()

#     list_controls = []
#     valores = {}
#     dict_values = None
#     if item.voto:
#         dict_values = {'voto': item.voto}
#     list_controls.append({'id': 'voto', 'label': config.get_localized_string(70468), 'enabled': True,
#                           'type': 'list', 'default': 0, 'visible': True})
#     list_controls[0]['lvalues'] = ['No vista']
#     valores['voto'] = ["-1"]
#     for i in range(1, 11):
#         list_controls[0]['lvalues'].append(str(i))
#         valores['voto'].append(i)

#     item.valores = valores
#     return platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values,
#                                                caption=config.get_localized_string(70336) % item.contentTitle, item=item,
#                                                callback='callback_voto')


# def callback_voto(item, values):
#     item.voto = item.valores["voto"][values["voto"]]
#     item.action = "acciones_fa"
#     movieid = item.url.rsplit("=", 1)[1]
#     post = "id=%s&rating=%s&itk=%s&action=rate" % (movieid, item.voto, item.itk)
#     data = jsontools.load(httptools.downloadpage("http://filmaffinity.com/%s/ratingajax.php" % langf, post=post).data)

#     if not item.folder:
#         import xbmc
#         return xbmc.executebuiltin("Container.Refresh")
#     else:
#         if data["result"] == 0:
#             title = config.get_localized_string(70337)
#         else:
#             title = config.get_localized_string(70335)
#         itemlist.append(item.clone(action="", title=title))
#         return itemlist


# def newlist(item):
#     # Creation of new list in filmaffinity
#     itemlist = []
#     if item.accion == "lista":
#         location = httptools.downloadpage(item.url, only_headers=True).headers["location"]
#         data = httptools.downloadpage("http://m.filmaffinity.com" + location).data
#         itemlist.append(item.clone(action="", title=config.get_localized_string(70338)))
#     else:
#         url = "http://m.filmaffinity.com/%s/addlist.php?rp=%s" % (langf, item.url)
#         data = httptools.downloadpage(url).data
#         data = re.sub(r"\n|\r|\t|&nbsp;|\s{2}", "", data)

#         patron = 'data-list-id="[^"]+" href="([^"]+)"><[^>]+><div class="col-xs-10">' \
#                  '([^<]+)</div><div[^>]+><div type="button" class="btn btn-primary">'
#         matches = scrapertools.find_multiple_matches(data, patron)
#         for scrapedurl, title in matches:
#             scrapedurl = "http://m.filmaffinity.com" + scrapedurl
#             itemlist.append(item.clone(title=title, url=scrapedurl, accion="lista"))

#     return itemlist


##-------------------- IMAGE LISTINGS ------------------------##
def imagenes(item):
    itemlist = []


    if item.args == "menu":
        item.folder = not config.is_xbmc()
        if "tmdb" in item.images:
            itemlist.append(item.clone(title="Tmdb", args=""))
            itemlist.append(item.clone(title="Fanart.Tv", args=""))
        if "imdb" in item.images:
            itemlist.append(item.clone(title="Imdb", args=""))
        # if "filmaffinity" in item.images:
        #     itemlist.append(item.clone(title="Filmaffinity", args=""))
        if "myanimelist" in item.images:
            images = match(item.url + "/pics", cookies=False, patron=R'<div class="picSurround"><a href="([^"]+)" title="([^"]+)"').matches
            if images:
                for thumb, title in images:
                    item.images["myanimelist"].append([thumb, title])
                itemlist.append(item.clone(title="MyAnimeList", args=""))

        return itemlist

    if "Fanart" in item.title:
        try:
            item, resultado = fanartv(item)
        except:
            resultado = None

        if not resultado:
            itemlist.append(item.clone(title=config.get_localized_string(70338), action=""))
            return itemlist
    # elif "Filmaffinity" in item.title:
    #     try:
    #         url = "http://m.filmaffinity.com" + item.url
    #         data = httptools.downloadpage(url).data
    #         matches = scrapertools.find_multiple_matches(data, 'data-src="([^"]+)" alt="[^-]+\s*([^"]+)"')
    #         if matches:
    #             item.images["filmaffinity"] = matches
    #         else:
    #             item.images.pop("filmaffinity", None)
    #     except:
    #         itemlist.append(item.clone(title=config.get_localized_string(70339), action=""))
    #         return itemlist
    elif "Imdb" in item.title:
        try:
            from core import httptools
            data = jsontools.load(httptools.downloadpage(item.images["imdb"]["url"], cookies=False).data)
            item.images["imdb"].pop("url")
            if data.get("allImages"):
                item.images["imdb"] = data["allImages"]
            else:
                item.images.pop("imdb", None)
        except:
            itemlist.append(item.clone(title=config.get_localized_string(70339), action=""))
            return itemlist

    if item.images:
        from platformcode import infoplus
        for key, value in item.images.items():
            if key == "tmdb" and "Tmdb" in item.title:
                if item.folder:
                    for tipo, child in value.iteritems():
                        for i, imagen in enumerate(child):
                            thumb = 'https://image.tmdb.org/t/p/w500' + imagen["file_path"]
                            fanart = 'https://image.tmdb.org/t/p/original' + imagen["file_path"]
                            title = "   %s %s [%sx%s]" % (tipo.capitalize(), i + 1, imagen["width"], imagen["height"])
                            itemlist.append(Item(channel=item.channel, action="", thumbnail=thumb, fanart=fanart,
                                                 title=title, infoLabels=item.infoLabels))
                else:
                    imagesWindow = infoplus.ImagesWindow(tmdb=value).doModal()

            elif key == "fanart.tv":
                if item.folder:
                    for tipo, child in value.iteritems():
                        for i, imagen in enumerate(child):
                            thumb = imagen["url"].replace("/fanart/", "/preview/")
                            fanart = imagen["url"]
                            title = "   %s %s [%s]" % (tipo.capitalize(), i + 1, imagen["lang"])
                            itemlist.append(Item(channel=item.channel, action="", thumbnail=thumb, fanart=fanart,
                                                 title=title, infoLabels=item.infoLabels))
                else:
                    imagesWindow = infoplus.ImagesWindow(fanartv=value).doModal()

            # elif key == "filmaffinity" and "Filmaffinity" in item.title:
            #     if item.folder:
            #         for thumb, title in value:
            #             thumb = thumb.replace("-s200", "-large")
            #             itemlist.append(Item(channel=item.channel, action="", thumbnail=thumb, fanart=thumb,
            #                                  title=title, infoLabels=item.infoLabels))
            #     else:
            #         imagesWindow = infoplus.images(fa=value).doModal()

            elif key == "imdb" and "Imdb" in item.title:
                if item.folder:
                    for imagen in value:
                        thumb = imagen["msrc"]
                        fanart = imagen["src"]
                        title = imagen["altText"]
                        itemlist.append(
                            Item(channel=item.channel, action="", thumbnail=thumb, fanart=fanart, title=title,
                                  infoLabels=item.infoLabels))
                else:
                    imagesWindow = infoplus.ImagesWindow(imdb=value).doModal()

            elif key == "myanimelist" and "MyAnimeList" in item.title:
                if item.folder:
                    for imagen, title in value:
                        itemlist.append(
                            Item(channel=item.channel, action="", thumbnail=imagen, fanart=imagen, title=title,
                                  infoLabels=item.infoLabels))
                else:
                    imagesWindow = infoplus.ImagesWindow(mal=value).doModal()

    return itemlist


def fanartv(item):
    headers = [['Content-Type', 'application/json']]
    id_search = item.infoLabels['tmdb_id']
    if item.contentType == "tvshow" and id_search:
        search = {'url': 'tv/%s/external_ids' % item.infoLabels['tmdb_id'], 'language': langt}
        ob_tmdb = Tmdb(discover=search, idioma_busqueda=langt)
        id_search = ob_tmdb.result.get("tvdb_id")

    resultado = False
    if id_search:
        if item.contentType == "movie":
            url = "http://webservice.fanart.tv/v3/movies/%s?api_key=cab16e262d72fea6a6843d679aa10300" \
                  % item.infoLabels['tmdb_id']
        else:
            url = "http://webservice.fanart.tv/v3/tv/%s?api_key=cab16e262d72fea6a6843d679aa10300" % id_search
        #data = jsontools.load(httptools.downloadpage(url, headers=headers, replace_headers=True).data)
        data = jsontools.load(match(url, headers=headers).data)
        if data and not "error message" in data:
            item.images['fanart.tv'] = {}
            for key, value in data.items():
                if key not in ["name", "tmdb_id", "imdb_id", "thetvdb_id"]:
                    item.images['fanart.tv'][key] = value
                    resultado = True

    return item, resultado


##-------------------- SECTION TRAKT.TV ------------------------##
def auth_trakt(item):
    return trakt_tools.auth_trakt()


def menu_trakt(item):
    # Menu with trakt account actions (views, watchlist, collection)
    itemlist = []
    token_auth = config.get_setting("token_trakt", "trakt")
    tipo = item.args.replace("tv", "show") + "s"
    title = item.contentType.replace("movie", config.get_localized_string(70283)).replace("tvshow", config.get_localized_string(30123))
    try:
        result = acciones_trakt(item.clone(url="sync/watched/%s" % tipo))
        post = {tipo: [{"ids": {"tmdb": item.infoLabels["tmdb_id"]}}]}
        if '"tmdb":%s' % item.infoLabels["tmdb_id"] in result: itemlist.append(item.clone(title=config.get_localized_string(70341) % title, action="acciones_trakt", url="sync/history/remove", post=post))
        else: itemlist.append(item.clone(title=config.get_localized_string(70342) % title, action="acciones_trakt", url="sync/history", post=post))
    except:
        pass

    try:
        result = acciones_trakt(item.clone(url="sync/watchlist/%s" % tipo))
        post = {tipo: [{"ids": {"tmdb": item.infoLabels["tmdb_id"]}}]}
        if '"tmdb":%s' % item.infoLabels["tmdb_id"] in result: itemlist.append(item.clone(title=config.get_localized_string(70343) % title, action="acciones_trakt", url="sync/watchlist/remove", post=post))
        else: itemlist.append(item.clone(title=config.get_localized_string(70344) % title, action="acciones_trakt", url="sync/watchlist", post=post))
    except:
        pass

    try:
        result = acciones_trakt(item.clone(url="sync/collection/%s" % tipo))
        post = {tipo: [{"ids": {"tmdb": item.infoLabels["tmdb_id"]}}]}
        if '"tmdb":%s' % item.infoLabels["tmdb_id"] in result: itemlist.append(item.clone(title=config.get_localized_string(70345) % title, action="acciones_trakt", url="sync/collection/remove", post=post))
        else: itemlist.append(item.clone(title=config.get_localized_string(70346) % title, action="acciones_trakt", url="sync/collection", post=post))
    except:
        pass

    return itemlist


def acciones_trakt(item):
    from core import httptools
    token_auth = config.get_setting("token_trakt", "trakt")
    itemlist = []
    item.contentType = item.args.replace("show", "tvshow")
    client_id = "502bd1660b833c1ae69828163c0848e84e9850061e5529f30930e7356cae73b1"
    headers = [['Content-Type', 'application/json'], ['trakt-api-key', client_id], ['trakt-api-version', '2']]
    if token_auth: headers.append(['Authorization', "Bearer %s" % token_auth])

    post = None
    if item.post: post = jsontools.dump(item.post)

    url = "http://api-v2launch.trakt.tv/%s" % item.url
    data = httptools.downloadpage(url, post=post, headers=headers)
    if data.code == "401":
        trakt_tools.token_trakt(item.clone(args="renew"))
        token_auth = config.get_setting("token_trakt", "trakt")
        headers[3][1] = "Bearer %s" % token_auth
        data = httptools.downloadpage(url, post=post, headers=headers)

    data = data.data
    if data and "sync" in item.url:
        if not item.post:
            return data
        else:
            data = jsontools.load(data)
            if "not_found" in data: return platformtools.dialog_notification("Trakt", config.get_localized_string(70347))
            else: return platformtools.dialog_notification("Trakt", config.get_localized_string(70348))
    elif data and "recommendations" in item.url:
        data = jsontools.load(data)
        ratings = []
        try:
            for i, entry in enumerate(data):
                logger.debug('ENTRY:',entry)
                if i <= item.pagina: continue
                # try: entry = entry[item.args]
                # except: pass
                new_item = item.clone(action="details")
                new_item.title = typo(entry["title"], 'bold') + typo(entry["year"],'_ () bold')
                new_item.infoLabels["tmdb_id"] = entry["ids"]["tmdb"]
                try: ratings.append(entry["rating"])
                except: ratings.append(0.0)
                itemlist.append(new_item)
                if i == item.pagina + 20:
                    itemlist.append(item.clone(title=config.get_localized_string(70065), pagina=item.pagina + 20))
                    break

            from core import tmdb
            tmdb.set_infoLabels_itemlist(itemlist[:-1], True)
            for i, new_item in enumerate(itemlist[:-1]):
                if new_item.infoLabels["title"]: new_item.title = typo(new_item.infoLabels["title"] + "  (%s)" % new_item.infoLabels["year"], 'bold')
                if ratings[i]: new_item.title += typo("Trakt: %.2f | Tmdb: %.2f"  % (ratings[i], new_item.infoLabels["rating"]), '_ [] color kod')
        except:
            pass

    elif data and not item.url.endswith("lists"):
        data = jsontools.load(data)
        if data and "page=1" in item.url and item.order:
            valores = {'rank': config.get_localized_string(70003), 'added': config.get_localized_string(70469), 'title': config.get_localized_string(60320), 'released': config.get_localized_string(70470),
                       'runtime': config.get_localized_string(70471), 'popularity': config.get_localized_string(70472), 'percentage': config.get_localized_string(70473),
                       'votes': config.get_localized_string(70474), 'asc': config.get_localized_string(70475), 'desc': config.get_localized_string(70476)}
            orden = valores[item.order] + " " + valores[item.how]
        ratings = []
        try:
            for entry in data:
                try: entry = entry[item.args]
                except: pass
                new_item = item.clone(action="details")
                new_item.title = entry["title"] + " (%s)" % entry["year"]
                new_item.infoLabels["tmdb_id"] = entry["ids"]["tmdb"]
                try: ratings.append(entry["rating"])
                except: ratings.append("")
                itemlist.append(new_item)

            from core import tmdb
            if "page=1" in item.url and item.order:
                tmdb.set_infoLabels_itemlist(itemlist[1:], True)
                for i, new_item in enumerate(itemlist[1:]):
                    if new_item.infoLabels["title"]: new_item.title = typo(new_item.infoLabels["title"] + ' ' + new_item.infoLabels["year"], 'bold')
                    if ratings[i]: new_item.title += typo("Trakt: %.2f | Tmdb: %.2f"  % (ratings[i], new_item.infoLabels["rating"]), '_ [] color kod')
            else:
                tmdb.set_infoLabels_itemlist(itemlist, True)
                for i, new_item in enumerate(itemlist):
                    if new_item.infoLabels["title"]: new_item.title = typo(new_item.infoLabels["title"] + " (%s)" % new_item.infoLabels["year"], 'bold')
                    if ratings[i]: new_item.title += typo("Trakt: %.2f | Tmdb: %.2f"  % (ratings[i], new_item.infoLabels["rating"]), '_ [] color kod')
        except:
            import traceback
            logger.error(traceback.format_exc())

        if "page" in item.url and len(itemlist) == 20:
            page = match(item.url, patron=r'page=(\d+)').match
            page_new = int(page) + 1
            url = item.url.replace("page=" + page, "page=" + str(page_new))
            itemlist.append(item.clone(title=typo(config.get_localized_string(30992), 'color kod bold'), url=url, thumbnail=thumb()))
    else:
        data = jsontools.load(data)
        for entry in data:
            new_item = item.clone()
            new_item.title = typo(entry["name"],'bold') + typo(str(entry["item_count"]),'color kod bold _ []')
            new_item.infoLabels["plot"] = entry.get("description")
            new_item.url = "users/me/lists/%s/items/?page=1&limit=20&extended=full" % entry["ids"]["trakt"]
            new_item.order = entry.get("sort_by")
            new_item.how = entry.get("sort_how")
            itemlist.append(new_item)

    return itemlist


def order_list(item):
    logger.debug()

    list_controls = []
    valores1 = ['rating', 'added', 'title', 'released', 'runtime', 'popularity', 'percentage', 'votes']
    valores2 = ['asc', 'desc']

    dict_values = {'orderby': valores1.index(item.order), 'orderhow': valores2.index(item.how)}

    list_controls.append({'id': 'orderby', 'label': config.get_localized_string(70455), 'enabled': True,
                          'type': 'list', 'default': 0, 'visible': True})
    list_controls.append({'id': 'orderhow', 'label': 'De forma:', 'enabled': True,
                          'type': 'list', 'default': 0, 'visible': True})
    list_controls[0]['lvalues'] = ['rank', 'added', 'title', 'released', 'runtime', 'popularity', 'percentage', 'votes']
    list_controls[1]['lvalues'] = ['asc', 'desc']
    return platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values, caption=config.get_localized_string(70320), item=item, callback='order_trakt')


def order_trakt(item, values):
    valores1 = ['rank', 'added', 'title', 'released', 'runtime', 'popularity', 'percentage', 'votes']
    valores2 = ['asc', 'desc']
    orderby = valores1[values["orderby"]]
    item.order = orderby
    orderhow = valores2[values["orderhow"]]
    item.how = orderhow

    item.action = "acciones_trakt"

    return acciones_trakt(item)


##-------------------- MYANIMELIST SECTION ------------------------##
def top_mal(item):
    # For the main menus of movie tops / series / ova
    itemlist = []
    # data = httptools.downloadpage(item.url, cookies=False).data
    # data = re.sub(r"\n|\r|\t|&nbsp;", "", data)
    # data = re.sub(r"\s{2}", " ", data)

    patron = r'<td class="title al va-t word-break">\s*<a.*?href="([^"]+)"[^>]+>\s*<img.*?src="([^"]+).*?<div class="di-ib clearfix">.*?href.*?>([^<]+)<.*?<div class="information di-ib mt4">(.*?)<br>.*?(\d{4}|-).*?<span class="text.*?>(.*?)</span>'
    matches = match(item, patron=patron)
    for url, thumbnail, title, info, year, rating in matches.matches:
        new_item = item.clone(action="details_mal", url=url)
        info = info.strip()
        new_item.thumbnail = thumbnail.replace("r/50x70/", "") + "l.jpg"
        year = year.replace("-", "")
        if year:
            new_item.infoLabels["year"] = year
        new_item.title = typo(title.strip(), 'bold')
        if not year in title and year:
            new_item.title += typo(year,'_ () bold')
        if rating != "N/A":
            new_item.infoLabels["rating"] = float(rating)
            new_item.title += typo(rating, '_ [] color kod bold')
        # if not item.args:
        info = info.replace("(1 eps)", "").replace("TV ", "")
        if "Movie" in info or "Special" in info:
            new_item.contentType = "movie"
            new_item.args = "movie"
        else:
            new_item.contentType = "tvshow"
            new_item.args = "tv"
            new_item.show = title.strip()
        if '(' in info:
            new_item.title += ' (' + info.split("(", 1)[1]
        new_item.contentTitle = title.strip()
        itemlist.append(new_item)

    next_page = match(matches.data, patron=r'limit=(\d+)" class="link-blue-box next">').match
    if next_page:
        next_page = item.url.rsplit("=", 1)[0] + "=%s" % next_page
        itemlist.append(item.clone(title=typo(config.get_localized_string(30992), 'color kod bold'), url=next_page, thumbnail=thumb()))

    return itemlist


def details_mal(item):
    itemlist = []

    cookie_session = get_cookie_value()
    header_mal = {'Cookie': '%s search_sort_anime=score; search_view=tile; is_logged_in=1' % cookie_session}
    data = match(item.url, headers=header_mal, cookies=False).data

    item.contentTitle = item.contentTitle.replace("(TV)", "").replace("(Movie)", "")
    item.fanart = default_fan
    item.infoLabels["plot"] = ""

    title_mal = item.contentTitle
    if not item.args:
        args = match(data, patron=r'Type:</span>.*?>([^<]+)</a>').match.lower()
        item.tipo = args
        if args == "movie" or args == "special":
            item.args = "movie"
            item.contentType = "movie"
        else:
            item.args = "tv"
            item.contentType = "tvshow"

    if item.infoLabels['rating'] != "0.0":
        rating = item.infoLabels['rating']
    else:
        rating = match(data, patron=r'<span itemprop="ratingValue">(\d.\d+)</span>').match

    if not item.infoLabels["year"]:
        item.infoLabels["year"] = match(data, patron=r'>Aired:</span>.*?(\d{4})').match

    eng_title = match(data, patron=r'English:</span> ([^<]+)</div>').match.strip()
    item_tmdb = item.clone()

    if item.contentType == "movie":
        ob_tmdb = Tmdb(text_buscado=item_tmdb.contentTitle, year=item_tmdb.infoLabels['year'], tipo=item_tmdb.args, idioma_busqueda=langt)
        if not ob_tmdb.result and eng_title:
            ob_tmdb = Tmdb(text_buscado=eng_title, year=item_tmdb.infoLabels['year'], tipo=item_tmdb.args, idioma_busqueda=langt)
        if not ob_tmdb.result and ("Special (" in item.title or item.tipo == "special"):
            item_tmdb.args = "tv"
            search = {'url': 'search/tv', 'language': langt, 'query': item_tmdb.contentTitle, 'first_air_date': item_tmdb.infoLabels["year"]}
            ob_tmdb = Tmdb(discover=search, tipo=item_tmdb.args, idioma_busqueda=langt)
    else:
        search = {'url': 'search/tv', 'language': langt, 'query': eng_title, 'first_air_date': item_tmdb.infoLabels["year"]}
        ob_tmdb = Tmdb(discover=search, tipo=item_tmdb.args, idioma_busqueda=langt)
        if not ob_tmdb.result and eng_title:
            search['query'] = eng_title
            ob_tmdb = Tmdb(discover=search, tipo=item_tmdb.args, idioma_busqueda=langt)
        if not ob_tmdb.result and ("OVA (" in item.title or item.tipo == "ova"):
            item_tmdb.args = "movie"
            ob_tmdb = Tmdb(text_buscado=item_tmdb.contentTitle, tipo=item_tmdb.args, idioma_busqueda=langt, year=item_tmdb.infoLabels['year'])

    if ob_tmdb.result:
        ob_tmdb = Tmdb(id_Tmdb=ob_tmdb.get_id(), tipo=item_tmdb.args, idioma_busqueda=langt)
        item.infoLabels = ob_tmdb.get_infoLabels(item.infoLabels)

    # Myanimelist synopsis is concatenated with that of tmdb if any
    plot = match(data, patron=r'<span itemprop="description">(.*?)</span>').match
    plot = plot.replace("<br />", "\n").replace("<i>", "[I]").replace("</i>", "[/I]")
    plot = decodeHtmlentities(plot)
    if plot and (item.infoLabels['plot'] and item.infoLabels['plot'] != plot): item.infoLabels['plot'] += " (TMDB)\n\n" + plot + " (MYANIMELIST)"
    elif plot and not item.infoLabels['plot']: item.infoLabels['plot'] = plot

    if not item.infoLabels['duration']:
        try:
            horas, min1, min2 = match(data, patron=r'Duration:</span>\s*(?:(\d+) hr\. (\d+) min|(\d+) min)').match
            if horas: horas = int(horas) * 360
            else: horas = 0
            if not min1: min1 = min2
            item.infoLabels['duration'] = horas + (int(min1) * 60)
        except:
            pass

    # Myanimelist info overwrites tmdb info
    generos = match(data, patron=r'Genres:</span>(.*?)</div>').match
    if generos: item.infoLabels['genre'] = htmlclean(generos)

    item.infoLabels['rating'] = float(rating) if rating in item.infoLabels else 0
    votos = match(data, patron=r'<span itemprop="ratingCount">([^<]+)<').match
    item.infoLabels['votes'] = votos.replace(",", "")

    if item.infoLabels['fanart']: item.fanart = item.infoLabels['fanart']
    if item.infoLabels['thumbnail']: item.thumbnail = item.infoLabels['thumbnail']
    if not item.thumbnail: item.thumbnail = match(data, patron=r'/pics">.*?<img src="([^"]+)"').match.replace(".jpg", "l.jpg")
    if config.get_setting('new_search'):
        itemlist.append(item.clone(action="Search", channel='globalsearch', title=config.get_localized_string(70350) % title_mal, text=title_mal, mode=item.args.replace("tv", "tvshow"), contentType=item.args.replace("tv", "tvshow"), thumbnail=thumb('search'), folder=False))
        if item.infoLabels["title"] and title_mal != item.infoLabels["title"]:
            itemlist.append(item.clone(action="Search", channel='globalsearch', search_text=item.infoLabels["title"], title=config.get_localized_string(70351) % item.infoLabels["title"], mode=item.args.replace("tv", "tvshow"), contentType=item.args.replace("tv", "tvshow"), thumbnail=thumb('search'), folder=False))

        if eng_title and item.contentTitle != eng_title and title_mal != eng_title:
            itemlist.append(item.clone(action="Search", channel='globalsearch', search_text=eng_title, title=config.get_localized_string(70352) % eng_title, mode=item.args.replace("tv", "tvshow"), contentType=item.args.replace("tv", "tvshow"), thumbnail=thumb('search'), folder=False))
    else:
        itemlist.append(item.clone(action="new_search", channel='search', title=config.get_localized_string(70350) % title_mal, search_text=title_mal, args=item.args.replace("tv", "anime"), thumbnail=thumb('search')))
        if item.infoLabels["title"] and title_mal != item.infoLabels["title"]:
            itemlist.append(item.clone(action="new_search", channel='search', search_text=item.infoLabels["title"], title=config.get_localized_string(70351) % item.infoLabels["title"], thumbnail=thumb('search')))

        if eng_title and item.contentTitle != eng_title and title_mal != eng_title:
            itemlist.append(item.clone(action="new_search", channel='search', search_text=eng_title, title=config.get_localized_string(70352) % eng_title, thumbnail=thumb('search')))

    if item_tmdb.args == "tv" and ob_tmdb.result and "number_of_seasons" in item.infoLabels:
        itemlist.append(item.clone(action="info_seasons", title=config.get_localized_string(70067) % item.infoLabels["number_of_seasons"], thumbnail=thumb('info')))

    itemlist.append(item.clone(action="videos_mal", title=config.get_localized_string(70353), url=item.url + "/video", thumbnail=thumb('trailer')))

    # Option to see the info of characters and voiceovers / filming equipment
    if not "No characters or voice actors" in data and not "No staff for this anime" in data:
        itemlist.append(item.clone(action="staff_mal", title=config.get_localized_string(70354), url=item.url + "/characters", thumbnail=thumb('star')))
    if config.is_xbmc():
        item.contextual = True
    itemlist.append(item.clone(channel="trailertools", action="buscartrailer", title=config.get_localized_string(30162), thumbnail=thumb('trailer')))

    images = {}
    if ob_tmdb.result and ob_tmdb.result.get("images"):
        images['tmdb'] = ob_tmdb.result["images"]
    images['myanimelist'] = []
    itemlist.append(item.clone(action="imagenes", title=config.get_localized_string(70316), images=images, args="menu", thumbnail=thumb('image')))

    try:
        title_search = re.sub(r'[^0-9A-z]+', ' ', title_mal)
        post = "searching=%s&button=Search" % urllib.quote(title_search)
        data_music = httptools.downloadpage("http://www.freeanimemusic.org/song_search.php", post=post).data
        if not "NO MATCHES IN YOUR SEARCH" in data_music:
            itemlist.append(item.clone(action="musica_anime", title=config.get_localized_string(70317), post=post, thumbnail=thumb('music')))
    except:
        pass

    score = match(data, patron=r'id="myinfo_score".*?selected" value="(\d+)"').match
    if score != "0":
        score = "Valued:%s" % (score)
    else:
        score = "Vote"
    if item.login and "Add to My List</span>" in data and config.is_xbmc():
        itemlist.append(item.clone(title=config.get_localized_string(70321) % score, action="menu_mal", contentTitle=title_mal))
    elif item.login and config.is_xbmc():
        status = {'1': config.get_localized_string(70479), '2': config.get_localized_string(70480), '3': config.get_localized_string(70384), '4': config.get_localized_string(70385), '6': config.get_localized_string(70481)}
        estado = match(data, patron=r'myinfo_updateInfo".*?option selected="selected" value="(\d+)"').match
        try:
            estado = status[estado]
            itemlist.append(item.clone(title=config.get_localized_string(70322) % (estado, score), action="menu_mal", contentTitle=title_mal))
        except:
            pass

    token_auth = config.get_setting("token_trakt", "trakt")
    if token_auth and ob_tmdb.result:
        itemlist.append(item.clone(title=config.get_localized_string(70323), action="menu_trakt", thumbnail=thumb('setting_0')))

    # Prequels, sequels and alternative series are listed
    prequel = match(data, patron=r'Prequel:</td>(.*?)</td>').match
    if prequel:
        matches = match(prequel, patron=r'href="([^"]+)">(.*?)</a>').matches
        for url, title in matches:
            new_item = item.clone(args="")
            new_item.title = config.get_localized_string(70355) % title
            new_item.contentTitle = title
            new_item.url = "https://myanimelist.net" + url if not url.startswith('http') else url
            new_item.thumbnail = thumb('back')
            itemlist.append(new_item)

    sequel = match(data, patron=r'Sequel:</td>(.*?)</td>').match
    if sequel:
        matches = match(sequel, patron=r'href="([^"]+)">(.*?)</a>').matches
        for url, title in matches:
            new_item = item.clone(args="")
            new_item.title = config.get_localized_string(70356) % title
            new_item.contentTitle = title
            new_item.url = "https://myanimelist.net" + url if not url.startswith('http') else url
            new_item.thumbnail = thumb('next')
            itemlist.append(new_item)

    alt_version = match(data, patron=r'Alternative version:</td>(.*?)</td>').match
    if alt_version:
        matches = match(alt_version, patron=r'href="([^"]+)">(.*?)</a>').matches
        for url, title in matches:
            new_item = item.clone(args="")
            new_item.title = config.get_localized_string(70357) % title
            new_item.contentTitle = title
            new_item.url = "https://myanimelist.net" + url if not url.startswith('http') else url
            new_item.thumbnail = thumb('alternative')
            itemlist.append(new_item)

    if ob_tmdb.result:
        # itemlist.append(item.clone(title="", action="", infoLabels={}))
        if ob_tmdb.result.get("belongs_to_collection"):
            new_item = item.clone(action="list_tmdb", )
            saga = ob_tmdb.result["belongs_to_collection"]
            new_item.infoLabels["tmdb_id"] = saga["id"]
            if saga["poster_path"]:
                new_item.thumbnail = 'https://image.tmdb.org/t/p/original' + saga["poster_path"]
            if saga["backdrop_path"]:
                new_item.fanart = 'https://image.tmdb.org/t/p/original' + saga["backdrop_path"]
            new_item.search = {'url': 'collection/%s' % saga['id'], 'language': langt}
            new_item.title = config.get_localized_string(70327) % saga["name"]
            itemlist.append(new_item)

        itemlist.append(item.clone(title=config.get_localized_string(70358), action="list_tmdb", search={'url': '%s/%s/recommendations' % (item.args, item.infoLabels['tmdb_id']), 'language': langt, 'page': 1}, thumbnail=thumb('popular')))

    # Myanimelist recommendations and info search on anidb (fansubs in Spanish)
    itemlist.append(item.clone(title=config.get_localized_string(70359), action="reco_mal", thumbnail=thumb('popular')))
    anidb_link = match(data, patron=r'<a href="(http://anidb.info/perl-bin/animedb.pl\?show=anime&amp;aid=\d+)').match
    if anidb_link:
        anidb_link = anidb_link.replace("&amp;", "&") + "&showallag=1#grouplist"
        info_anidb(item, itemlist, anidb_link)

    return itemlist


def videos_mal(item):
    # Method for crunchyroll and trailer / promotional episodes
    itemlist = []

    data = match(item.url, cookies=False).data

    if not "No episode video" in data and not "http://www.hulu.com/" in data:
        patron = r'<a class="video-list di-ib po-r" href="([^"]+)".*?data-src="([^"]+)".*?<span class="title">([^<]+)<(.*?)<span class="episode-title" title="([^"]+)"'
        matches = match(data, patron=patron).matches
        for url, thumb, epi, info, title in matches:
            if "icon-pay" in info and "icon-banned-youtube" in thumb:
                continue
            url = "https://myanimelist.net" + url if not url.startswith('http') else url
            new_item = item.clone(url=url, thumbnail=thumb, action="play", )
            new_item.title = epi + " - " + title.strip()
            if "icon-pay" in info:
                new_item.title += " (Crunchyroll Premium)"
            itemlist.append(new_item)

        next_page = match(data, patron=r'<a href="([^"]+)" class="link-blue-box">More').match
        if next_page: itemlist.append(item.clone(title=config.get_localized_string(70361), url=next_page, ))
    if itemlist: itemlist.insert(0, item.clone(title=config.get_localized_string(70362), action="", ))

    patron = r'<a class="iframe.*?href="(https://www.youtube.*?)\?.*?data-src="([^"]+)".*?<span class="title">([^<]+)<'
    matches = match(data, patron=patron).matches
    if matches:
        itemlist.append(item.clone(title=config.get_localized_string(70363), action="", ))
        for url, thumb, title in matches:
            url = url.replace("embed/", "watch?v=")
            itemlist.append(item.clone(title=title, url=url, server="youtube", action="play", thumbnail=thumb, ))

    return itemlist


def reco_mal(item):
    # Myanimelist recommendations
    itemlist = []

    # patronBlock = r'<div class="anime-slide-block" id="anime_recommendation"(.*?)</ul></div>'
    patron = r'<div class="picSurround"><a href="([^"]+)"[^>]+><img src="[^"]+" data-src="([^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>([^<\(]+)(?:\([^<]+)?<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>([^<]+)'
    matches = match(item.url + "/userrecs", cookies=False, patron=patron).matches
    for url, thumb, title, plot in matches:
        new_item = item.clone(action="details_mal", fanart=default_fan, title=title, contentType="", args="", contentTitle=title)
        new_item.infoLabels["plot"] = htmlclean(plot)
        new_item.url = "https://myanimelist.net" + url if not url.startswith('http') else url
        new_item.thumbnail = thumb.replace("r/50x70/", "").replace(".jpg", "l.jpg")
        itemlist.append(new_item)
    return itemlist


def indices_mal(item):
    # Seasonal and gender indices
    itemlist = []
    url_base = ""
    if config.get_localized_string(30140) in item.title:
        matches = match("https://myanimelist.net/anime/season/archive", cookies=False, patron=r'<td>\s*<a href="([^"]+)">\s*(.*?)\s*</a>').matches
        for url, title in matches:
            year = title.rsplit(" ", 1)[1]
            thumbnail = item.thumbnail
            if int(year) >= 1968:
                thumbnail = url_base + year
            title = title.replace("Winter", config.get_localized_string(70364)).replace("Spring", config.get_localized_string(70365)).replace("Summer", config.get_localized_string(70366)).replace("Fall", config.get_localized_string(70367))
            itemlist.append(Item(channel=item.channel, action="season_mal", title=typo(title, 'bold'), url=url, thumbnail=thumbnail, info=True, fanart=thumbnail))
    else:
        patronBlock = r'Genres</div>(.*?)View More</a>'
        patron = r'<a href="([^"]+)" class="genre-name-link">(.*?)</a>'
        matches = match("https://myanimelist.net/anime.php", cookies=False, patronBlock=patronBlock, patron=patron).matches
        for url, title in matches:
            genero = title.split(" (", 1)[0]
            logger.debug(url_base, genero)
            thumbnail = url_base + genero.lower().replace(" ", "%20")
            if genero in ["Hentai", "Yaoi", "Yuri"] and not adult_mal:
                continue
            if not url.startswith('http'): url = "https://myanimelist.net" + url
            itemlist.append(Item(channel=item.channel, action="season_mal", title=typo(title, 'bold'), url=url, thumbnail=thumbnail, fanart=thumbnail))

    return thumb(itemlist, genre=True)


def season_mal(item):
    # Scraper for anime seasons
    itemlist = []

    cookie_session = get_cookie_value()
    header_mal = {'Cookie': '%s search_sort_anime=score; search_view=tile; is_logged_in=1' % cookie_session}
    data = match(item.url, headers=header_mal, cookies=False).data
    if item.info:
        blocks = match(data, patron=r'<div class="anime-header">([^<]+)</div>(.*?)</div>\s*</div></div></div>').matches
        for head_title, block in blocks:
            head_title = head_title.replace("(New)", config.get_localized_string(70369)).replace("(Continuing)", config.get_localized_string(70369))
            patron = r'<a href="([^"]+)" class="link-title">(.*?)</a>.*?<span>(\? ep|\d+ ep).*?<div class="genres-inner js-genre-inner">(.*?)</div>.*?<div class="image".*?src="(.*?).jpg.*?<span class="preline">(.*?)</span>.*?<div class="info">\s*(.*?)\s*-.*?(\d{4}).*?title="Score">\s*(N/A|\d\.\d+)'
            matches = match(block, patron=patron, debug=True).matches
            if matches:
                itemlist.append(Item(channel=item.channel, action="", title=head_title, ))
            for url, scrapedtitle, episode, genres, thumb, plot, tipo, year, score in matches:
                if ("Hentai" in genres or "Yaoi" in genres or "Yuri" in genres) and adult_mal: continue
                scrapedtitle = scrapedtitle.replace("(TV)", "").replace("(Movie)", "")
                if tipo == "Movie": title = scrapedtitle + "   (%s)" % year
                else: title = scrapedtitle + "   %ss (%s)" % (episode, year)
                infoLabels = {}
                if score != "N/A":
                    title += "  %s" % (score)
                    infoLabels["rating"] = float(score)
                infoLabels["plot"] = htmlclean(plot)
                infoLabels["year"] = year

                genres = match(genres, patron=r'title="([^"]+)"').matches
                infoLabels["genre"] = ", ".join(genres)
                tipo = tipo.lower()
                if tipo == "movie" or tipo == "special":
                    args = "movie"
                    contentType = "movie"
                else:
                    args = "tv"
                    contentType = "tvshow"
                thumb = thumb.replace("r/167x242/", "") + "l.jpg"
                itemlist.append(Item(channel=item.channel, action="details_mal", url=url, title=title, thumbnail=thumb, infoLabels=infoLabels, args=args, tipo=tipo, contentTitle=scrapedtitle, contentType=contentType, fanart=default_fan))
    else:
        patron = r'<a href="([^"]+)" class="link-title">([^<]+)</a>.*?<span>(\? ep|\d+ ep).*?<div class="genres-inner js-genre-inner">(.*?)</div>.*?<div class="image".*?src="([^"]+).*?<span class="preline">(.*?)</span>.*?<div class="info">\s*(.*?)\s*-.*?(\d{4}).*?title="Score">\s*(N/A|\d\.\d+)'
        matches = match(data, patron=patron).matches
        for url, scrapedtitle, epis, scrapedgenres, thumbnail, plot, tipo, year, score in matches:
            if ("Hentai" in scrapedgenres or "Yaoi" in scrapedgenres or "Yuri" in scrapedgenres) and not adult_mal:
                continue
            scrapedtitle = scrapedtitle.replace("(TV)", "").replace("(Movie)", "")
            if tipo == "Movie":
                title = scrapedtitle + " (%s)" % year
            else:
                title = scrapedtitle + " %ss (%s)" % (epis, year)
            infoLabels = {}
            if score != "N/A":
                title += "  %s" % (score)
                infoLabels["rating"] = float(score)
            infoLabels["plot"] = htmlclean(plot)
            infoLabels["year"] = year

            genres = match(scrapedgenres, patron=r'title="([^"]+)"').matches
            infoLabels["genre"] = ", ".join(genres)
            tipo = tipo.lower()
            if tipo == "movie" or tipo == "special":
                args = "movie"
                contentType = "movie"
            else:
                args = "tv"
                contentType = "tvshow"
            thumbnail = thumbnail.replace(".webp", ".jpg")
            itemlist.append(Item(channel=item.channel, action="details_mal", url=url, title=title,
                                 thumbnail=thumbnail, infoLabels=infoLabels, args=args, tipo=tipo,
                                 contentTitle=scrapedtitle, contentType=contentType,
                                 fanart=default_fan))
        next_page = match(data, patron=r'<a class="link current" href.*?href="([^"]+)"').match
        if next_page:
            itemlist.append(Item(channel=item.channel, action="season_mal", url=next_page,
                                 title=config.get_localized_string(70065), thumbnail=item.thumbnail))

    return itemlist


def staff_mal(item):
    # Benders / Filming Equipment
    itemlist = []
    data = match(item.url, cookies=False).data
    patron = r'(/character/[^"]+)".*?data-src="([^"]+)".*?href=.*?>([^<]+)<.*?<small>([^<]+)</small>(.*?)</table>'
    matches = match(data, patron=patron).matches
    if matches:
        # itemlist.append(item.clone(title=config.get_localized_string(70370), action="", ))
        for url, thumbnail, nombre, rol, voces in matches:
            url = "https://myanimelist.net%s" % url
            nombre = "%s [%s]" % (nombre, rol)
            thumbnail = thumbnail.replace("r/46x64/", "").replace("r/42x62/", "")
            itemlist.append(Item(channel=item.channel, action="detail_staff", url=url, thumbnail=thumbnail, fanart=default_fan, title=nombre, args="character"))
            patron_voces = r'(/people[^"]+)">([^<]+)<.*?<small>([^<]+)</small>.*?data-src="([^"]+)"'
            voces_match = match(voces, patron=patron_voces).matches
            for vurl, vnombre, vidioma, vthumb in voces_match:
                vurl = "https://myanimelist.net%s" % vurl
                vnombre = " - %s [%s]" % (vnombre, vidioma)
                vthumb = vthumb.replace("r/46x64/", "").replace("r/42x62/", "")
                itemlist.append(Item(channel=item.channel, action="detail_staff", url=vurl, thumbnail=vthumb, fanart=default_fan, title=vnombre))
    patronBlock = r'<a name="staff">(.*?)</table>'
    patron = r'(/people[^"]+)".*?data-src="([^"]+)".*?href=.*?>([^<]+)<.*?<small>([^<]+)</small>'
    matches = match(data, patronBlock=patronBlock, patron=patron).matches
    if matches:
        itemlist.append(item.clone(title="Staff", action="", ))
        for url, thumb, nombre, rol in matches:
            url = "https://myanimelist.net%s" % url
            nombre = " - %s [%s]" % (nombre, rol)
            thumb = thumb.replace("r/46x64/", "").replace("r/42x62/", "")
            itemlist.append(Item(channel=item.channel, action="detail_staff", url=url, thumbnail=thumb, fanart=default_fan, title=nombre))

    return itemlist


def detail_staff(item):
    itemlist = []
    data = match(item.url, cookies=False).data
    if item.args == "character" and not "No biography written" in data:
        bio = match(data,patron=r'<div class="normal_header">[^>]+>(.*?)<div class="normal_header"').match
        bio = bio.replace("<br />", "\n")
        bio = htmlclean(bio)
        if not "questionmark" in item.thumbnail:
            itemlist.append(Item(channel=item.channel, title=typo(config.get_localized_string(70316),'bold, bullet'), action="", thumbnail=thumb('info')))
            data_img = match(item.url + "/pictures", cookies=False).data
            matches = match(data_img, patron=r'rel="gallery-character"><img.*?src="([^"]+)"').matches
            for i, thumbnail in enumerate(matches):
                title =  typo(i + 1,'submenu')
                infoLabels = {'plot': bio}
                itemlist.append(Item(channel=item.channel, action="", title=title, infoLabels=infoLabels, thumbnail=thumbnail))

        matches = match(data, patron=r'(/anime[^"]+)"><img.*?src="([^"]+)".*?href.*?>(.*?)</a>').matches
        if matches:
            itemlist.append(Item(channel=item.channel, title=typo(config.get_localized_string(70373),'bold, bullet'), action="", thumbnail=thumb('info') ))
            for url, thumbnail, title in matches:
                url = "https://myanimelist.net%s" % url
                thumbnail = thumbnail.replace("r/23x32/", "").replace("r/42x62/", "")
                itemlist.append(Item(channel=item.channel, action="details_mal", url=url, thumbnail=thumbnail, fanart=default_fan, title= typo(title, 'submenu'), contentTitle=title))
    else:
        patron_bio = r'<?<div class="spaceit_pad">(.*?)</td>'
        bio = match(data, patron=patron_bio).match
        bio = htmlclean(bio.replace("</div>", "\n"))
        logger.debug(bio)
        infoLabels = {'plot': bio}
        if not "No voice acting roles" in data:
            itemlist.append(Item(channel=item.channel, title=typo(config.get_localized_string(70374),'bold bullet'), action="", thumbnail=item.thumbnail, infoLabels=infoLabels))
            patronBlock = r'Voice Acting Roles</div>(.*?)</table>'
            patron = r'(/anime[^"]+)"><img data-src="([^"]+)"[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>([^<]+)<[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>[^>]+>.*?(/character[^"]+)"[^>]*>([^<]+)<[^>]*>[^>]*>[^>]*>[^>]*>[^>]*>[^>]*>[^>]*><img data-src="([^"]+)"'
            matches = match(data, patronBlock=patronBlock, patron=patron).matches
            for url, thumbnail, title, url_p, personaje, thumb_p in matches:
                url = "https://myanimelist.net%s" % url
                url_p = "https://myanimelist.net%s" % url_p
                thumbnail = thumbnail.replace("r/46x64/", "")
                thumb_p = thumb_p.replace("r/46x64/", "")
                itemlist.append(Item(channel=item.channel, action="details_mal", url=url, thumbnail=thumbnail, title=typo(title, 'bold submenu'), contentTitle=title))
                itemlist.append(Item(channel=item.channel, action="detail_staff", url=url_p, thumbnail=thumb_p, title=typo(personaje,'_ submenu'), args="character"))

        if not "No staff positions" in data:
            itemlist.append(Item(channel=item.channel, title=typo(config.get_localized_string(70375),'bold bullet'), action="", thumbnail=item.thumbnail, infoLabels=infoLabels))
            patronBlock = r'Anime Staff Positions</div>(.*?)</table>'
            patron = r'(/anime[^"]+)"><img data-src="([^"]+)".*?href.*?>(.*?)</a>.*?<small>(.*?)</div>'
            matches = match(data, patronBlock=patronBlock, patron=patron).matches
            for url, thumbnails, title, rol in matches:
                url = "https://myanimelist.net%s" % url
                thumbnails = thumbnails.replace("r/46x64/", "").replace("r/84x124/", "")
                rol = htmlclean(rol)
                titulo = typo("%s [%s]" % (title, rol), 'submenu')
                itemlist.append(Item(channel=item.channel, action="details_mal", url=url, thumbnail=thumbnails, fanart=default_fan, title=titulo, contentTitle=title))

    return itemlist


def searching_mal(item):
    # Scraper for myanimelist searches
    itemlist = []

    cookie_session = get_cookie_value()
    header_mal = {'Cookie': '%s search_sort_anime=score; search_view=tile; is_logged_in=1' % cookie_session}
    data = match(item.url, headers=header_mal, cookies=False).data
    patron = r'<a class="hoverinfo_trigger" href="([^"]+)".*?(?:data-src|src)="([^"]+)".*?<div class="hoverinfo".*?href.*?><strong>([^<]+)<.*?<div class="pt4">(.*?)<.*?<td.*?>(.*?)</td>.*?<td.*?>(.*?)</td>.*?<td.*?>(.*?)</td>.*?<td.*?>(.*?)</td>'
    matches = match(data, patron=patron).matches
    for url, thumb, title, plot, tipo, epis, rating, date in matches:
        infolabels = {"mediatype": "tvshow"}
        contentType = "tvshow"
        args = "tv"
        title = title.strip()
        tipo = tipo.strip()
        rating = rating.strip()
        epis = epis.strip()
        infolabels["plot"] = htmlclean(plot.strip())
        thumb = thumb.replace("r/50x70/", "").replace(".jpg", "l.jpg")
        show = title
        contentitle = title
        try:
            year = date.strip().rsplit("-", 1)[1]
            if year.isdigit():
                if int(year) < 30:
                    year = "20%s" % year
                else:
                    year = "19%s" % year
                infolabels["year"] = year
                if not year in title:
                    title += "  (%s)" % year
        except:
            import traceback
            logger.error(traceback.format_exc())

        if tipo == "Movie" or tipo == "OVA":
            infolabels["mediatype"] = "movie"
            contentType = "movie"
            args = "movie"
            show = ""

        if epis and tipo != "Movie":
            title += "  %s eps" % epis
        if rating != "0.00" and rating != "N/A":
            infolabels["rating"] = float(rating)
            title += "  %s" % (rating)
        itemlist.append(Item(channel=item.channel, title=title, action="details_mal", url=url, show=show,
                             thumbnail=thumb, infoLabels=infolabels, contentTitle=contentitle,
                             contentType=contentType, tipo=tipo.lower(), args=args))

    if not "&show=" in item.url:
        next_page = item.url + "&show=50"
    else:
        pagina = int(item.url.rsplit("=", 1)[1])
        next_page = item.url.replace("&show=%s" % str(pagina), "&show=%s" % str(pagina + 50))

    check_page = next_page.replace("https://myanimelist.net/anime.php", "")
    if check_page in data:
        itemlist.append(item.clone(title=config.get_localized_string(70065), url=next_page, ))
    else:
        check_page = check_page.replace("[", "%5B").replace("]", "%5D")
        if check_page in data:
            itemlist.append(item.clone(title=config.get_localized_string(70065), url=next_page, ))

    return itemlist


def info_anidb(item, itemlist, url):
    # Extract info, score and fansubs on anidb
    data = match(url).data

    infoLabels = {'mediatype': item.contentType}
    plot = match(data, patron=r'itemprop="description">(.*?)</div>').match
    infoLabels["plot"] = htmlclean(plot)

    generos = match(data, patron=r'<div class="tag".*?<span class="tagname">(.*?)</span>').matches
    for i, genero in enumerate(generos):
        generos[i] = genero.capitalize()
    infoLabels["genre"] = ", ".join(generos)
    rating = match(data, patron=r'itemprop="ratingValue">(.*?)</span>').match
    try:
        infoLabels["rating"] = float(rating)
    except:
        pass
    infoLabels["votes"] = match(data, patron=r'itemprop="ratingCount">(.*?)</span>').match
    thumbnail = match(data, patron=r'<div class="image">.*?src="([^"]+)"').match
    if infoLabels:
        title = config.get_localized_string(70376) % (rating)
        if re.search(r'(?:subtitle|audio) | language: spanish"', data):
            title += config.get_localized_string(70377)
        itemlist.append(Item(channel=item.channel, title=title, infoLabels=infoLabels, action="", thumbnail=thumbnail))

    if re.search(r'(?:subtitle|audio) | language: spanish"', data):
        epi_total = match(data, patron=r'itemprop="numberOfEpisodes">([^<]+)</span>').match
        patron = r'<td class="name group">.*?title="([^"]+)">(.*?)</a>.*?>([^<]+)</a>.*?<td class="epno lastep">([^<]+)</td>.*?title="audio(.*?)</td>.*?class="source" title="([^"]+)"'
        matches = match(data, patron=patron).matches
        for fansub, abrev, estado, epis, lang, source in matches:
            if not "spanish" in lang:
                continue
            title = "    " + fansub
            if abrev != title:
                title += "  [%s]" % abrev
            estado = estado.replace("complete", config.get_localized_string(70378)).replace("finished", config.get_localized_string(70379)).replace("stalled", config.get_localized_string(70380)).replace("dropped", config.get_localized_string(70381))
            title += " (%s) %s/%s  [%s]" % (estado, epis, epi_total, source)
            itemlist.append(Item(channel=item.channel, title=title, infoLabels=infoLabels, action="", thumbnail=thumbnail))


def filter_mal(item):
    logger.debug()

    list_controls = []
    valores = {}
    dict_values = None
    # Default / saved values ​​are used
    saved_values = config.get_setting("default_filter_mal", item.channel)
    if saved_values:
        dict_values = saved_values

    list_controls.append({'id': 'keyword', 'label': config.get_localized_string(70465), 'enabled': True,
                          'type': 'text', 'default': '', 'visible': True})
    list_controls.append({'id': 'tipo', 'label': config.get_localized_string(70482), 'enabled': True,
                          'type': 'list', 'default': -1, 'visible': True})
    list_controls[1]['lvalues'] = [config.get_localized_string(70483), config.get_localized_string(70484), config.get_localized_string(60244), config.get_localized_string(70136), config.get_localized_string(70450)]
    valores["tipo"] = ['4', '2', '3', '1', '0']
    list_controls.append({'id': 'valoracion', 'label': config.get_localized_string(70473), 'enabled': True,
                          'type': 'list', 'default': -1, 'visible': True})
    list_controls[2]['lvalues'] = [config.get_localized_string(70486), config.get_localized_string(70487), config.get_localized_string(70488), config.get_localized_string(70489),
                                   config.get_localized_string(70490), config.get_localized_string(70491), config.get_localized_string(70492), config.get_localized_string(70493),
                                   config.get_localized_string(70494), config.get_localized_string(70495), config.get_localized_string(70450)]
    valores["valoracion"] = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '0']

    list_controls.append({'id': 'estado', 'label': config.get_localized_string(70485), 'enabled': True,
                          'type': 'list', 'default': -1, 'visible': True})
    list_controls[3]['lvalues'] = ['Por estrenar', config.get_localized_string(60264), config.get_localized_string(70379), config.get_localized_string(70450)]
    valores["estado"] = ['3', '1', '2', '0']

    try:
        data = httptools.downloadpage('https://myanimelist.net/anime.php', cookies=False).data

        patron = r'name="genre\[\]" type="checkbox" value="([^"]+)">.*?>([^<]+)<'
        generos = scrapertools.find_multiple_matches(data, patron)
        if generos:
            list_controls.append({'id': 'labelgenre', 'enabled': True, 'type': 'label', 'default': None, 'label': config.get_localized_string(70451), 'visible': True})
            for value, genre in generos:
                list_controls.append({'id': 'genre' + value, 'label': genre, 'enabled': True, 'type': 'bool', 'default': False, 'visible': True})
    except:
        pass

    list_controls.append({'id': 'espacio', 'label': '', 'enabled': False, 'type': 'label', 'default': None, 'visible': True})
    list_controls.append({'id': 'save', 'label': config.get_localized_string(70464), 'enabled': True, 'type': 'bool', 'default': False, 'visible': True})

    item.valores = valores
    return platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values, caption=config.get_localized_string(70320), item=item, callback='callback_mal')


def callback_mal(item, values):
    values_copy = values.copy()
    # Save the filter to be the one loaded by default
    if "save" in values and values["save"]:
        values_copy.pop("save")
        config.set_setting("default_filter_mal", values_copy, item.channel)

    genero_ids = []
    for v in values:
        if "genre" in v:
            if values[v]:
                genero_ids.append("genre[%s]=%s" % (len(genero_ids), v.replace('genre', '')))

    genero_ids = "&".join(genero_ids)
    query = values["keyword"].replace(" ", "%20")
    tipo = item.valores["tipo"][values["tipo"]]
    valoracion = item.valores["valoracion"][values["valoracion"]]
    estado = item.valores["estado"][values["estado"]]

    item.url = "https://myanimelist.net/anime.php?q=%s&type=%s&score=%s&status=%s" \
               "&p=0&r=0&sm=0&sd=0&sy=0&em=0&ed=0&ey=0&c[0]=a&c[1]=b&c[2]=c&c[3]=d&c[4]=f&gx=0" \
               % (query, tipo, valoracion, estado)
    if genero_ids:
        item.url += "&" + genero_ids

    item.action = "searching_mal"
    return searching_mal(item)


def musica_anime(item):
    # List available anime and songs similar to the anime title
    logger.debug()
    itemlist = []

    data = match("http://www.freeanimemusic.org/song_search.php", post=item.post).data
    patron = r"<span class='Estilo6'>(\d+).*?<span class='Estilo22'>([^<]+)<.*?<span class='Estilo22'>([^<]+)<.*?href='http://www.freeanimemusic.org/anime/([^/]+)/index.php\?var=(\d+)"
    matches = match(data, patron=patron).matches
    animes = {}
    action = ""
    if config.is_xbmc():
        action = "move"
    for number, song, anime, id_anime, id_song in matches:
        if not animes.get(anime):
            animes[anime] = []
            animes[anime].append(
                Item(channel=item.channel, action=action, title="[%s]" % (anime.capitalize()),
                     url="",
                     number="0", thumbnail=item.thumbnail, fanart=item.fanart))
        title = "%s - %s" % (number, song)
        animes[anime].append(
            Item(channel=item.channel, action="play", title=title, server="directo", url=id_anime, song=id_song,
                 number=number,
                 thumbnail=item.thumbnail, fanart=item.fanart, ))

    for k, v in sorted(animes.items()):
        v.sort(key=lambda x: (x.url, int(x.number)))
        for lt in v:
            if lt.action == "move":
                lt.args = len(v)
                lt.folder = False
            itemlist.append(lt)

    return itemlist


def login_mal(from_list=False):
    logger.debug()
    from core import httptools
    from base64 import b64decode as bdec

    try:
        user = config.get_setting("usuariomal", "tvmoviedb")
        password = config.get_setting("passmal", "tvmoviedb")
        generic = False
        if not user or not password:
            if not from_list:
                user = bdec("Y3VlbnRhdHZtb3ZpZWRi")
                password = bdec("dFlTakE3ekYzbng1")
                generic = True
            else:
                return False, config.get_localized_string(70393), user
        data = httptools.downloadpage("https://myanimelist.net/login.php?from=%2F").data
        if re.search(r'(?i)' + user, data) and not generic:
            return True, "", user
        token = match(data, patron=r"name='csrf_token' content='([^']+)'").match
        response = httptools.downloadpage("https://myanimelist.net/logout.php", post="csrf_token=%s" % token)
        post = "user_name=%s&password=%s&cookie=1&sublogin=Login&submit=1&csrf_token=%s" % (user, password, token)
        response = httptools.downloadpage("https://myanimelist.net/login.php?from=%2F", post=post)

        if not re.search(r'(?i)' + user, response.data):
            logger.error("Login failed")
            return False, config.get_localized_string(70330), user
        else:
            if generic:
                return False, config.get_localized_string(70393), user
            logger.debug("Correct login")
            return True, "", user
    except:
        import traceback
        logger.error(traceback.format_exc())
        return False, config.get_localized_string(70331) , ''


def cuenta_mal(item):
    # Myanimelist account menu
    itemlist = []
    login, message, user = login_mal(True)
    if not login:
        itemlist.append(item.clone(action="configuracion", title=message, ))
    else:
        itemlist.append(
            item.clone(action="items_mal", title=config.get_localized_string(70382), accion="lista_mal",
                       url="https://myanimelist.net/animelist/%s?status=1" % user, login=True))
        itemlist.append(item.clone(action="items_mal", title=config.get_localized_string(70383), accion="lista_mal",
                                   url="https://myanimelist.net/animelist/%s?status=2" % user, login=True))
        itemlist.append(item.clone(action="items_mal", title=config.get_localized_string(70384), accion="lista_mal",
                                   url="https://myanimelist.net/animelist/%s?status=3" % user, login=True))
        itemlist.append(item.clone(action="items_mal", title=config.get_localized_string(70385), accion="lista_mal",
                                   url="https://myanimelist.net/animelist/%s?status=4" % user, login=True))
        itemlist.append(item.clone(action="items_mal", title=config.get_localized_string(70386), accion="lista_mal",
                                   url="https://myanimelist.net/animelist/%s?status=6" % user, login=True))

    return itemlist


def items_mal(item):
    # Scraper for personal lists
    logger.debug()
    itemlist = []
    data = match(item.url).data

    data_items = match(data, patron=r'data-items="([^"]+)"').match.replace("&quot;", "'").replace("null", "None").replace("false", "False").replace("true", "True")
    data_items = eval(data_items)
    for d in data_items:
        if d["anime_airing_status"] == 1:
            title = "[E]"
        if d["anime_airing_status"] == 2:
            title = "[F]"
        else:
            title = "[P]"
        title += typo(" %s [%s/%s] (%s)" % (
        d["anime_title"], d["num_watched_episodes"], d["anime_num_episodes"], d["anime_media_type_string"]),'bold')
        title = title.replace("\\", "")
        contentTitle = d["anime_title"].replace("\\", "")
        thumbnail = d["anime_image_path"].replace("\\", "").replace("r/96x136/", "").replace(".jpg", "l.jpg")
        if d["anime_url"].startswith('http'): url= d["anime_url"].replace("\\", "")
        else: url = "https://myanimelist.net" + d["anime_url"].replace("\\", "")
        if d["score"] != 0:
            title += typo(" Punt:%s" % (d["score"]),'color kod bold')
        if title.count("(TV)") == 2:
            title = title.replace("] (TV)", "]")
        elif title.count("(Movie)") == 2:
            title = title.replace("] (Movie)", "]")
        tipo = "tvshow"
        args = "tv"
        if "Movie" in d["anime_media_type_string"]:
            tipo = "movie"
            args = "movie"
        itemlist.append(Item(channel=item.channel, action="details_mal", url=url, title=title, thumbnail=thumbnail,

                             contentTitle=contentTitle, contentType=tipo, args=args, login=True))

    if itemlist:
        itemlist.insert(0, Item(channel=item.channel, action="", title=config.get_localized_string(70387)))

    return itemlist


def menu_mal(item):
    # Options BAD account, add to list / vote
    itemlist = []

    data = match(item.url).data
    try:
        status = {'1': config.get_localized_string(70479), '2': config.get_localized_string(70480), '3': config.get_localized_string(70384), '4': config.get_localized_string(70385), '6': config.get_localized_string(70481)}
        button, estado =match(data, patron=r'myinfo_updateInfo"(.*?)>.*?option selected="selected" value="(\d+)"').match
        if "disabled" in button:
            title_estado = config.get_localized_string(70388)
            estado = "1"
        else:
            title_estado = typo(config.get_localized_string(70389) % (status[estado]), 'bold')
    except:
        title_estado = config.get_localized_string(70388)

    score = match(data, patron=r'id="myinfo_score".*?selected" value="(\d+)"').match
    if score != "0":
        title_estado += " (Punt:%s)" % score
    if "lista" in title_estado:
        item.lista = True

    itemlist.append(item.clone(title="Anime: %s%s" % (item.contentTitle, title_estado), action=""))
    status = {'1': config.get_localized_string(70479), '2': config.get_localized_string(70480), '3': config.get_localized_string(70384), '4': config.get_localized_string(70385), '6': config.get_localized_string(70481)}
    for key, value in status.items():
        if not value in title_estado:
            itemlist.append(
                item.clone(title=typo(config.get_localized_string(70391) % value, 'bold'), action="addlist_mal", value=key, estado=value))

    for i in range(10, 0, -1):
        if i != int(score):
            itemlist.append(item.clone(title=typo(config.get_localized_string(70392) % (i), 'bold'), action="addlist_mal", value=estado, estado=status[estado], score=i))
    return itemlist


def addlist_mal(item):
    data = match(item.url).data

    anime_id = match(data, patron=r'id="myinfo_anime_id" value="([^"]+)"').match
    if item.value == "2":
        vistos = match(data, patron=r'id="myinfo_watchedeps".*?<span id="curEps">(\d+)').match
    else:
        vistos = match(data, patron=r'id="myinfo_watchedeps".*?value="(\d+)"').match
    if not item.score:
        item.score = match(data, patron=r'id="myinfo_score".*?selected" value="(\d+)"').match
    token = match(data, patron=r"name='csrf_token' content='([^']+)'").match

    post = {'anime_id': int(anime_id), 'status': int(item.value), 'score': int(item.score),
            'num_watched_episodes': int(vistos), 'csrf_token': token}
    headers_mal = {'User-Agent': 'Mozilla/5.0', 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                   'Referer': item.url, 'X-Requested-With': 'XMLHttpRequest'}
    url = "https://myanimelist.net/ownlist/anime/add.json"
    if item.lista:
        url = "https://myanimelist.net/ownlist/anime/edit.json"
    # data = httptools.downloadpage(url, post=jsontools.dump(post), headers=headers_mal, replace_headers=True).data
    data = match(url, post=jsontools.dump(post), headers=headers_mal).data
    item.title = "En tu lista"
    if config.is_xbmc():
        import xbmc
        xbmc.executebuiltin("Container.Refresh")


def move(item):
    import xbmcgui, xbmc
    item_focus = str(item.args)
    wnd = xbmcgui.Window(xbmcgui.getCurrentWindowId())
    id = wnd.getFocusId()
    return xbmc.executebuiltin('Control.Move(' + str(id) + ',' + item_focus + ')')


def play(item):
    itemlist = []
    if not item.server:
        data = match(item.url).data
        if "Sorry, this video is not available to be embedded" in data:
            id_video = match(data, patron=r'<div class="video-embed.*?-(\d+)\&amp;aff').match
            crunchy = "https://www.crunchyroll.com/affiliate_iframeplayer?aff=af-12299-plwa&media_id=%s&video_format=106&video_quality=60&auto_play=0" % id_video
        else:
            crunchy = match(data, patron=r'<iframe src="([^"]+)"').match
        itemlist.append(item.clone(server="crunchyroll", url=crunchy))
    else:
        if item.server == "directo" and item.song:
            url = ""
            data_music = jsontools.load(match("http://www.musicaanime.org/scripts/resources/artists1.php").data)
            for child in data_music["data"]:
                if child["title"] == item.url.upper():
                    url = "http://www.musicaanime.org/aannmm11/%s/imagen%s.mp3" % (child["artist"], item.song.zfill(3))
                    break
            if url:
                itemlist.append(item.clone(url=url))
        else:
            itemlist.append(item)

    return itemlist


def get_cookie_value():
    cookies = filetools.join(config.get_data_path(), 'cookies.dat')
    cookiedata = filetools.read(cookies)
    malsess = match(cookiedata, patron=r"myanimelist.*?MALHLOGSESSID\s+([A-z0-9\+\=]+)").match
    cookievalue = "MALHLOGSESSID=" + malsess
    mal_id = match(cookiedata, patron=r"myanimelist.*?MALSESSIONID\s+([A-z0-9\+\=\-]+)").match
    if mal_id:
        cookievalue += "; MALSESSIONID=%s;" % mal_id

    return cookievalue