# -*- coding: utf-8 -*-
# ------------------------------------------------------------
# Common Library Tools
# ------------------------------------------------------------

#from builtins import str
# from specials import videolibrary
import sys
PY3 = False
if sys.version_info[0] >= 3: PY3 = True; unicode = str; unichr = chr; long = int

if PY3:
    from concurrent import futures
else:
    from concurrent_py2 import futures

import errno, math, traceback, re, os

from core import filetools, jsontools, scraper, scrapertools, support, db, httptools, tmdb
from core.item import InfoLabels, Item
from lib import generictools
from platformcode import config, logger, platformtools
from platformcode.autorenumber import RENUMBER
from core.videolibrarydb import videolibrarydb

FOLDER_MOVIES = config.get_setting("folder_movies")
FOLDER_TVSHOWS = config.get_setting("folder_tvshows")
VIDEOLIBRARY_PATH = config.get_videolibrary_path()
MOVIES_PATH = filetools.join(VIDEOLIBRARY_PATH, FOLDER_MOVIES)
TVSHOWS_PATH = filetools.join(VIDEOLIBRARY_PATH, FOLDER_TVSHOWS)

if not FOLDER_MOVIES or not FOLDER_TVSHOWS or not VIDEOLIBRARY_PATH or not filetools.exists(MOVIES_PATH) or not filetools.exists(TVSHOWS_PATH):
    config.verify_directories_created()

addon_name = "plugin://plugin.video.%s/" % config.PLUGIN_NAME

quality_order = ['4k', '2160p', '2160', '4k2160p', '4k2160', '4k 2160p', '4k 2160', '2k',
                 'fullhd', 'fullhd 1080', 'fullhd 1080p', 'full hd', 'full hd 1080', 'full hd 1080p', 'hd1080', 'hd1080p', 'hd 1080', 'hd 1080p', '1080', '1080p',
                 'hd', 'hd720', 'hd720p', 'hd 720', 'hd 720p', '720', '720p', 'hdtv',
                 'sd', '480p', '480', '360p', '360', '240p', '240']

video_extensions = ['3g2', '3gp', '3gp2', 'asf', 'avi', 'divx', 'flv', 'iso', 'm4v', 'mk2', 'mk3d', 'mka', 'mkv', 'mov', 'mp4', 'mp4a', 'mpeg', 'mpg', 'ogg', 'ogm', 'ogv', 'qt', 'ra', 'ram', 'rm', 'ts', 'vob', 'wav', 'webm', 'wma', 'wmv']
subtitle_extensions = ['srt', 'idx', 'sub', 'ssa', 'ass']
immage_extensions = ['jpg', 'png']


def read_nfo(path_nfo, item=None):
    """
    Method to read nfo files.
        Nfo files have the following structure: url_scraper | xml + item_json [url_scraper] and [xml] are optional, but only one of them must always exist.
    @param path_nfo: absolute path to nfo file
    @type path_nfo: str
    @param item: If this parameter is passed the returned item will be a copy of it with the values ​​of 'infoLabels', 'library_playcounts' and 'path' read from the nfo
    @type: Item
    @return: A tuple consisting of the header (head_nfo = 'url_scraper' | 'xml') and the object 'item_json'
    @rtype: tuple (str, Item)
    """
    head_nfo = ""
    it = None

    data = filetools.read(path_nfo)

    if data:
        head_nfo = data.splitlines()[0] + "\n"
        data = "\n".join(data.splitlines()[1:])

        it_nfo = Item().fromjson(data)
        if not it_nfo.library_playcounts:  # may be corrupted
            it_nfo.library_playcounts = {}

        if item:
            it = item.clone()
            it.infoLabels = it_nfo.infoLabels
            if 'library_playcounts' in it_nfo:
                it.library_playcounts = it_nfo.library_playcounts
            if it_nfo.path:
                it.path = it_nfo.path
        else:
            it = it_nfo

        if 'fanart' in it.infoLabels:
            it.fanart = it.infoLabels['fanart']

    return head_nfo, it


def set_base_name(item, _id):
    # set base_name for videolibrary
    logger.debug()
    if item.contentType == 'movie':
        if config.get_setting("original_title_folder", "videolibrary") and item.infoLabels['originaltitle']:
            base_name = item.infoLabels['originaltitle']
        else:
            base_name = item.contentTitle
    else:
        if config.get_setting("original_title_folder", "videolibrary") and item.infoLabels['originaltitle']:
            base_name = item.infoLabels['originaltitle']
        elif item.infoLabels['tvshowtitle']:
            base_name = item.infoLabels['tvshowtitle']
        elif item.infoLabels['title']:
            base_name = item.infoLabels['title']
        else:
            base_name = item.contentSerieName

    if not PY3:
        base_name = unicode(filetools.validate_path(base_name.replace('/', '-')), "utf8").encode("utf8")
    else:
        base_name = filetools.validate_path(base_name.replace('/', '-'))

    if config.get_setting("lowerize_title", "videolibrary"):
        base_name = base_name.lower()

    return '{} [{}]'.format(base_name, _id)


def save_movie(item, silent=False):
    """
    saves the item element in the movie library, with the values ​​it contains.
    @type item: item
    @param item: item to be saved.
    @rtype inserted: int
    @return: the number of elements inserted
    @rtype overwritten: int
    @return: the number of overwritten elements
    @rtype failed: int
    @return: the number of failed items or -1 if all failed
    """

    logger.debug()
    # logger.debug(item.tostring('\n'))
    inserted = 0
    overwritten = 0
    failed = 0
    path = ""

    # Put the correct title on your site so that scraper can locate it
    if not item.contentTitle:
        if item.fulltitle: item.contentTitle = item.fulltitle
        else: item.contentTitle = re.sub(r'\[\s*[^\]]+\]', '', item.title).strip()

    # If at this point we do not have a title, we leave
    if not item.contentTitle or not item.channel:
        logger.debug("contentTitle NOT FOUND")
        return 0, 0, -1, path  # Salimos sin guardar

    # At this point we can have:
    #  scraper_return = True: An item with infoLabels with the updated information of the movie
    #  scraper_return = False: An item without movie information (it has been canceled in the window)
    #  item.infoLabels['code'] == "" : The required IMDB identifier was not found to continue, we quit
    if not item.infoLabels['code']:
        logger.debug("NOT FOUND IN SCRAPER OR DO NOT HAVE code")
        return 0, 0, -1, path

    # Get ID from infoLabels
    _id = get_id(item)
    if not _id:
        logger.debug("NOT FOUND IN SCRAPER OR DO NOT HAVE code")
        return 0, 0, -1, path

    # get parameters from db
    try:
        moviedb = videolibrarydb['movie'].get(_id, {})
        movie_item = moviedb.get('item', Item())
        head_nfo = movie_item.head_nfo
        channels = moviedb.get('channels',{})
    except:
        logger.debug("The film cannot be added to the database")
        videolibrarydb.close()
        return 0, 0, -1, path

    # progress dialog
    if not silent: p_dialog = platformtools.dialog_progress_bg(config.get_localized_string(20000), config.get_localized_string(60062))

    base_name = set_base_name(item, _id)
    path = filetools.join(MOVIES_PATH, base_name)

    # check if path already exist
    if not filetools.exists(path):
        logger.debug("Creating movie directory:" + path)
        if not filetools.mkdir(path):
            logger.debug("Could not create directory")
            videolibrarydb.close()
            return 0, 0, -1, path
    # try:
    # set nfo and strm paths
    nfo_path = filetools.join(base_name, "{}.nfo".format(base_name))
    strm_path = filetools.join(base_name, "{}.strm".format(base_name))

    # check if nfo and strm file exist
    nfo_exists = filetools.exists(filetools.join(MOVIES_PATH, nfo_path))
    strm_exists = filetools.exists(filetools.join(MOVIES_PATH, strm_path))

    if not head_nfo:
        head_nfo = scraper.get_nfo(item)

    # get extra info from fanart tv
    # support.dbg()
    extra_info = get_fanart_tv(item)
    if not item.infoLabels.get('posters', []): item.infoLabels['posters'] = []
    item.infoLabels['posters'] += extra_info['poster']
    if not item.infoLabels.get('fanarts', []): item.infoLabels['fanarts'] = []
    item.infoLabels['fanarts'] += extra_info['fanart']
    if not item.infoLabels.get('clearlogos', []): item.infoLabels['clearlogos'] = []
    item.infoLabels['clearlogos'] += extra_info['clearlogo']
    if not item.infoLabels.get('cleararts', []): item.infoLabels['cleararts'] = []
    item.infoLabels['cleararts'] += extra_info['clearart']
    if not item.infoLabels.get('landscapes', []): item.infoLabels['landscapes'] = []
    item.infoLabels['landscapes'] += extra_info['landscape']
    if not item.infoLabels.get('banners', []): item.infoLabels['banners'] = []
    item.infoLabels['banners'] += extra_info['banner']
    if not item.infoLabels.get('discs', []): item.infoLabels['discs'] = []
    item.infoLabels['discs'] += extra_info['disc']

    if 'setid' in item.infoLabels:
        collection = videolibrarydb['collection'].get(item.infoLabels['setid'], None)
        if not collection:
            collection = Item(title=item.infoLabels['set'],
                                plot=item.infoLabels['setoverview'],
                                infoLabels={},
                                thumbnail=item.infoLabels.get('setposters')[0] if item.infoLabels.get('setposters') else item.thumbnail,
                                fanart=item.infoLabels.get('setfanarts')[0] if item.infoLabels.get('setfanarts') else item.fanart,
                                videolibrary_id = item.infoLabels['setid'],
                                set = item.infoLabels['setid'],
                                channel = "videolibrary",
                                action='list_movies')

        if not collection.infoLabels.get('posters') and item.infoLabels.get('setposters'):
            collection.infoLabels['posters'] = item.infoLabels['setposters']
        if not collection.infoLabels.get('fanarts') and item.infoLabels.get('fanarts'):
            collection.infoLabels['fanarts'] = item.infoLabels['setfanarts']
        if not collection.infoLabels.get('clearlogos') and extra_info.get('setclearlogo'):
            collection.infoLabels['clearlogos'] = extra_info['setclearlogo']
            collection.infoLabels['clearlogo'] = extra_info['setclearlogo'][0]
        if not collection.infoLabels.get('cleararts') and extra_info.get('setclearart'):
            collection.infoLabels['cleararts'] = extra_info['setclearart']
            collection.infoLabels['clearart'] = extra_info['setclearart'][0]
        if not collection.infoLabels.get('landscapes') and extra_info.get('setlandscape'):
            collection.infoLabels['landscapes'] = extra_info['setlandscape']
            collection.infoLabels['landscape'] = extra_info['setlandscape'][0]
        if not collection.infoLabels.get('banners') and extra_info.get('setbanner'):
            collection.infoLabels['banners'] = extra_info['setbanner']
            collection.infoLabels['banner'] = extra_info['setbanner'][0]
        if not collection.infoLabels.get('discs') and extra_info.get('setdisc'):
            collection.infoLabels['discs'] = extra_info['setdisc']
            collection.infoLabels['disc'] = extra_info['setdisc'][0]
        videolibrarydb['collection'][item.infoLabels['setid']] = collection

    # Make or update Videolibrary Movie Item
    movie_item.channel = "videolibrary"
    movie_item.action = 'findvideos'
    movie_item.infoLabels = item.infoLabels
    movie_item.infoLabels['playcount'] = 0
    if not movie_item.head_nfo: movie_item.head_nfo = head_nfo
    if not movie_item.title: movie_item.title = item.contentTitle
    if not movie_item.videolibrary_id: movie_item.videolibrary_id = _id
    if not movie_item.strm_path: movie_item.strm_path = strm_path
    if not movie_item.nfo_path: movie_item.nfo_path = nfo_path
    if not movie_item.base_name: movie_item.base_name = base_name
    if not movie_item.thumbnail: movie_item.thumbnail = item.infoLabels['thumbnail']
    if not movie_item.fanart: movie_item.fanart = item.infoLabels['fanart']
    if not movie_item.infoLabels['landscape'] and item.infoLabels['landscapes']: movie_item.infoLabels['landscape'] = item.infoLabels['landscapes'][0]
    if not movie_item.infoLabels['banner'] and item.infoLabels['banners']: movie_item.infoLabels['banner']= item.infoLabels['banners'][0]
    if not movie_item.infoLabels['clearart'] and item.infoLabels['cleararts']: movie_item.infoLabels['clearart'] = item.infoLabels['cleararts'][0]
    if not movie_item.infoLabels['clearlogo'] and item.infoLabels['clearlogos']: movie_item.infoLabels['clearlogo'] = item.infoLabels['clearlogos'][0]
    if not movie_item.infoLabels['disc'] and item.infoLabels['discs']: movie_item.infoLabels['disc'] = item.infoLabels['discs'][0]
    if not movie_item.playtime: movie_item.playtime = 0,
    if not movie_item.playcounts: movie_item.playcounts = 0,
    if not movie_item.prefered_lang: movie_item.prefered_lang = ''
    if not movie_item.lang_list: movie_item.lang_list = []
    # if not movie_item.info: movie_item.info = extra_info(_id)

    if not item.contentLanguage: item.contentLanguage = 'ITA'
    if not item.contentLanguage in movie_item.lang_list: movie_item.lang_list.append(item.contentLanguage)

    if len(movie_item.lang_list) > 1:
        movie_item.prefered_lang = movie_item.lang_list[platformtools.dialog_select(config.get_localized_string(70246), movie_item.lang_list)]
    else:
        movie_item.prefered_lang = movie_item.lang_list[0]

    # create nfo file if it does not exist
    # support.dbg()
    if not nfo_exists:
        # data = dicttoxml(movie_item)
        filetools.write(filetools.join(MOVIES_PATH, movie_item.nfo_path), head_nfo)

    # create strm file if it does not exist
    if not strm_exists:
        logger.debug("Creating .strm: " + strm_path)
        item_strm = Item(channel='videolibrary', action='play_from_library', strm_path=movie_item.strm_path, contentType='movie', contentTitle=item.contentTitle, videolibraryd_id=item.videolibrary_id)
        strm_exists = filetools.write(filetools.join(MOVIES_PATH, movie_item.strm_path), '{}?{}'.format(addon_name, item_strm.tourl()))

    # checks if the content already exists
    if videolibrarydb['movie'].get(_id, {}):
        logger.debug("The file exists. Is overwritten")
        overwritten += 1
    else:
        logger.debug("Creating .nfo: " + nfo_path)
        inserted += 1

    remove_host(item)
    # write on db
    if item.channel in channels and item.channel != 'download':
        channels_url = [u.url for u in channels[item.channel]]
        if item.url not in channels_url:
            channels[item.channel].append(item)
        else:
            del channels[item.channel][channels_url.index(item.url)]
            channels[item.channel].append(item)
    else:
        channels[item.channel] = [item]

    moviedb['item'] = movie_item
    moviedb['channels'] = channels

    videolibrarydb['movie'][_id] = moviedb
    # except:
    #     failed += 1

    videolibrarydb.close()


    # Only if movie_item and .strm exist we continue
    if movie_item and strm_exists:
        if not silent:
            p_dialog.update(100, item.contentTitle)
            p_dialog.close()
        # Update Kodi Library
        from platformcode.dbconverter import add_video
        add_video(movie_item)
        # if config.is_xbmc() and config.get_setting("videolibrary_kodi") and not silent and inserted:
            # from platformcode.xbmc_videolibrary import update
            # update(MOVIES_PATH)
        return inserted, overwritten, failed, path

    # If we get to this point it is because something has gone wrong
    logger.error("Could not save %s in the video library" % item.contentTitle)
    if not silent:
        p_dialog.update(100, item.contentTitle)
        p_dialog.close()
    return 0, 0, -1, path

def update_renumber_options(item):
    from core import jsontools

    filename = filetools.join(config.get_data_path(), "settings_channels", item.channel + '_data.json')
    if filetools.isfile(filename):
        json_file = jsontools.load(filetools.read(filename))
        json = json_file.get(RENUMBER,{}).get(item.fulltitle,{})
    if json:
        logger.debug('UPDATED=\n' + item.fulltitle)
        item.renumber = json
    return item

def add_renumber_options(item):
    from core import jsontools
    # from core.support import dbg;dbg()
    ret = None
    filename = filetools.join(config.get_data_path(), "settings_channels", item.channel + '_data.json')
    json_file = jsontools.load(filetools.read(filename))
    if RENUMBER in json_file:
        json = json_file[RENUMBER]
        if item.fulltitle in json:
            ret = json[item.fulltitle]
    return ret

def check_renumber_options(item):
    from platformcode.autorenumber import load, write
    for key in item.channel_prefs:
        if RENUMBER in item.channel_prefs[key]:
            item.channel = key
            json = load(item)
            if not json or item.fulltitle not in json:
                json[item.fulltitle] = item.channel_prefs[key][RENUMBER]
                write(item, json)

    # head_nfo, tvshow_item = read_nfo(filetools.join(item.context[0]['nfo']))
    # if tvshow_item['channel_prefs'][item.fullti]


def save_tvshow(item, episodelist, silent=False):
    """
    stores in the series library the series with all the chapters included in the episodelist
    @type item: item
    @param item: item that represents the series to save
    @type episodelist: list
    @param episodelist: list of items that represent the episodes to be saved.
    @rtype inserted: int
    @return: the number of episodes inserted
    @rtype overwritten: int
    @return: the number of overwritten episodes
    @rtype failed: int
    @return: the number of failed episodes or -1 if the entire series has failed
    @rtype path: str
    @return: serial directory
    """

    inserted = 0
    overwritten = 0
    failed = 0
    path = ""
    # support.dbg()
    # If at this point we do not have a title or code, we leave
    if not (item.contentSerieName or item.infoLabels['code']) or not item.channel:
        logger.debug("NOT FOUND contentSerieName or code")
        return 0, 0, -1, path  # Salimos sin guardar

    contentTypeBackup = item.contentType  # Fix errors in some channels
    item.contentType = contentTypeBackup  # Fix errors in some channels

    # At this point we can have:
    #  scraper_return = True: An item with infoLabels with the updated information of the series
    #  scraper_return = False: An item without movie information (it has been canceled in the window)
    #  item.infoLabels['code'] == "" :T he required IMDB identifier was not found to continue, we quit
    if not item.infoLabels['code']:
        logger.debug("NOT FOUND IN SCRAPER OR DO NOT HAVE code")
        return 0, 0, -1, path

    # Get ID from infoLabels
    _id = get_id(item)
    if not _id:
        logger.debug("NOT FOUND IN SCRAPER OR DO NOT HAVE code")
        return 0, 0, -1, path

    # get parameters from db
    try:
        tvshowdb = videolibrarydb['tvshow'].get(_id, {})
        tvshow_item = tvshowdb.get('item', Item())
        head_nfo = tvshow_item.head_nfo
        channels = tvshowdb.get('channels',{})

    except:
        logger.debug("The tv show cannot be added to the database")
        videolibrarydb.close()
        return 0, 0, -1, path

    # set base name
    base_name = set_base_name(item, _id)
    path = filetools.join(TVSHOWS_PATH, base_name)

    # check if path already exist
    if not filetools.exists(path):
        logger.debug("Creating tv show directory:" + path)
        if not filetools.mkdir(path):
            logger.debug("Could not create directory")
            return 0, 0, -1, path

    nfo_path = filetools.join(base_name, "tvshow.nfo")
    nfo_exists = filetools.exists(filetools.join(TVSHOWS_PATH, nfo_path))

    # get parameters
    if not item.head_nfo:
        head_nfo = scraper.get_nfo(item)
    if not head_nfo: return 0, 0, -1, ''
    # support.dbg()
    extra_info = get_fanart_tv(item)
    if not item.infoLabels.get('posters'): item.infoLabels['posters'] = []
    item.infoLabels['posters'] += extra_info['poster'].get('all',[])
    if not item.infoLabels.get('fanarts'): item.infoLabels['fanarts'] = []
    item.infoLabels['fanarts'] += extra_info['fanart']
    if not item.infoLabels.get('clearlogos'): item.infoLabels['clearlogos'] = []
    item.infoLabels['clearlogos'] += extra_info['clearlogo']
    if not item.infoLabels.get('cleararts'): item.infoLabels['cleararts'] = []
    item.infoLabels['cleararts'] += extra_info['clearart']
    if not item.infoLabels.get('landscapes'): item.infoLabels['landscapes'] = []
    item.infoLabels['landscapes'] += extra_info['landscape'].get('all',[])
    if not item.infoLabels.get('banners'): item.infoLabels['banners'] = []
    item.infoLabels['banners'] += extra_info['banner'].get('all',[])


    item.infoLabels['mediatype'] = 'tvshow'
    item.contentType = 'tvshow'
    item.infoLabels['title'] = item.contentSerieName
    tvshow_item.infoLabels = item.infoLabels
    if not tvshow_item.infoLabels.get('playcount'): tvshow_item.infoLabels['playcount'] = 0
    tvshow_item.channel = 'videolibrary'
    tvshow_item.action = 'get_seasons'
    tvshow_item.nfo_path = nfo_path
    if not tvshow_item.head_nfo: tvshow_item.head_nfo = head_nfo
    if not tvshow_item.title: tvshow_item.title = item.contentSerieName
    if not tvshow_item.videolibrary_id: tvshow_item.videolibrary_id = _id
    if not tvshow_item.thumbnail: tvshow_item.thumbnail = item.infoLabels['thumbnail']
    if not tvshow_item.fanart: tvshow_item.fanart = item.infoLabels['fanart']
    if not tvshow_item.landscape: tvshow_item.landscape = item.infoLabels['landscapes'][0] if item.infoLabels['landscapes'] else item.infoLabels['fanart']
    if not tvshow_item.banner and item.infoLabels['banners']: tvshow_item.clearart = item.infoLabels['banners'][0]
    if not tvshow_item.clearart and item.infoLabels['cleararts']: tvshow_item.clearart = item.infoLabels['cleararts'][0]
    if not tvshow_item.clearlogo and item.infoLabels['clearlogos']: tvshow_item.clearlogo = item.infoLabels['clearlogos'][0]
    if not tvshow_item.base_name: tvshow_item.base_name = base_name
    if tvshow_item.active == '': tvshow_item.active = True
    if not tvshow_item.prefered_lang: tvshow_item.prefered_lang = ''
    if not tvshow_item.lang_list: tvshow_item.lang_list = []

    remove_host(item)
    item.renumber = add_renumber_options(item)
    # write on db
    if item.channel in channels and item.channel != 'download':
        channels_url = [u.url for u in channels[item.channel]]
        if item.url not in channels_url:
            channels[item.channel].append(item)
        else:
            del channels[item.channel][channels_url.index(item.url)]
            channels[item.channel].append(item)
    else:
        channels[item.channel] = [item]
    tvshowdb['item'] = tvshow_item
    tvshowdb['channels'] = channels
    videolibrarydb['tvshow'][_id] = tvshowdb

    if not nfo_exists:
        filetools.write(filetools.join(TVSHOWS_PATH, tvshow_item.nfo_path), head_nfo + ', kod:' + _id)
    # support.dbg()
    if not episodelist:
        # The episode list is empty
        return 0, 0, -1, path

    # Save the episodes
    logger.debug()
    inserted, overwritten, failed = save_episodes(tvshow_item, episodelist, extra_info, item.host, silent=silent)
    videolibrarydb.close()
    # if config.is_xbmc() and config.get_setting("videolibrary_kodi") and not silent and inserted:
    #     # from platformcode.dbconverter import add_video
    #     # add_video(tvshow_item)
    #     from platformcode.xbmc_videolibrary import update
    #     update(TVSHOWS_PATH, tvshow_item.basename)

    return inserted, overwritten, failed, path


def save_episodes(item, episodelist, extra_info, host, silent=False):
    """
    saves in the indicated path all the chapters included in the episodelist
    @type Item: str
    @param path: path to save the episodes
    @type episodelist: list
    @param episodelist: list of items that represent the episodes to be saved.
    @type serie: item
    @param serie: series from which to save the episodes
    @type silent: bool
    @param silent: sets whether notification is displayed
    @param overwrite: allows to overwrite existing files
    @type overwrite: bool
    @rtype inserted: int
    @return: the number of episodes inserted
    @rtype overwritten: int
    @return: the number of overwritten episodes
    @rtype failed: int
    @return: the number of failed episodes
    """
    # support.dbg()
    def save_episode(item, episodes, e):
        inserted = 0
        overwritten = 0
        failed = 0
        episode = None
        season_episode = None

        season_episode = scrapertools.get_season_and_episode(e.title)


        if season_episode:
            strm_path = filetools.join(item.base_name, "{}.strm".format(season_episode))

            e.contentSeason = int(season_episode.split('x')[0])
            e.contentEpisodeNumber = int(season_episode.split('x')[1])
            if item.infoLabels.get('imdb_id'): e.infoLabels['imdb_id'] = item.infoLabels['imdb_id']
            if item.infoLabels.get('tmdb_id'): e.infoLabels['tmdb_id'] = item.infoLabels['tmdb_id']
            if item.infoLabels.get('tvdb_id'): e.infoLabels['tvdb_id'] = item.infoLabels['tvdb_id']

            tmdb.set_infoLabels_item(e)
            if not e.infoLabels.get('playcount'): e.infoLabels['playcount'] = 0
            head_nfo = scraper.get_nfo(e)

            episode_item = Item(action='findvideos',
                                channel='videolibrary',
                                strm_path=strm_path,
                                contentSeason = e.contentSeason,
                                contentEpisodeNumber = e.contentEpisodeNumber,
                                contentType = e.contentType,
                                infoLabels = e.infoLabels,
                                head_nfo = head_nfo,
                                videolibrary_id = item.videolibrary_id,
                                thumbnail = e.infoLabels.get('poster_path') if e.infoLabels.get('poster_path') else item.thumbnail,
                                fanart = e.infoLabels.get('poster_path') if e.infoLabels.get('poster_path') else item.fanart,
                                title = '{}. {}'.format(e.contentEpisodeNumber, e.infoLabels['title']))

            episode = episodes.get(season_episode, {})

            try:
                if not episode:
                    inserted += 1
                    episode['item'] = episode_item

                # else:
                epchannels = episode.get('channels',{})

                if e.url.startswith(host):
                    remove_host(e)

                e.contentTitle = e.infoLabels['title']
                contentType = e.contentType
                e.infoLabels = {}
                e.contentType = contentType

                if e.channel in epchannels and e.channel != 'download':
                    channels_url = [u.url for u in epchannels[e.channel]]
                    if e.url not in channels_url:
                        epchannels[e.channel].append(e)
                        overwritten += 1
                    else:
                        del epchannels[e.channel][channels_url.index(e.url)]
                        epchannels[e.channel].append(e)
                        overwritten += 1
                else:
                    epchannels[e.channel] = [e]
                    overwritten += 1

                episode['channels'] = epchannels

                if not filetools.exists(filetools.join(TVSHOWS_PATH, strm_path)):
                    logger.debug("Creating .strm: " + strm_path)
                    item_strm = Item(channel='videolibrary', action='play_from_library', strm_path=strm_path, contentType='episode', videolibraryd_id=episode_item.videolibrary_id, contentSeason = episode_item.contentSeason, contentEpisodeNumber = episode_item.contentEpisodeNumber,)
                    filetools.write(filetools.join(TVSHOWS_PATH, strm_path), '{}?{}'.format(addon_name, item_strm.tourl()))
                # if not filetools.exists(filetools.join(TVSHOWS_PATH, nfo_path)):
                #     filetools.write(filetools.join(TVSHOWS_PATH, nfo_path), head_nfo)
            except:
                logger.error(traceback.format_exc())
                failed += 1
        return item, episode, season_episode, e.contentLanguage, inserted, overwritten, failed

    def save_season(item, seasons, s):
        tmdb_info = tmdb.Tmdb(id_Tmdb = item.infoLabels['tmdb_id'], search_type='tv')
        seasoninfo = tmdb.get_season_dic(tmdb_info.get_season(s))
        infoLabels = {}

        if seasoninfo.get('season_posters'): infoLabels['posters'] = seasoninfo.get('season_posters') + extra_info['poster'].get(str(s), [])
        if seasoninfo.get('season_fanarts'): infoLabels['fanarts'] = seasoninfo.get('season_fanarts') + extra_info['fanart'].get(str(s), [])
        if seasoninfo.get('season_trailer'): infoLabels['trailer'] = seasoninfo.get('season_trailer')
        infoLabels['landscapes'] = extra_info['landscape'].get(str(s), [])
        infoLabels['banners'] = extra_info['banner'].get(str(s), [])
        infoLabels['clearlogos'] = item.infoLabels.get('clearlogos', [])
        infoLabels['cleararts'] = item.infoLabels.get('cleararts', [])
        if s in seasons: infoLabels['playcount'] = seasons[s].infoLabels.get('playcount', 0)

        season_item = Item(action="get_episodes",
                            channel='videolibrary',
                            title=seasoninfo.get('season_title'),
                            thumbnail = seasoninfo.get('season_poster') if seasoninfo.get('season_poster') else item.thumbnail,
                            fanart = item.fanart,
                            plot = seasoninfo.get('season_plot') if seasoninfo.get('season_plot') else item.infoLabels.get('plot'),
                            contentType = 'season',
                            infoLabels = infoLabels,
                            contentSeason = s,
                            videolibrary_id = item.videolibrary_id,
                            playcount=0)

        if infoLabels['clearlogos']: season_item.clearlogo = infoLabels['clearlogos'][0]
        if infoLabels['cleararts']: season_item.clearart = infoLabels['cleararts'][0]
        if infoLabels['landscapes']: season_item.landscape = infoLabels['landscapes'][0]
        if infoLabels['banners']: season_item.banner = infoLabels['banners'][0]

        return s, season_item

    logger.debug()

    # from core import tmdb
    # No episode list, nothing to save
    if not len(episodelist):
        logger.debug("There is no episode list, we go out without creating strm")
        return 0, 0, 0

    # Silent is to show no progress (for service)
    if not silent:
        # progress dialog
        p_dialog = platformtools.dialog_progress_bg(config.get_localized_string(60064) ,'')

    inserted = 0
    overwritten = 0
    failed = 0
    current_seasons = []
    seasons = videolibrarydb['season'].get(item.videolibrary_id, {})
    episodes = videolibrarydb['episode'].get(item.videolibrary_id, {})
    videolibrarydb.close()

    try: t = float(100) / len(episodelist)
    except: t = 0

    # support.dbg()
    # for i, e in enumerate(episodelist):
    #     item, episode, season_episode, lang, I, O, F = save_episode(item, episodes, e)
    #     inserted += I
    #     overwritten += O
    #     failed += F
    #     if episode:
    #         episodes[season_episode] = episode
    #         e = episode['item']
    #         if not e.contentSeason in current_seasons: current_seasons.append(e.contentSeason)
    #         if not lang: lang = item.contentLanguage if item.contentLanguage else 'ITA'
    #         if not lang in item.lang_list: item.lang_list.append(lang)
    #         if not silent:
    #             p_dialog.update(int(math.ceil(i * t)), message=e.title)

    i = 0
    with futures.ThreadPoolExecutor() as executor:
        itlist = [executor.submit(save_episode, item, episodes, e) for e in episodelist]
        for res in futures.as_completed(itlist):
            if res.result():
                item, episode, season_episode, lang, I, O, F = res.result()
                inserted += I
                overwritten += O
                failed += F
                if episode:
                    episodes[season_episode] = episode
                    e = episode['item']
                    if not e.contentSeason in current_seasons: current_seasons.append(e.contentSeason)
                    if not lang: lang = item.contentLanguage if item.contentLanguage else 'ITA'
                    if not lang in item.lang_list: item.lang_list.append(lang)
                    if not silent:
                        i += 1
                        p_dialog.update(int(math.ceil(i * t)), message=e.title)

    with futures.ThreadPoolExecutor() as executor:
        itlist = [executor.submit(save_season, item, seasons, s) for s in current_seasons]
        for res in futures.as_completed(itlist):
            if res.result():
                s, season_item = res.result()
                seasons[s] = season_item

    if not silent:
        if len(item.lang_list) > 1:
            item.prefered_lang = item.lang_list[platformtools.dialog_select(config.get_localized_string(70246), item.lang_list)]
        else:
            item.prefered_lang = item.lang_list[0]
        tvshowdb = videolibrarydb['tvshow'][item.videolibrary_id]
        tvshowdb['item'] = item
        videolibrarydb['tvshow'][item.videolibrary_id] = tvshowdb
        videolibrarydb.close()

    videolibrarydb['episode'][item.videolibrary_id] = episodes
    videolibrarydb['season'][item.videolibrary_id] = seasons

    videolibrarydb.close()
    if not silent:
        p_dialog.close()

    return inserted, overwritten, failed



def config_local_episodes_path(path, item, silent=False):
    logger.debug(item)
    from platformcode.xbmc_videolibrary import search_local_path
    local_episodes_path=search_local_path(item)
    if not local_episodes_path:
        title = item.contentSerieName if item.contentSerieName else item.fulltitle
        if not silent:
            silent = platformtools.dialog_yesno(config.get_localized_string(30131), config.get_localized_string(80044) % title)
        if silent:
            if config.is_xbmc() and not config.get_setting("videolibrary_kodi"):
                platformtools.dialog_ok(config.get_localized_string(30131), config.get_localized_string(80043))
            local_episodes_path = platformtools.dialog_browse(0, config.get_localized_string(80046))
            if local_episodes_path == '':
                logger.debug("User has canceled the dialog")
                return -2, local_episodes_path
            elif path in local_episodes_path:
                platformtools.dialog_ok(config.get_localized_string(30131), config.get_localized_string(80045))
                logger.debug("Selected folder is the same of the TV show one")
                return -2, local_episodes_path

    if local_episodes_path:
        # import artwork
        artwork_extensions = ['.jpg', '.jpeg', '.png']
        files = filetools.listdir(local_episodes_path)
        for file in files:
            if os.path.splitext(file)[1] in artwork_extensions:
                filetools.copy(filetools.join(local_episodes_path, file), filetools.join(path, file))

    return 0, local_episodes_path


def process_local_episodes(local_episodes_path, path):
    logger.debug()

    sub_extensions = ['.srt', '.sub', '.sbv', '.ass', '.idx', '.ssa', '.smi']
    artwork_extensions = ['.jpg', '.jpeg', '.png']
    extensions = sub_extensions + artwork_extensions

    local_episodes_list = []
    files_list = []
    for root, folders, files in filetools.walk(local_episodes_path):
        for file in files:
            if os.path.splitext(file)[1] in extensions:
                continue
            season_episode = scrapertools.get_season_and_episode(file)
            if season_episode == "":
                continue
            local_episodes_list.append(season_episode)
            files_list.append(file)

    nfo_path = filetools.join(path, "tvshow.nfo")
    head_nfo, item_nfo = read_nfo(nfo_path)

    # if a local episode has been added, overwrites the strm
    for season_episode, file in zip(local_episodes_list, files_list):
        if not season_episode in item_nfo.local_episodes_list:
            filetools.write(filetools.join(path, season_episode + '.strm'), filetools.join(root, file))

    # if a local episode has been removed, deletes the strm
    for season_episode in set(item_nfo.local_episodes_list).difference(local_episodes_list):
        filetools.remove(filetools.join(path, season_episode + '.strm'))

    # updates the local episodes path and list in the nfo
    if not local_episodes_list:
        item_nfo.local_episodes_path = ''
    item_nfo.local_episodes_list = sorted(set(local_episodes_list))

    filetools.write(nfo_path, head_nfo + item_nfo.tojson())


def get_local_content(path):
    logger.debug()

    local_episodelist = []
    for root, folders, files in filetools.walk(path):
        for file in files:
            season_episode = scrapertools.get_season_and_episode(file)
            if season_episode == "" or filetools.exists(filetools.join(path, "%s.strm" % season_episode)):
                continue
            local_episodelist.append(season_episode)
    local_episodelist = sorted(set(local_episodelist))

    return local_episodelist


def add_movie(item):
    """
        Keep a movie at the movie library. The movie can be a link within a channel or a previously downloaded video.

        To add locally downloaded episodes, the item must have exclusively:
            - contentTitle: title of the movie
            - title: title to show next to the list of links -findvideos- ("Play local HD video")
            - infoLabels ["tmdb_id"] o infoLabels ["imdb_id"]
            - contentType == "movie"
            - channel = "downloads"
            - url: local path to the video

        @type item: item
        @param item: item to be saved.
    """
    logger.debug()
    from platformcode.launcher import set_search_temp; set_search_temp(item)

    # To disambiguate titles, TMDB is caused to ask for the really desired title
    # The user can select the title among those offered on the first screen
    # or you can cancel and enter a new title on the second screen
    # If you do it in "Enter another name", TMDB will automatically search for the new title
    # If you do it in "Complete Information", it partially changes to the new title, but does not search TMDB. We have to do it
    # If the second screen is canceled, the variable "scraper_return" will be False. The user does not want to continue
    item = generictools.update_title(item) # We call the method that updates the title with tmdb.find_and_set_infoLabels
    #if item.tmdb_stat:
    #    del item.tmdb_stat          # We clean the status so that it is not recorded in the Video Library
    if item:
        new_item = item.clone(action="findvideos")
        inserted, overwritten, failed, path = save_movie(new_item)

        if failed == 0:
            platformtools.dialog_notification(config.get_localized_string(30131),
                                    config.get_localized_string(30135) % new_item.contentTitle)  # 'has been added to the video library'
        else:
            filetools.rmdirtree(path)
            platformtools.dialog_ok(config.get_localized_string(30131),
                                    config.get_localized_string(60066) % new_item.contentTitle)  # "ERROR, the movie has NOT been added to the video library")


def add_tvshow(item, channel=None):
    """
        Save content in the series library. This content can be one of these two:
            - The series with all the chapters included in the episodelist.
            - A single chapter previously downloaded locally.

        To add locally downloaded episodes, the item must have exclusively:
            - contentSerieName (or show): Title of the series
            - contentTitle: title of the episode to extract season_and_episode ("1x01 Pilot")
            - title: title to show next to the list of links -findvideos- ("Play local video")
            - infoLabels ["tmdb_id"] o infoLabels ["imdb_id"]
            - contentType != "movie"
            - channel = "downloads"
            - url: local path to the video

        @type item: item
        @param item: item that represents the series to save
        @type channel: modulo
        @param channel: channel from which the series will be saved. By default, item.from_channel or item.channel will be imported.

    """
    logger.debug("show=#" + item.show + "#")
    from platformcode.launcher import set_search_temp; set_search_temp(item)

    if item.channel == "downloads":
        itemlist = [item.clone()]

    else:
        # This mark is because the item has something else apart in the "extra" attribute
        # item.action = item.extra if item.extra else item.action
        if isinstance(item.extra, str) and "###" in item.extra:
            item.action = item.extra.split("###")[0]
            item.extra = item.extra.split("###")[1]

        if item.from_action:
            item.__dict__["action"] = item.__dict__.pop("from_action")
        if item.from_channel:
            item.__dict__["channel"] = item.__dict__.pop("from_channel")

        if not channel:
            try:
                channel = __import__('channels.%s' % item.channel, fromlist=["channels.%s" % item.channel])
                # channel = __import__('specials.%s' % item.channel, fromlist=["specials.%s" % item.channel])
            except ImportError:
                exec("import channels." + item.channel + " as channel")

        # To disambiguate titles, TMDB is caused to ask for the really desired title
        # The user can select the title among those offered on the first screen
        # or you can cancel and enter a new title on the second screen
        # If you do it in "Enter another name", TMDB will automatically search for the new title
        # If you do it in "Complete Information", it partially changes to the new title, but does not search TMDB. We have to do it
        # If the second screen is canceled, the variable "scraper_return" will be False. The user does not want to continue

        item = generictools.update_title(item) # We call the method that updates the title with tmdb.find_and_set_infoLabels
        if not item: return
        #if item.tmdb_stat:
        #    del item.tmdb_stat          # We clean the status so that it is not recorded in the Video Library

        # Get the episode list
        it = item.clone()
        itemlist = getattr(channel, it.action)(it)
        item.host = channel.host
        if itemlist and not scrapertools.find_single_match(itemlist[0].title, r'[Ss]?(\d+)(?:x|_|\s+)[Ee]?[Pp]?(\d+)'):
            from platformcode.autorenumber import start, check
            if not check(item):
                action = item.action
                item.renumber = True
                start(item)
                item.renumber = False
                item.action = action
                if not item.exit:
                    return add_tvshow(item, channel)
                itemlist = getattr(channel, item.action)(item)
            else:
                itemlist = getattr(channel, item.action)(item)

    global magnet_caching
    magnet_caching = False

    inserted, overwritten, failed, path = save_tvshow(item, itemlist)

    if not path:
        pass

    elif not inserted and not overwritten and not failed:
        filetools.rmdirtree(path)
        platformtools.dialog_ok(config.get_localized_string(30131), config.get_localized_string(60067) % item.show)
        logger.error("The string %s could not be added to the video library. Could not get any episode" % item.show)

    elif failed == -1:
        filetools.rmdirtree(path)
        platformtools.dialog_ok(config.get_localized_string(30131), config.get_localized_string(60068) % item.show)
        logger.error("The string %s could not be added to the video library" % item.show)

    elif failed == -2:
        filetools.rmdirtree(path)

    elif failed > 0:
        platformtools.dialog_ok(config.get_localized_string(30131), config.get_localized_string(60069) % item.show)
        logger.error("Could not add %s episodes of series %s to the video library" % (failed, item.show))

    else:
        platformtools.dialog_notification(config.get_localized_string(30131), config.get_localized_string(60070) % item.show)
        logger.debug("%s episodes of series %s have been added to the video library" % (inserted, item.show))
        if config.is_xbmc():
            if config.get_setting("sync_trakt_new_tvshow", "videolibrary"):
                import xbmc
                from platformcode import xbmc_videolibrary
                if config.get_setting("sync_trakt_new_tvshow_wait", "videolibrary"):
                    # Check that you are not looking for content in the Kodi video library
                    while xbmc.getCondVisibility('Library.IsScanningVideo()'):
                        xbmc.sleep(1000)
                # Synchronization for Kodi video library launched
                xbmc_videolibrary.sync_trakt_kodi()
                # Synchronization for the addon video library is launched
                xbmc_videolibrary.sync_trakt_addon(path)


def remove_host(item):
    
    if PY3: import urllib.parse as urlparse  # It is very slow in PY2. In PY3 it is native
    else: import urlparse  # We use the native of PY2 which is faster
    parsed_url = urlparse.urlparse(item.url)
    item.url = urlparse.urlunparse(('', '', parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment))


def get_id(item):
    _id = ''
    for i in item.infoLabels['code']:
        if i or i != 'None':
            _id = i
            break
    return _id


def get_local_files(item):
    included_files = {}
    # search media files in Videolibrary Folder
    for root, folder, files in filetools.walk(filetools.join(TVSHOWS_PATH,item.base_name)):
        # for folder in folders:
        for f in files:
            if f.split('.')[-1] in video_extensions:
                s, e = scrapertools.find_single_match(f, r'[Ss]?(\d+)(?:x|_|\s+)[Ee]?[Pp]?(\d+)')
                included_files['{}x{}'.format(s,e.zfill(2))] = f
    if included_files:
        return included_files, 1

def get_fanart_tv(item, set='', ret={}):
    def set_dict(l):
        d = {}
        for k in l:
            o = d.get(k['season'], [])
            o.append(k['url'])
            d[k['season']] = o
        return d

    _id = item.infoLabels.get('tvdb_id', item.infoLabels.get('tmdb_id'))

    if _id:
        _type = item.contentType.replace('show','').replace('movie','movies')
        host = 'http://webservice.fanart.tv/v3/{}/{}?api_key=cab16e262d72fea6a6843d679aa10300'
        url = host.format(_type, _id)
        res = httptools.downloadpage(url).json
        if _type == 'tv':
            ret['clearlogo'] = [k.get('url') for k in res.get('hdtvlogo', [])] + [k.get('url') for k in res.get('tvlogo', [])]
            ret['clearart'] = [k.get('url') for k in res.get('hdclearart', [])] + [k.get('url') for k in res.get('hdclearart', [])]
            ret['fanart'] = set_dict(res.get('showbackground', []))
            ret['poster'] = set_dict(res.get('seasonposter', []))
            ret['poster']['all'] = [k.get('url') for k in res.get('tvposter', [])]
            ret['landscape'] = set_dict(res.get('seasonthumb', []))
            ret['landscape']['all'] = [k.get('url') for k in res.get('tvthumb', [])]
            ret['banner'] = set_dict(res.get('seasonbanner', []))
            ret['banner']['all'] = [k.get('url') for k in res.get('tvbanner', [])]

        elif _type == 'movies':
            ret[set + 'clearlogo'] = [k.get('url') for k in res.get('hdmovielogo', [])] + [k.get('url') for k in res.get('movielogo', [])]
            ret[set + 'poster'] = [k.get('url') for k in res.get('movieposter', [])]
            ret[set + 'fanart'] = [k.get('url') for k in res.get('moviebackground', [])]
            ret[set + 'clearart'] = [k.get('url') for k in res.get('hdmovieclearart', [])] + [k.get('url') for k in res.get('movieclearart', [])]
            ret[set + 'landscape'] = [k.get('url') for k in res.get('moviethumb', [])]
            ret[set + 'banner'] = [k.get('url') for k in res.get('moviebanner', [])]
            ret[set + 'disc'] = [k.get('url') for k in res.get('moviedisc', [])]
            if item.infoLabels.get('setid'):
                it = item.clone(infoLabels = {'tmdb_id':item.infoLabels['setid']})
                get_fanart_tv(it, 'set', ret)

    return ret