#
# This file is part of SickGear.
#
# SickGear is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# SickGear is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with SickGear.  If not, see <http://www.gnu.org/licenses/>.

import random
import weakref
from collections import Counter, OrderedDict
from functools import reduce
from itertools import chain
from weakref import ReferenceType

import datetime
import glob
import inspect
import os.path
import re
import requests
import stat
import threading
import traceback

from imdbpie import ImdbAPIError
from lxml_etree import etree

import exceptions_helper
from exceptions_helper import ex

import sickgear
from . import db, helpers, history, image_cache, indexermapper, logger, \
    name_cache, network_timezones, notifiers, postProcessor, subtitles
from .anime import AniGroupList
from .classes import WeakList
from .common import Quality, statusStrings, \
    ARCHIVED, DOWNLOADED, FAILED, IGNORED, SKIPPED, SNATCHED, SNATCHED_ANY, SNATCHED_PROPER, UNAIRED, UNKNOWN, WANTED, \
    NAMING_DUPLICATE, NAMING_EXTEND, NAMING_LIMITED_EXTEND, NAMING_LIMITED_EXTEND_E_PREFIXED, NAMING_SEPARATED_REPEAT
from .generic_queue import QueuePriorities
from .helpers import try_float, try_int
from .indexermapper import del_mapping, MapStatus, save_mapping
from .indexers.indexer_config import TVINFO_IMDB, TVINFO_TMDB, TVINFO_TRAKT, TVINFO_TVDB, TVINFO_TVMAZE, TVINFO_TVRAGE
from .name_parser.parser import InvalidNameException, InvalidShowException, NameParser
from .sgdatetime import SGDatetime
from .tv_base import TVEpisodeBase, TVShowBase

from lib import imdbpie, subliminal
from lib.dateutil import tz
from lib.dateutil.parser import parser as du_parser
try:
    from lib.thefuzz import fuzz
except ImportError as e:
    from lib.fuzzywuzzy import fuzz
from lib.tvinfo_base import RoleTypes, TVINFO_FACEBOOK, TVINFO_INSTAGRAM, TVINFO_SLUG, TVINFO_TWITTER, \
    TVINFO_WIKIPEDIA, TVINFO_TIKTOK, TVINFO_FANSITE, TVINFO_YOUTUBE, TVINFO_REDDIT, TVINFO_LINKEDIN, TVINFO_WIKIDATA
from lib.tvinfo_base.exceptions import *
from sg_helpers import calc_age, int_to_time, remove_file_perm, time_to_int

from six import integer_types, iteritems, iterkeys, itervalues, moves, string_types

# noinspection PyUnreachableCode
if False:
    from typing import Any, AnyStr, Dict, List, Optional, Set, Text, Tuple, Union
    from sqlite3 import Row
    from lib.tvinfo_base import CastList, TVInfoCharacter, TVInfoPerson, \
        TVInfoEpisode, TVInfoShow

coreid_warnings = False
if coreid_warnings:
    import warnings
    warnings.simplefilter('always', DeprecationWarning)

tz_p = du_parser()
invalid_date_limit = datetime.date(1900, 1, 1)

tba_tvinfo_name = re.compile(r'^(episode \d+|tb[acd])$', flags=re.I)
tba_file_name = re.compile(r'\b(episode.\d+|tb[acd])\b', flags=re.I)
pattern_ep_name = re.compile(r'%E[._]?N', flags=re.I)

# status codes for switching tv show source
TVSWITCH_DUPLICATE_SHOW = 0
TVSWITCH_ID_CONFLICT = 1
TVSWITCH_NO_NEW_ID = 2
TVSWITCH_NORMAL = 3
TVSWITCH_NOT_FOUND_ERROR = 4
TVSWITCH_SAME_ID = 5
TVSWITCH_SOURCE_NOT_FOUND_ERROR = 6
TVSWITCH_VERIFY_ERROR = 7

tvswitch_names = {
    TVSWITCH_DUPLICATE_SHOW: 'Duplicate Show',
    TVSWITCH_ID_CONFLICT: 'new id conflicts with existing show',
    TVSWITCH_NO_NEW_ID: 'no new id found',
    TVSWITCH_NORMAL: 'Normal',
    TVSWITCH_NOT_FOUND_ERROR: 'Not found on new tv source',
    TVSWITCH_SAME_ID: 'unchanged ids given',
    TVSWITCH_SOURCE_NOT_FOUND_ERROR: 'source show not found',
    TVSWITCH_VERIFY_ERROR: 'Verification error',
}

TVSWITCH_EP_DELETED = 1
TVSWITCH_EP_RENAMED = 2

tvswitch_ep_names = {
    TVSWITCH_EP_DELETED: 'deleted',
    TVSWITCH_EP_RENAMED: 'renamed'
}

concurrent_show_not_found_days = 7
show_not_found_retry_days = 7

prodid_bitshift = 4
tvid_bitmask = (1 << prodid_bitshift) - 1


class TVidProdid(object):
    """
    Helper class to standardise the use of a TV info source id with its associated TV show id

    Examples of setting and using on the one action, tvid and prodid are numbers of type int or string;
    TVidProdid({tvid: prodid})
    TVidProdid({tvid: prodid})([])
    TVidProdid({tvid: prodid})(list)
    TVidProdid({tvid: prodid})('list')
    TVidProdid({tvid: prodid}).list

    Whitespace may exist between the number value and <self.glue> in these strings
    TVidProdid('tvid <self.glue> prodid')({})
    TVidProdid('tvid <self.glue> prodid')(dict)
    TVidProdid('tvid <self.glue> prodid')('dict')
    TVidProdid('tvid <self.glue> prodid').dict
    """
    glue = ':'

    def __init__(self, tvid_prodid=None):
        """
        :param tvid_prodid: TV info data source ID, and TV show ID
        :type tvid_prodid: Dict or String
        """
        self.tvid = None
        self.prodid = None
        self.sid_int = None

        if isinstance(tvid_prodid, dict) and 1 == len(tvid_prodid):
            try:
                for (cur_tvid, cur_prodid) in iteritems(tvid_prodid):
                    self.tvid, self.prodid = int(cur_tvid), int(cur_prodid)
            except ValueError:
                pass
        elif isinstance(tvid_prodid, string_types):
            if self.glue in tvid_prodid:
                try:
                    for (cur_tvid, cur_prodid) in [re.findall(r'(\d+)\s*%s\s*(\d+)' % self.glue, tvid_prodid)[0]]:
                        self.tvid, self.prodid = int(cur_tvid), int(cur_prodid)
                except IndexError:
                    pass
            else:
                try:
                    legacy_showid = int(re.findall(r'(?i)\d+', tvid_prodid)[0])
                    show_obj = (helpers.find_show_by_id({TVINFO_TVDB: legacy_showid})
                                or helpers.find_show_by_id({TVINFO_TVRAGE: legacy_showid}))
                    pre_msg = 'Todo: Deprecate show_id used without a tvid'
                    if None is show_obj:
                        pre_msg += ' and show_obj not found'
                    else:
                        self.tvid, self.prodid = show_obj.tvid, legacy_showid

                    if coreid_warnings:
                        logger.log('%s\n' % pre_msg +
                                   '|>%s^-- Note: Bootstrap & Tornado startup functions stripped from traceback log.' %
                                   '|>'.join(filter(lambda text: not re.search(r'(?i)bootstrap|traceback\.'
                                                                               r'format_stack|pydevd|tornado'
                                                                               r'|webserveinit', text),
                                                         traceback.format_stack(inspect.currentframe()))))
                except IndexError:
                    pass
        elif isinstance(tvid_prodid, integer_types):
            self.tvid = tvid_prodid & tvid_bitmask
            self.prodid = tvid_prodid >> prodid_bitshift
            self.sid_int = tvid_prodid
            return

        if None not in (self.prodid, self.tvid):
            self.sid_int = self.prodid << prodid_bitshift | self.tvid

    def __call__(self, *args, **kwargs):
        return self._get(*args, **kwargs)

    def __repr__(self):
        return self._get()

    def __str__(self):
        return self._get()

    def __tuple__(self):
        return self._get(tuple)

    def __int__(self):
        return self._get(int)

    @property
    def list(self):
        return self._get(list)

    @property
    def dict(self):
        return self._get(dict)

    @property
    def tuple(self):
        return self._get(tuple)

    @property
    def int(self):
        return self._get(int)

    @staticmethod
    def _checktype(value, t):
        if isinstance(value, string_types) and not isinstance(value, type) and value:
            if value == getattr(t, '__name__', None):
                return True
        elif (isinstance(value, type) and value == t) or isinstance(value, t):
            return True
        return False

    def _get(self, kind=None):
        if None is not kind:
            if self._checktype(kind, int):
                return self.sid_int
            elif self._checktype(kind, dict):
                return {self.tvid: self.prodid}
            elif self._checktype(kind, tuple):
                return self.tvid, self.prodid
        if None is kind or self._checktype(kind, string_types):
            return '%s%s%s' % (self.tvid, self.glue, self.prodid)
        return [self.tvid, self.prodid]

    @property
    def _tvid(self):
        return self.tvid

    @property
    def _prodid(self):
        return self.prodid


class PersonGenders(object):
    UNKNOWN = 0
    male = 1
    female = 2

    possible_values = [0, 1, 2]
    names = {UNKNOWN: 'Unknown', male: 'Male', female: 'Female'}
    tmdb_map = {0: UNKNOWN, 1: female, 2: male}


def _make_date(dt):
    # type: (datetime.date) -> integer_types
    if not dt:
        return None
    return dt.toordinal()


def usable_id(value):
    # type: (Union[AnyStr, int]) -> Optional[AnyStr, int]
    """
    return value as int if value is numerical,
    or value as string if value is valid id:format
    otherwise None
    """
    value_id = try_int(value, None)
    if None is not value_id:
        return value_id
    return usable_rid(value)


def usable_rid(value):
    # type: (Union[AnyStr]) -> Optional[AnyStr]
    """
    return value if is an id:format is valid
    otherwise None if value fails basic id format validation
    """
    if isinstance(value, string_types) and ':' in value:
        temp = value.split(':')
        if 2 == len(temp) and None not in [try_int(_x, None) for _x in temp]:
            return value


class Referential(object):
    """
    This class superimposes handling for a string based ID named `ref_id`.

    __init__ will pass back control untouched to the object deriving
    from this one if an integer is passed so that integer ID can perform
    """

    def __init__(self, sid=None):
        self.id = None  # type: integer_types
        self.ids = {}  # type: Dict[int, integer_types]
        self._rid = usable_rid(sid)

    def has_ref_id(self, item):
        if isinstance(item, integer_types):
            return self.id == item

        tvid, src_id = self.ref_id(rid=item, string=False)
        return self.ids.get(tvid) == src_id

    def ref_id(self,
               rid=None,  # type: Optional[AnyStr, int]
               string=True  # type: Optional[bool]
               ):  # type: (...) -> Union[tuple[Optional[AnyStr, int], Optional[AnyStr, int]], AnyStr]
        """
        return either,
         1) a preferred external unique id for a consistent reliable `reference`, or the internal row id as fallback
         2) convert a consistent `reference` to src and src_id to use for matching to an internal row id
            uses param rid or self._rid as reference id to convert if either is not Nonetype

        for example,
         1) if string is False, preferred static tuple[tvid, id], or tuple[None, id] if ids not set
         2)          otherwise, preferred static 'tvid:id', or 'id' if ids not set
         3) if string is False and self._rid contains ':', list[src, src_id]
         4)           otherwise if self._rid contains ':', list['src', 'src_id']

        reason, a row id is highly volatile, but a preferred ID is more reliable.
        use cases,
         show removed and readded, or src switched, then refreshing any character/person views will be consistent.
         can share/save a character/person link/bookmark as it will be consistent across instances.
         cast glide startAt is unreliable using glide index or row id.
         """
        # if self._rid is a temporary type string containing ':' (use case during init)
        # return it as a tuple[int, int] -> src, src_id
        rid = rid or self._rid
        if usable_rid(rid):
            self._rid = None  # consume once
            parts = [try_int(_x, None) for _x in rid.split(':')]

            # if string: no usage for this case
            #     ? return rid
            #     ? return '%s' % parts[0], '%s' % parts[1]
            return parts[0], parts[1]

        # get an available id from an order of preferred ids for use
        if self.ids:
            for cur_tvid in [TVINFO_IMDB, TVINFO_TVMAZE, TVINFO_TMDB, TVINFO_TRAKT]:
                if self.ids.get(cur_tvid):
                    if string:
                        return '%s:%s' % (cur_tvid, self.ids.get(cur_tvid))
                    return cur_tvid, self.ids.get(cur_tvid)
        if string:
            return '%s' % self.id
        return None, self.id  # default internal id has no slug


class Person(Referential):
    def __init__(
            self,
            name=None,  # type: AnyStr
            gender=PersonGenders.UNKNOWN,  # type: int
            birthday=None,  # type: datetime.date
            deathday=None,  # type: datetime.date
            bio=None,  # type: AnyStr
            ids=None,  # type: Dict[int, integer_types]
            sid=None,  # type: integer_types
            birthplace=None,  # type: AnyStr
            homepage=None,  # type: AnyStr
            image_url=None,  # type: AnyStr
            thumb_url=None,  # type: AnyStr
            show_obj=None,  # type: TVShow
            updated=1,  # type: integer_types
            deathplace=None,  # type: AnyStr
            height=None,  # type: Union[integer_types, float]
            real_name=None,  # type: AnyStr
            nicknames=None,  # type: Set[AnyStr]
            akas=None,  # type: Set[AnyStr]
            character_obj=None,  # type: Character
            tmp_character_obj=None  # type: Character
    ):

        super(Person, self).__init__(sid)

        self.updated = updated  # type: integer_types
        self._data_failure = False  # type: bool
        self._data_fetched = False  # type: bool
        self.name = name  # type: AnyStr
        self.character_obj = character_obj  # type: Optional[Character]
        self._tmp_character_obj = tmp_character_obj  # type: Optional[Character]
        self.gender = (PersonGenders.UNKNOWN, gender)[gender in PersonGenders.possible_values]  # type: int
        self.birthday = birthday  # type: Optional[datetime.date]
        self.deathday = deathday  # type: Optional[datetime.date]
        self.biography = bio  # type: Optional[AnyStr]
        self.birthplace = birthplace  # type: Optional[AnyStr]
        self.homepage = homepage  # type: Optional[AnyStr]
        self.image_url = image_url  # type: Optional[AnyStr]
        self.thumb_url = thumb_url  # type: Optional[AnyStr]
        self.deathplace = deathplace  # type: Optional[AnyStr]
        self.height = height  # type: Optional[Union[integer_types, float]]
        self.real_name = real_name  # type: Optional[AnyStr]
        self.nicknames = nicknames or set()  # type: Set[AnyStr]
        self.akas = akas or set()  # type: Set[AnyStr]
        self.ids = ids or {}  # type: Dict[int, integer_types]
        if not self._rid:
            self.id = sid or self._get_sid(show_obj=show_obj)  # type: integer_types
        new_dirty = not sid
        self.dirty_main = new_dirty  # type: bool
        self.dirty_ids = new_dirty  # type: bool
        if not sid and self.id:
            fetched = self._data_fetched
            cur_data = self._remember_properties()
            self.load_from_db()
            cur_data['ids'] = dict(chain.from_iterable(iteritems(_d) for _d in (self.ids, ids or {})))
            self.update_properties(**cur_data)
            self._data_fetched = fetched
        elif not self.name:
            self.load_from_db()

    @staticmethod
    def _order_names(name_set):
        # type: (Set[AnyStr]) -> List[AnyStr]
        rc_aka = re.compile(r'[\x00-\x7f]+')

        aka_all_ascii = []
        aka_non_ascii = []

        for cur_aka in name_set or []:
            if rc_aka.match(cur_aka):
                aka_all_ascii += [cur_aka]
            else:
                aka_non_ascii += [cur_aka]

        return aka_all_ascii + aka_non_ascii

    @property
    def lang_ordered_akas(self):
        # type: (...) -> List[AnyStr]
        return self._order_names(self.akas)

    @property
    def lang_ordered_nicknames(self):
        # type: (...) -> List[AnyStr]
        return self._order_names(self.nicknames)

    def _remember_properties(self):
        # type: (...) -> Dict
        return {_k: self.__dict__[_k] for _k in
                ['akas', 'biography', 'birthday', 'birthplace', 'deathday', 'deathplace', 'gender', 'height',
                 'homepage', 'ids', 'image_url', 'name', 'nicknames', 'real_name', 'thumb_url']}

    def reset(self, person_obj=None):
        # type: (TVInfoPerson) -> None
        """
        reset all properties except; name, id, ids

        :param person_obj: TVInfo Person object to reset to
        """
        self._data_failure = False
        self._data_fetched = False
        self.akas = person_obj.akas or set()
        self.biography = person_obj.bio or None
        self.birthday = person_obj.birthdate or None
        self.birthplace = person_obj.birthplace or None
        self.deathday = person_obj.deathdate or None
        self.deathplace = person_obj.deathplace or None
        self.dirty_main = True
        self.gender = person_obj.gender or PersonGenders.UNKNOWN
        self.height = person_obj.height or None
        self.homepage = person_obj.homepage or None
        self.image_url = person_obj.image or None
        self.nicknames = person_obj.nicknames or set()
        self.real_name = person_obj.real_name or None
        self.thumb_url = person_obj.thumb_url or None
        self.updated = 1

    def _get_sid(self, mass_action_result=None, show_obj=None):
        # type: (List, TVShow) -> Optional[integer_types]
        if getattr(self, 'id', None):
            return self.id

        def _get_from_ids():
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT person_id
                FROM person_ids
                WHERE %s
                """ % ' OR '.join(['( src = ? AND src_id = ? )'] * len(self.ids)),
                list(reduce(lambda a, b: a + b, iteritems(self.ids))))
            for cur_id in sql_result or []:
                return cur_id['person_id']

        if mass_action_result:
            try:
                return mass_action_result[-1:][0][0]['last_rowid']
            except (BaseException, Exception):
                return
        elif self.ids:
            i = _get_from_ids()
            if i:
                return i
        self.get_missing_data(show_obj=show_obj)
        if self.ids:
            return _get_from_ids()

    def _set_updated(self):
        # type: (...) -> integer_types
        """
        set and return new update date
        """
        self.updated = datetime.date.today().toordinal() - (0, 120)[self._data_failure]
        return self.updated

    def remove_img(self):
        """
        removes image of person
        """
        try:
            remove_file_perm(image_cache.ImageCache().person_path(self))
        except (BaseException, Exception):
            pass

    def remove_thumb(self):
        """
        removes thumb image of person
        """
        try:
            remove_file_perm(image_cache.ImageCache().person_thumb_path(self))
        except (BaseException, Exception):
            pass

    def remove_all_img(self):
        """
        remove all images of person
        """
        try:
            for cur_remove in image_cache.ImageCache().person_both_paths(self):
                try:
                    remove_file_perm(cur_remove)
                except (BaseException, Exception):
                    pass
        except (BaseException, Exception):
            pass

    def update_properties(self, **kwargs):
        """
        updates properties of class, if changed sets dirty
        :param kwargs: properties of class
        """
        if (not self.image_url and not self.thumb_url) or (not self.image_url and kwargs.get('image_url')):
            if kwargs.get('image_url'):
                self.dirty_main = True
                self.remove_img()
                self.image_url = kwargs.get('image_url')
                # thumb changed, remove old image
                if kwargs.get('thumb_url'):
                    self.remove_thumb()
                    self.thumb_url = kwargs.get('thumb_url')
                else:
                    self.remove_thumb()
                    self.thumb_url = None
            elif kwargs.get('thumb_url'):
                self.dirty_main = True
                self.thumb_url = kwargs.get('thumb_url')
                # image changed remove old image
                self.remove_img()
                if kwargs.get('image_url'):
                    self.remove_img()
                    self.image_url = kwargs.get('image_url')
                else:
                    self.remove_img()
                    self.image_url = None

        for cur_key, cur_value in iteritems(kwargs):
            if cur_key in ('image_url', 'thumb_url'):
                continue
            if cur_key not in self.__dict__:
                raise Exception('Person has no property [%s]' % cur_key)
            if None is not cur_value:
                if 'akas' == cur_key:
                    cur_value.update(self.akas)
                elif 'nicknames' == cur_key:
                    cur_value.update(self.nicknames)
                if cur_value != self.__dict__[cur_key]:
                    if 'biography' == cur_key:
                        if len(cur_value) > len(self.biography or ''):
                            self.biography = cur_value
                            self.dirty_main = True
                    elif 'gender' == cur_key and cur_value not in (PersonGenders.male, PersonGenders.female):
                        continue
                    else:
                        self.__dict__[cur_key] = cur_value
                    if 'ids' == cur_key:
                        self.dirty_ids = True
                    else:
                        self.dirty_main = True

    def load_from_db(self):
        if self.id or usable_rid(self._rid):
            my_db = db.DBConnection()
            src, src_id = self.ref_id(string=False)
            sql_result = my_db.select(
                """
                SELECT persons.*,
                (SELECT group_concat(person_ids.src || ':' || person_ids.src_id, ';;;')
                 FROM person_ids 
                 WHERE person_ids.person_id = persons.id) AS p_ids
                FROM persons
                LEFT JOIN person_ids pi ON persons.id = pi.person_id
                WHERE %s
                """ % ('pi.src = ? and pi.src_id = ?', 'persons.id = ?')[not src],
                ([src, src_id], [self.id])[not src])

            for cur_person in sql_result or []:
                birthdate = try_int(cur_person['birthdate'], None)
                birthdate = birthdate and datetime.date.fromordinal(cur_person['birthdate'])
                deathdate = try_int(cur_person['deathdate'], None)
                deathdate = deathdate and datetime.date.fromordinal(cur_person['deathdate'])

                p_ids = {}
                for cur_ids in (cur_person['p_ids'] and cur_person['p_ids'].split(';;;')) or []:
                    k, v = cur_ids.split(':', 1)
                    k = try_int(k, None)
                    if v and None is not k:
                        p_ids[k] = v if k in (TVINFO_FACEBOOK, TVINFO_INSTAGRAM, TVINFO_TWITTER, TVINFO_WIKIPEDIA,
                                              TVINFO_TIKTOK, TVINFO_FANSITE, TVINFO_YOUTUBE, TVINFO_REDDIT,
                                              TVINFO_LINKEDIN, TVINFO_WIKIDATA) \
                            else try_int(v, None)

                (self._data_failure, self._data_fetched,
                 self.akas, self.biography,
                 self.birthday, self.birthplace, self.deathday, self.deathplace,
                 self.gender, self.height, self.homepage,
                 self.id, self.ids, self.image_url, self.name,
                 self.nicknames,
                 self.real_name, self.thumb_url, self.updated) = \
                    (False, False,
                     set((cur_person['akas'] and cur_person['akas'].split(';;;')) or []), cur_person['bio'],
                     birthdate, cur_person['birthplace'], deathdate, cur_person['deathplace'],
                     cur_person['gender'], cur_person['height'], cur_person['homepage'],
                     cur_person['id'], p_ids, cur_person['image_url'], cur_person['name'],
                     set((cur_person['nicknames'] and cur_person['nicknames'].split(';;;')) or []),
                     cur_person['realname'], cur_person['thumb_url'], cur_person['updated'])
                break

    def update_prop_from_tvinfo_person(self, person_obj):
        # type: (TVInfoPerson) -> None
        """
        update person with tvinfo person object info
        Note: doesn't change: name, id, image_url, thumb_url

        :param person_obj: TVInfo Person object
        """
        if person_obj:
            char_obj = self.character_obj or self._tmp_character_obj
            if person_obj.characters and char_obj and char_obj.show_obj \
                    and char_obj.show_obj.ids.get(TVINFO_IMDB, {}).get('id'):
                p_char = [_pc for _pc in person_obj.characters
                          if _pc.ti_show and
                          _pc.ti_show.ids.imdb == char_obj.show_obj.ids.get(TVINFO_IMDB, {}).get('id')]
                p_count = len(p_char)
                if 1 == p_count:
                    if (p_char[0].start_year or p_char[0].end_year) and getattr(self, 'id', None):
                        char_obj.combine_start_end_years(
                            {self.id: {'start': p_char[0].start_year, 'end': p_char[0].end_year}})
                elif 1 < p_count:
                    start, end, found, p_p = None, None, False, None
                    for cur_p in p_char:
                        if not start or start > (cur_p.start_year or 3000):
                            start = cur_p.start_year
                        if not end or end < (cur_p.end_year or 0):
                            end = cur_p.end_year
                        if cur_p.name == char_obj.name:
                            start = cur_p.start_year
                            end = cur_p.end_year
                            found = True
                            break
                    if not found:
                        try:
                            p_p = sorted([
                                (fuzz.UWRatio(char_obj.name, _pc.name),
                                 _pc.end_year and _pc.start_year and _pc.end_year - _pc.start_year, _pc)
                                for _pc in p_char],
                                key=lambda _a: (_a[0], _a[1]), reverse=True)[0][2]
                        except (BaseException, Exception):
                            p_p = None
                    if None is not p_p and (p_p.start_year or p_p.end_year):
                        start = p_p.start_year
                        end = p_p.end_year
                    if (start or end) and getattr(self, 'id', None):
                        char_obj.combine_start_end_years({self.id: {'start': start, 'end': end}})
            self.update_properties(
                gender=person_obj.gender, homepage=person_obj.homepage,
                ids=dict(chain.from_iterable(
                    iteritems(_d) for _d in (self.ids, {_k: _v for _k, _v in iteritems(person_obj.ids)
                                                        if _v and TVINFO_SLUG != _k} or {}))),
                birthday=person_obj.birthdate, deathday=person_obj.deathdate, biography=person_obj.bio,
                birthplace=person_obj.birthplace, deathplace=person_obj.deathplace, height=person_obj.height,
                real_name=person_obj.real_name, nicknames=person_obj.nicknames, akas=person_obj.akas
            )

    def get_missing_data(self, show_obj=None, character_obj=None, stop_event=None, force_id=False):
        # type: (TVShow, Character, threading.Event, bool) -> None
        """
        load missing data for person from trakt + tmdb

        :param show_obj:
        :param character_obj:
        :param stop_event:
        :param force_id: refetch all external ids, normally only source ids and missing are fetched
        """
        if character_obj and not self.character_obj:
            self.character_obj = character_obj
        if self._data_failure:
            self.dirty_main = True
        self._data_failure = False
        self._data_fetched = True
        tvsrc_result, found_persons, found_on_src, search_sources, \
            found_ids, ids_to_check, imdb_confirmed, source_confirmed = \
            None, {}, set(), [TVINFO_TRAKT, TVINFO_TMDB, TVINFO_IMDB, TVINFO_TVDB], \
            set([_k for _k, _v in iteritems(self.ids) if _v] + ['text']), {}, False, {}
        # confirmed_character =  False
        max_search_src = len(search_sources)
        logger.debug('Getting extra data for: %s' % self.name)
        for cur_tv_loop in moves.xrange(0, max_search_src):
            search_sources = [_s for _s in search_sources if _s not in found_on_src]
            for cur_tv_info_src in search_sources:
                if stop_event and stop_event.is_set():
                    return
                rp, confirmed_on_src = None, False
                tvinfo_config = sickgear.TVInfoAPI(cur_tv_info_src).api_params.copy()
                t = sickgear.TVInfoAPI(cur_tv_info_src).setup(**tvinfo_config)
                if 0 == cur_tv_loop or cur_tv_info_src not in ids_to_check:
                    ids_to_check[cur_tv_info_src] = t.supported_person_id_searches + ['text']
                    found_persons[cur_tv_info_src] = set()
                for cur_tv_src in ids_to_check[cur_tv_info_src]:
                    if 'text' != cur_tv_src and not self.ids.get(cur_tv_src):
                        continue
                    try:
                        if 'text' != cur_tv_src:
                            kw = {'ids': {cur_tv_src: self.ids[cur_tv_src]}}
                        else:
                            kw = {'name': self.name}
                        tvsrc_result = t.search_person(**kw)
                    except (BaseException, Exception):
                        self._data_failure = True
                        continue
                    if tvsrc_result:
                        # verify we have the correct person
                        for cur_person in tvsrc_result:  # type: TVInfoPerson
                            if None is not rp:
                                break
                            if not (imdb_confirmed and TVINFO_IMDB == cur_tv_src) \
                                    and cur_person.id in found_persons[cur_tv_info_src]:
                                continue
                            found_persons[cur_tv_info_src].add(cur_person.id)
                            try:
                                pd = t.get_person(cur_person.ids.get(cur_tv_info_src),
                                                  get_show_credits=True, get_images=True)
                            except (BaseException, Exception) as e:
                                self._data_failure = True
                                logger.warning('Error searching extra info for person: %s - %s' % (self.name, ex(e)))
                                continue
                            if None is not pd and imdb_confirmed and TVINFO_IMDB == cur_tv_src:
                                rp = pd
                                break
                            # noinspection PyUnresolvedReferences
                            if show_obj and None is not pd and pd.characters:
                                clean_show_name = indexermapper.clean_show_name(show_obj.name.lower())
                                for cur_ch in pd.characters or []:  # type: TVInfoCharacter
                                    if not cur_ch.ti_show:
                                        continue
                                    if cur_ch.ti_show.seriesname and clean_show_name == indexermapper.clean_show_name(
                                            cur_ch.ti_show.seriesname and cur_ch.ti_show.seriesname.lower()):
                                        rp = pd
                                        confirmed_on_src = True
                                        # confirmed_character = True
                                        break
                                    elif any(_ti_src == _so_src and bool(_ti_ids) and _ti_ids == _so_ids['id']
                                             for _ti_src, _ti_ids in iteritems(cur_ch.ti_show.ids)
                                             for _so_src, _so_ids in iteritems(show_obj.ids)):
                                        rp = pd
                                        confirmed_on_src = True
                                        # confirmed_character = True
                                        break
                        if rp:
                            if TVINFO_IMDB == cur_tv_info_src and confirmed_on_src:
                                imdb_confirmed = True
                            found_on_src.add(cur_tv_info_src)
                            break

                ids_to_check[cur_tv_info_src] = [_i for _i in ids_to_check[cur_tv_info_src] if _i not in found_ids]

                if None is not rp:
                    if confirmed_on_src:
                        for cur_i in (TVINFO_TRAKT, TVINFO_IMDB, TVINFO_TMDB, TVINFO_TVMAZE, TVINFO_TVDB):
                            if not rp.ids.get(cur_i):
                                continue
                            # in case it's the current source use its id and lock if from being changed
                            if cur_tv_info_src == cur_i and rp.ids.get(cur_i):
                                source_confirmed[cur_i] = True
                                if rp.ids.get(cur_i) != self.ids.get(cur_i):
                                    self.ids[cur_i] = rp.ids[cur_i]
                                    self.dirty_ids = True
                            if not source_confirmed.get(cur_i) and \
                                    (rp.ids.get(cur_i) and not self.ids.get(cur_i) or
                                     (force_id and rp.ids.get(cur_i) and rp.ids.get(cur_i) != self.ids.get(cur_i))):
                                self.ids[cur_i] = rp.ids[cur_i]
                                found_ids.add(cur_i)
                                self.dirty_ids = True

                        for cur_i in (TVINFO_INSTAGRAM, TVINFO_TWITTER, TVINFO_FACEBOOK, TVINFO_WIKIPEDIA,
                                      TVINFO_TIKTOK, TVINFO_FANSITE, TVINFO_YOUTUBE, TVINFO_REDDIT, TVINFO_LINKEDIN,
                                      TVINFO_WIKIDATA):
                            if not rp.social_ids.get(cur_i):
                                continue
                            if rp.social_ids.get(cur_i) and not self.ids.get(cur_i) or \
                                    (rp.social_ids.get(cur_i) and rp.social_ids.get(cur_i) != self.ids.get(cur_i)):
                                self.ids[cur_i] = rp.social_ids[cur_i]
                                found_ids.add(cur_i)
                                self.dirty_ids = True

                    self.update_prop_from_tvinfo_person(rp)
                    if not self.image_url and rp.image:
                        self.image_url = rp.image
                        if rp.thumb_url:
                            self.thumb_url = rp.thumb_url
                        else:
                            self.remove_thumb()
                            self.thumb_url = None
                        self.dirty_main = True
                    elif not self.thumb_url and rp.thumb_url:
                        self.thumb_url = rp.thumb_url
                        if not rp.image:
                            self.remove_img()
                            self.image_url = None
                        self.dirty_main = True

    def save_to_db(self, show_obj=None, character_obj=None, force=False, stop_event=None):
        # type: (TVShow, Character, bool, threading.Event) -> None
        if not self._data_fetched:
            self.get_missing_data(show_obj=show_obj, character_obj=character_obj, stop_event=stop_event)
        self._data_fetched = False
        if not any(_d for _d in (self.dirty_main, self.dirty_ids)):
            return
        my_db = db.DBConnection()
        if not self.id:
            cl = [[
                """
                INSERT INTO persons (akas, bio, birthdate, birthplace,
                deathdate, deathplace, gender, height, homepage,
                image_url, name, nicknames, realname, thumb_url,
                updated)
                VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);
                """, [';;;'.join(self.akas or []), self.biography, _make_date(self.birthday), self.birthplace,
                      _make_date(self.deathday), self.deathplace, self.gender, self.height, self.homepage,
                      self.image_url, self.name, ';;;'.join(self.nicknames or []), self.real_name, self.thumb_url,
                      self._set_updated()]
            ]]
            c_ids = len(self.ids)
            if c_ids:
                f_d = next(iter(self.ids))
                cl.extend([[
                    """
                    INSERT INTO person_ids (src, src_id, person_id)
                    VALUES (?,?,last_insert_rowid())
                    """, [f_d, self.ids[f_d]]]
                ])
                if 1 < c_ids:
                    cl.extend([[
                        """
                        INSERT INTO person_ids (src, src_id, person_id)
                        VALUES (?,?, 
                         (SELECT person_ids.person_id FROM person_ids
                          WHERE person_ids.id = last_insert_rowid())
                        );
                        """, [_s, self.ids[_s]]] for _s in list(self.ids)[1:]
                    ])
                cl.extend([[
                    """
                    SELECT person_ids.person_id AS last_rowid
                    FROM person_ids
                    WHERE person_ids.id = last_insert_rowid()
                    """]
                ])
            else:
                cl.extend([['SELECT last_insert_rowid() as last_rowid;']])
        else:
            cl = []
            if force or self.dirty_main:
                cl = [[
                    """
                    UPDATE persons
                     SET name = ?, gender = ?, birthdate = ?, deathdate = ?, bio = ?,
                     birthplace = ?, homepage = ?, image_url = ?, thumb_url = ?, updated = ?,
                     deathplace = ?, height = ?, realname = ?, nicknames = ?, akas = ?
                    WHERE id = ?
                    """,
                    [self.name, self.gender, _make_date(self.birthday), _make_date(self.deathday), self.biography,
                     self.birthplace, self.homepage, self.image_url, self.thumb_url,
                     self._set_updated(), self.deathplace, self.height, self.real_name,
                     ';;;'.join(self.nicknames or []), ';;;'.join(self.akas or []), self.id]],
                ]
            if force or self.dirty_ids:
                for cur_src, cur_ids in iteritems(self.ids):
                    cl.extend([
                        ['UPDATE person_ids SET src_id = ? WHERE person_id = ? AND src = ?',
                         [cur_ids, self.id, cur_src]],
                        ["INSERT INTO person_ids (src, src_id, person_id) SELECT %s, '%s', %s WHERE changes() == 0"
                         % (cur_src, cur_ids, self.id)]
                    ])
        if cl:
            r_id = my_db.mass_action(cl)
            if r_id and r_id[-1:][0]:
                self.id = self._get_sid(r_id)
            self.dirty_main, self.dirty_ids = False, False

    def calc_age(self, date=None):
        # type: (Optional[datetime.date]) -> Optional[int]
        """
        returns age based on current date or given date
        :param date:
        """
        return calc_age(self.birthday, self.deathday, date)

    @property
    def age(self):
        # type: (...) -> Optional[int]
        """
        :return: age of person if birthdate is known, in case of deathdate is known return age of death
        """
        return self.calc_age()

    def __bool__(self):
        return bool(self.name)

    def __eq__(self, other):
        return (self.id not in [None, 0] and other.id == self.id) \
               and any(self.ids[_o] == ids for _o, ids in iteritems(other.ids))

    def __str__(self):
        lived, id_str, id_list = '', '', []
        if self.birthday:
            lived += ' %s' % self.birthday
        if self.deathday:
            lived += ' - %s' % self.deathday
        for _src, _ids in iteritems(self.ids):
            id_list.append('%s: %s' % (sickgear.TVInfoAPI(_src).name, _ids))
        if id_list:
            id_str = ' (%s)' % ', '.join(id_list)
        return '<Person %s%s%s>' % (self.name, lived, id_str)

    def __repr__(self):
        return self.__str__()

    __nonzero__ = __bool__


class Character(Referential):
    def __init__(
            self,
            name=None,  # type: AnyStr
            person=None,  # type: List[Person]
            ids=None,  # type: Dict[int, integer_types]
            bio=None,  # type: AnyStr
            sid=None,  # type: integer_types
            image_url=None,  # type: AnyStr
            thumb_url=None,  # type: AnyStr
            show_obj=None,  # type: TVShow
            updated=1,  # type: integer_types
            persons_years=None,  # type: Dict[integer_types, Dict[AnyStr, int]]
            tmp=False  # type:bool
    ):  # type: (...) -> Character

        super(Character, self).__init__(sid)

        self.updated = updated  # type: integer_types
        self.name = name  # type: AnyStr
        self.persons_years = persons_years or {}  # type: Dict[integer_types, Dict[AnyStr, int]]
        self.person = person or []  # type: List[Person]
        self.biography = bio  # type: Optional[AnyStr]
        self.ids = ids or {}  # type: Dict[int, integer_types]
        self.image_url = image_url  # type: Optional[AnyStr]
        self.thumb_url = thumb_url  # type: Optional[AnyStr]
        self.show_obj = show_obj  # type: TVShow
        if not tmp:
            if not self._rid:
                self.id = sid or self._get_sid()  # type: integer_types
            new_dirty = not sid
            self.dirty_main = new_dirty  # type: bool
            self.dirty_ids = new_dirty  # type: bool
            self.dirty_person = new_dirty  # type: bool
            self.dirty_years = new_dirty  # type: bool
            if not sid and self.id:
                self.load_from_db()
                self.update_properties(name=name, person=person, biography=bio,
                                       ids=dict(chain.from_iterable(iteritems(_d) for _d in (self.ids, ids or {}))),
                                       image_url=image_url, thumb_url=thumb_url)
            elif not self.name:
                self.load_from_db()

    def _get_sid(self, mass_action_result=None):
        # type: (List) -> Optional[integer_types]
        if getattr(self, 'id', None):
            return self.id

        if mass_action_result:
            try:
                return mass_action_result[-1:][0][0]['last_rowid']
            except (BaseException, Exception):
                return
        elif self.ids:
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT character_id 
                FROM character_ids 
                WHERE %s
                """ % ' OR '.join(['( src = ? AND src_id = ? )'] * len(self.ids)),
                list(reduce(lambda a, b: a+b, iteritems(self.ids))))
            if sql_result:
                return sql_result[0]['character_id']
        elif self.person:
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT characters.id AS c_id 
                FROM characters
                LEFT JOIN character_person_map cpm ON characters.id = cpm.character_id
                WHERE name = ? AND cpm.person_id IN (%s)
                """ % ','.join(['?' * len(self.person)]),
                [self.name] + [_p.id for _p in self.person])
            if sql_result:
                return sql_result[0]['c_id']

    def _set_updated(self):
        # type: (...) -> integer_types
        """
        set and return new update date
        """
        self.updated = datetime.date.today().toordinal()
        return self.updated

    def remove_img(self):
        """
        removes image of person
        """
        try:
            remove_file_perm(image_cache.ImageCache().character_path(self, self.show_obj))
        except (BaseException, Exception):
            pass

    def remove_thumb(self):
        """
        removes thumb image of person
        """
        try:
            remove_file_perm(image_cache.ImageCache().character_thumb_path(self, self.show_obj))
        except (BaseException, Exception):
            pass

    def remove_all_img(self, include_person=False, tvid=None, proid=None):
        # type: (bool, integer_types, integer_types) -> None
        """
        remove all images of person
        """
        try:
            for cur_remove in image_cache.ImageCache().character_both_path(
                    self, show_obj=self.show_obj, tvid=tvid, proid=proid):
                try:
                    remove_file_perm(cur_remove)
                except (BaseException, Exception):
                    pass
        except (BaseException, Exception):
            pass
        if include_person:
            for cur_person in self.person or []:
                try:
                    cur_person.remove_all_img()
                except (BaseException, Exception):
                    pass

    def update_properties(self, **kwargs):
        for cur_key, cur_value in iteritems(kwargs):
            if cur_key not in self.__dict__:
                raise Exception('Character has no property [%s]' % cur_key)
            if None is not cur_value and cur_value != self.__dict__[cur_key]:
                if 'image_url' == cur_key:
                    self.dirty_main = True
                    self.remove_img()
                    if not kwargs.get('thumb_url'):
                        self.remove_thumb()
                        self.thumb_url = None
                elif 'thumb_url' == cur_key:
                    self.dirty_main = True
                    self.remove_thumb()
                    if not kwargs.get('image_url'):
                        self.remove_img()
                        self.image_url = None
                self.__dict__[cur_key] = cur_value
                if 'ids' == cur_key:
                    self.dirty_ids = True
                elif 'person' == cur_key:
                    self.dirty_person = True
                else:
                    self.dirty_main = True

    def combine_start_end_years(self, new_years):
        # type: (Dict[integer_types, Dict[AnyStr, int]]) -> None
        new_dict = dict(chain.from_iterable(
                    iteritems(_d) for _d in (self.persons_years,
                                             {_k: _v for _k, _v in iteritems(new_years) if _v} or {})))
        if new_dict != self.persons_years:
            self.persons_years = new_dict
            self.dirty_years = True

    def load_from_db(self):
        if self.id or usable_rid(self._rid):
            my_db = db.DBConnection()
            src, src_id = self.ref_id(string=False)
            sql_result = my_db.select(
                """
                SELECT characters.name AS name, characters.bio AS bio,
                characters.thumb_url AS thumb_url, characters.image_url AS image_url,
                characters.updated AS c_updated, characters.id AS c_id,
                (SELECT group_concat(character_ids.src || ':' || character_ids.src_id, ';;;')
                FROM character_ids WHERE character_ids.character_id = characters.id) AS c_ids,
                (SELECT group_concat(character_person_map.person_id, ';;;')
                FROM character_person_map
                WHERE character_person_map.character_id = characters.id) AS person_ids,
                (SELECT group_concat(character_person_years.person_id || ':' ||
                character_person_years.start_year || '-' || character_person_years.end_year, ';;;')
                FROM character_person_years WHERE character_person_years.character_id = characters.id)
                AS p_years
                FROM characters
                LEFT JOIN character_ids ci ON characters.id = ci.character_id
                WHERE %s
                """ % ('ci.src = ? and ci.src_id = ?', 'characters.id = ?')[not src],
                ([src, src_id], [self.id])[not src])

            for cur_row in (sql_result or []):
                c_ids = {}
                for cur_ids in (cur_row['c_ids'] and cur_row['c_ids'].split(';;;')) or []:
                    k, v = cur_ids.split(':', 1)
                    v = try_int(v, None)
                    if v:
                        c_ids[int(k)] = try_int(v, None)

                p_years = {}
                for cur_years in (cur_row['p_years'] and cur_row['p_years'].split(';;;')) or []:
                    p_id, py = cur_years.split(':')
                    start, end = py.split('-')
                    p_years[int(p_id)] = {'start': try_int(start, None), 'end': try_int(end, None)}

                (self.biography, self.id, self.ids, self.image_url, self.name,
                 self.person,
                 self.persons_years, self.thumb_url, self.updated) = \
                    (cur_row['bio'], cur_row['c_id'], c_ids, cur_row['image_url'], cur_row['name'],
                     [Person(sid=int(_p), character_obj=self)
                      for _p in (cur_row['person_ids'] and cur_row['person_ids'].split(';;;')) or []],
                     p_years, cur_row['thumb_url'], cur_row['c_updated'])

                self.dirty_main, self.dirty_ids, self.dirty_person = False, False, False
                break

    def _get_start_end_year(self):
        if self.person:
            tvinfo_config = sickgear.TVInfoAPI(TVINFO_IMDB).api_params.copy()
            t = sickgear.TVInfoAPI(TVINFO_IMDB).setup(**tvinfo_config)
            for cur_per in self.person:
                if not cur_per.id:
                    continue
                if cur_per.ids.get(TVINFO_IMDB):
                    try:
                        res = t.get_person(cur_per.ids.get(TVINFO_IMDB), get_show_credits=True)
                    except (BaseException, Exception):
                        continue
                    if res and res.characters:
                        cur_per.character_obj = self
                        cur_per.update_prop_from_tvinfo_person(res)

    def save_to_db(self, show_obj=None, force=False, stop_event=None):
        # type: (TVShow, bool, threading.Event) -> None
        if self.person:
            for cur_per in self.person:
                if stop_event and stop_event.is_set():
                    return
                if force or self.dirty_person or not cur_per.id or cur_per.dirty_main or cur_per.dirty_ids or \
                        14 < (datetime.date.today().toordinal() - cur_per.updated):
                    cur_per.save_to_db(show_obj=show_obj, character_obj=self, force=force, stop_event=stop_event)
                    self.dirty_person = True

        if ((None is self.id and not self.persons_years)
                or self.dirty_main or 14 < datetime.date.today().toordinal() - self.updated) and self.person:
            self._get_start_end_year()

        my_db = db.DBConnection()
        if not self.id:
            cl = [[
                """
                INSERT INTO characters (bio, image_url, name, thumb_url, updated)
                VALUES (?,?,?,?,?)
                """, [self.biography, self.image_url, self.name, self.thumb_url, self._set_updated()]],
                 ]
            c_ids = len(self.ids)
            if c_ids:
                f_d = next(iter(self.ids))
                cl.extend([[
                    """
                    INSERT INTO character_ids (src, src_id, character_id)
                    VALUES (?,?,last_insert_rowid())
                    """, [f_d, self.ids[f_d]]]
                ])
                if 1 < c_ids:
                    cl.extend([[
                        """
                        INSERT INTO character_ids (src, src_id, character_id)
                        VALUES (?,?,
                         (SELECT character_ids.character_id FROM character_ids
                          WHERE character_ids.id = last_insert_rowid())
                         );
                        """, [_s, self.ids[_s]]] for _s in list(self.ids)[1:]
                    ])
                cl.extend([[
                    """
                    SELECT character_ids.character_id AS last_rowid
                    FROM character_ids
                    WHERE character_ids.id = last_insert_rowid()
                    """]
                ])
            else:
                cl.extend([['SELECT last_insert_rowid() AS last_rowid;']])
        else:
            cl = []
            if force or self.dirty_main:
                cl = [[
                    """
                    UPDATE characters SET bio = ?, image_url = ?, name = ?, thumb_url = ?, updated = ?
                    WHERE id = ?
                    """, [self.biography, self.image_url, self.name, self.thumb_url, self._set_updated(), self.id]],
                ]
            if force or self.dirty_ids:
                for cur_tvid, cur_src_id in iteritems(self.ids):
                    cl.extend([[
                        """
                        UPDATE character_ids SET src_id = ?
                        WHERE src = ? AND character_id = ? 
                        """, [cur_src_id, cur_tvid, self.id]
                    ], [
                        """
                        INSERT INTO character_ids (src, src_id, character_id)
                        SELECT %s, %s, %s WHERE changes() == 0
                        """ % (cur_tvid, cur_src_id, self.id)]
                    ])

        # in case we don't have a character id yet, we need to fetch it for the next step
        if not self.id and cl:
            r_id = my_db.mass_action(cl)
            cl = []
            if r_id and r_id[-1:][0]:
                # r_id = list(itertools.chain.from_iterable(r_id))
                if r_id:
                    self.id = self._get_sid(r_id)

        if (force or self.dirty_person) and self.person:
            cl.append([
                """
                DELETE FROM character_person_map
                WHERE character_id = ? AND person_id NOT IN (%s)
                """ % ','.join(['?'] * len(self.person)),
                [self.id] + [_p.id for _p in self.person]])
            for cur_per in self.person:
                cl.extend([[
                    """
                    INSERT OR IGNORE INTO character_person_map (character_id, person_id)
                    VALUES (?,?)
                    """, [self.id, cur_per.id]]
                ])

        if (force or self.dirty_years) and self.person:
            cl.append([
                """
                DELETE FROM character_person_years
                WHERE character_id = ? AND person_id NOT IN (%s)
                """ % ','.join(['?'] * len(self.person)),
                [self.id] + [_p.id for _p in self.person]])
            for cur_per in self.person:
                if cur_per.id and any(1 for _v in itervalues(self.persons_years.get(cur_per.id, {})) if _v):
                    p_years = self.persons_years.get(cur_per.id, {})
                    cl.append([
                        """
                        REPLACE INTO character_person_years (character_id, person_id, start_year, end_year)
                        VALUES (?,?,?,?)
                        """, [self.id, cur_per.id, p_years.get('start'), p_years.get('end')]]
                    )

        if cl:
            my_db.mass_action(cl)
            self.dirty_ids, self.dirty_main, self.dirty_person, self.dirty_years = False, False, False, False

    def __bool__(self):
        return bool(self.name) or bool(self.person) or bool(self.ids)

    def __eq__(self, other):
        return other.person == self.person and ((self.id not in [None, 0] and other.id == self.id)
                                                or any(self.ids[_o] == _v for _o, _v in iteritems(other.ids))
                                                or (not other.ids and other.name == self.name))

    def __str__(self):
        id_str, id_list = '', []
        for _src, _ids in iteritems(self.ids):
            id_list.append('%s: %s' % (sickgear.TVInfoAPI(_src).name, _ids))
        if id_list:
            id_str = ' (%s)' % ', '.join(id_list)
        return '<Character %s (%s)%s>' % (self.name, ', '.join(_p.name for _p in self.person), id_str)

    def __repr__(self):
        return self.__str__()

    __nonzero__ = __bool__


class TVShow(TVShowBase):
    __slots__ = (
        'path',
        'unique_name',
    )

    def __init__(self, tvid, prodid, lang='', show_result=None, imdb_info_result=None):
        # type: (int, int, Text, Optional[Row], Optional[Union[Row, Dict]]) -> None
        super(TVShow, self).__init__(tvid, prodid, lang)

        self.unique_name = ''
        self.tvid = int(tvid)
        self.prodid = int(prodid)
        self.sid_int = self.create_sid(self.tvid, self.prodid)
        if None is not helpers.find_show_by_id(self.sid_int, check_multishow=True):
            raise exceptions_helper.MultipleShowObjectsException('Can\'t create a show if it already exists')

        self._airtime = None  # type: Optional[datetime.time]
        self._cast_list = None  # type: Optional[ReferenceType[List[Character]]]
        self._last_found_on_indexer = -1  # type: int
        self._location = self.path = ''  # type: AnyStr
        # self._is_location_good = None
        self._network_country = None  # type: Optional[AnyStr]
        self._network_country_code = None  # type: Optional[AnyStr]
        self._network_id = None  # type: Optional[int]
        self._network_is_stream = None  # type: Optional[bool]
        self._not_found_count = None  # type: None or int
        self._paused = 0
        self._src_update_time = None  # type: Optional[integer_types]

        self.internal_ids = {}  # type: Dict
        self.internal_timezone = None  # type: Optional[AnyStr]
        self.lock = threading.RLock()
        self.nextaired = ''  # type: AnyStr
        # noinspection added so that None _can_ be excluded from type annotation
        # so that this property evaluates directly to the class on ctrl+hover instead of "multiple implementations"
        # noinspection PyTypeChecker
        self.release_groups = None  # type: AniGroupList
        self.sxe_ep_obj = {}  # type: Dict

        self.load_from_db(show_result=show_result, imdb_info_result=imdb_info_result)

    def _get_end_episode(self, last=False, exclude_specials=False):
        # type: (bool, bool) -> Optional[TVEpisode]
        eps = self.get_all_episodes()
        if eps:
            ed = datetime.date(1900, 1, 1)
            return next(iter(sorted(
                (_ep for _ep in eps if _ep.airdate > ed and (not exclude_specials or _ep.season != 0)),
                key=lambda a: a.airdate, reverse=last)), None)

    @property
    def first_aired_episode(self):
        # type: (...) -> Optional[TVEpisode]
        """
        returns first aired episode
        """
        return self._get_end_episode()

    @property
    def first_aired_regular_episode(self):
        # type: (...) -> Optional[TVEpisode]
        """
        returns first aired regular episode
        """
        return self._get_end_episode(exclude_specials=True)

    @property
    def latest_aired_episode(self):
        # type: (...) -> Optional[TVEpisode]
        """
        returns latest aired episode
        """
        return self._get_end_episode(last=True)

    @property
    def latest_aired_regular_episode(self):
        # type: (...) -> Optional[TVEpisode]
        """
        returns latest aired regular episode
        """
        return self._get_end_episode(last=True, exclude_specials=True)

    @property
    def cast_list(self):
        # type: (...) -> List[Character]
        if None is self._cast_list or (isinstance(self._cast_list, ReferenceType) and None is self._cast_list()):
            v = self._load_cast_from_db()
            self._cast_list = weakref.ref(v)
            return self._cast_list()
        return self._cast_list()

    @cast_list.setter
    def cast_list(self, value):
        # type: (WeakList[Character]) -> None
        self._cast_list = None if not isinstance(value, WeakList) else weakref.ref(value)

    @property
    def network_id(self):
        return self._network_id

    @network_id.setter
    def network_id(self, *args):
        self.dirty_setter('_network_id')(self, *args)

    @property
    def network_country(self):
        return self._network_country

    @network_country.setter
    def network_country(self, *args):
        self.dirty_setter('_network_country')(self, *args)

    @property
    def network_country_code(self):
        return self._network_country_code

    @network_country_code.setter
    def network_country_code(self, *args):
        self.dirty_setter('_network_country_code')(self, *args)

    @property
    def network_is_stream(self):
        return self._network_is_stream

    @network_is_stream.setter
    def network_is_stream(self, *args):
        self.dirty_setter('_network_is_stream')(self, *args)

    @property
    def airtime(self):
        return self._airtime

    @airtime.setter
    def airtime(self, *args):
        self.dirty_setter('_airtime')(self, *args)

    @property
    def timezone(self):
        return self.internal_timezone

    @timezone.setter
    def timezone(self, *args):
        self.dirty_setter('internal_timezone')(self, *args)

    @staticmethod
    def create_sid(tvid, prodid):
        # type: (int, int) -> int
        return int(prodid) << prodid_bitshift | int(tvid)

    @property
    def _tvid(self):
        return self.tvid

    @_tvid.setter
    def _tvid(self, val):
        self.dirty_setter('tvid')(self, int(val))
        self.tvid_prodid = self.create_sid(val, self.prodid)
        # TODO: remove the following when indexer is gone
        # in deprecation transition, tvid also sets indexer so that existing uses continue to work normally
        self.dirty_setter('_indexer')(self, int(val))

    @property
    def _prodid(self):
        return self.prodid

    @_prodid.setter
    def _prodid(self, val):
        # type: (int) -> None
        self.dirty_setter('prodid')(self, int(val))
        self.tvid_prodid = self.create_sid(self.tvid, val)
        # TODO: remove the following when indexerid is gone
        # in deprecation transition, prodid also sets indexerid so that existing usages continue as normal
        self.dirty_setter('_indexerid')(self, int(val))

    @property
    def tvid_prodid(self):
        # type: (...) -> AnyStr
        return TVidProdid({self.tvid: self.prodid})()

    @tvid_prodid.setter
    def tvid_prodid(self, val):
        tvid_prodid_obj = TVidProdid(val)
        if getattr(self, 'tvid_prodid', None) != tvid_prodid_obj():
            self.tvid, self.prodid = tvid_prodid_obj.list
            self.dirty = True
        tvid_prodid_int = int(tvid_prodid_obj)
        if getattr(self, 'sid_int', None) != tvid_prodid_int:
            self.sid_int = tvid_prodid_int

    def helper_load_failed_db(self, sql_result=None):
        # type: (Optional[Row, Dict]) -> None
        if None is self._not_found_count or -1 == self._last_found_on_indexer:
            if sql_result and self.prodid == sql_result['indexer_id'] and self.tvid == sql_result['indexer']:
                sql_result = [sql_result]
            else:
                my_db = db.DBConnection()
                sql_result = my_db.select(
                    """
                    SELECT fail_count, last_success
                    FROM tv_shows_not_found
                    WHERE indexer = ? AND indexer_id = ?
                    """, [self.tvid, self.prodid])
            if sql_result:
                self._not_found_count = helpers.try_int(sql_result[0]['fail_count'])
                self._last_found_on_indexer = helpers.try_int(sql_result[0]['last_success'])
            else:
                self._not_found_count = 0
                self._last_found_on_indexer = 0

    @property
    def not_found_count(self):
        self.helper_load_failed_db()
        return self._not_found_count

    @not_found_count.setter
    def not_found_count(self, v):
        if isinstance(v, integer_types) and v != self._not_found_count:
            self._last_found_on_indexer = self.last_found_on_indexer
            my_db = db.DBConnection()
            # noinspection PyUnresolvedReferences
            last_check = SGDatetime.timestamp_near()
            # in case of flag change (+/-) don't change last_check date
            if abs(v) == abs(self._not_found_count):
                sql_result = my_db.select(
                    """
                    SELECT last_check
                    FROM tv_shows_not_found
                    WHERE indexer = ? AND indexer_id = ?
                    """, [self.tvid, self.prodid])
                if sql_result:
                    last_check = helpers.try_int(sql_result[0]['last_check'])
            my_db.upsert('tv_shows_not_found',
                         dict(fail_count=v, last_check=last_check, last_success=self._last_found_on_indexer),
                         dict(indexer=self.tvid, indexer_id=self.prodid))
            self._not_found_count = v

    @property
    def last_found_on_indexer(self):
        self.helper_load_failed_db()
        return (self._last_found_on_indexer, self.last_update_indexer)[0 >= self._last_found_on_indexer]

    def inc_not_found_count(self):
        my_db = db.DBConnection()
        sql_result = my_db.select(
            """
            SELECT last_check
            FROM tv_shows_not_found
            WHERE indexer = ? AND indexer_id = ?
            """, [self.tvid, self.prodid])
        days = (show_not_found_retry_days - 1, 0)[abs(self.not_found_count) <= concurrent_show_not_found_days]
        if not sql_result or datetime.datetime.fromtimestamp(helpers.try_int(sql_result[0]['last_check'])) + \
                datetime.timedelta(days=days, hours=18) < datetime.datetime.now():
            self.not_found_count += (-1, 1)[0 <= self.not_found_count]

    def reset_not_found_count(self):
        if 0 != self.not_found_count:
            self._not_found_count = 0
            self._last_found_on_indexer = 0
            my_db = db.DBConnection()
            my_db.action(
                """
                DELETE FROM tv_shows_not_found
                WHERE indexer = ? AND indexer_id = ?
                """, [self.tvid, self.prodid])

    @property
    def paused(self):
        """
        :rtype: bool
        """
        return self._paused

    @paused.setter
    def paused(self, value):
        if value != self._paused:
            if isinstance(value, bool) or (isinstance(value, integer_types) and value in [0, 1]):
                self._paused = int(value)
                self.dirty = True
            else:
                logger.error('tried to set paused property to invalid value: %s of type: %s' % (value, type(value)))

    @property
    def ids(self):
        if not self.internal_ids:
            acquired_lock = self.lock.acquire(False)
            if acquired_lock:
                try:
                    indexermapper.map_indexers_to_show(self)
                finally:
                    self.lock.release()
        return self.internal_ids

    @ids.setter
    def ids(self, value):
        if isinstance(value, dict):
            for cur_key, cur_value in iteritems(value):
                if cur_key not in indexermapper.indexer_list or \
                        not isinstance(cur_value, dict) or \
                        not isinstance(cur_value.get('id'), integer_types) or \
                        not isinstance(cur_value.get('status'), integer_types) or \
                        cur_value.get('status') not in indexermapper.MapStatus.allstatus or \
                        not isinstance(cur_value.get('date'), datetime.date):
                    return
            self.internal_ids = value

    @property
    def is_anime(self):
        # type: (...) -> bool
        return 0 < int(self.anime)

    @property
    def is_sports(self):
        # type: (...) -> bool
        return 0 < int(self.sports)

    @property
    def is_scene(self):
        # type: (...) -> bool
        return 0 < int(self.scene)

    def _get_location(self):
        # type: (...) -> AnyStr
        # no dir check needed if missing show dirs are created during post-processing
        if sickgear.CREATE_MISSING_SHOW_DIRS:
            return self._location

        if os.path.isdir(self._location):
            return self._location

        raise exceptions_helper.ShowDirNotFoundException('Show folder does not exist: \'%s\'' % self._location)

    def _set_location(self, new_location):
        # type: (AnyStr) -> None
        logger.debug('Setter sets location to %s' % new_location)
        # Don't validate dir if user wants to add shows without creating a dir
        if sickgear.ADD_SHOWS_WO_DIR or os.path.isdir(new_location):
            self.dirty_setter('_location')(self, new_location)
            self.path = new_location
            # self._is_location_good = True
        else:
            raise exceptions_helper.NoNFOException('Invalid folder for the show!')

    location = property(_get_location, _set_location)

    # delete references to anything that's not in the internal lists
    def flush_episodes(self):

        for cur_season_number in self.sxe_ep_obj:
            for cur_ep_number in self.sxe_ep_obj[cur_season_number]:
                # noinspection PyUnusedLocal
                ep_obj = self.sxe_ep_obj[cur_season_number][cur_ep_number]
                self.sxe_ep_obj[cur_season_number][cur_ep_number] = None
                del ep_obj

    def get_all_episodes(self, season=None, has_location=False, check_related_eps=True):
        # type: (Optional[integer_types], bool, bool) -> List[TVEpisode]
        """

        :param season: None or season number
        :param has_location:  return only with location
        :param check_related_eps: get related episodes
        :return: List of TVEpisode objects
        """
        sql_selection = 'SELECT *'

        if check_related_eps:
            # subselection to detect multi-episodes early, share_location > 0
            sql_selection += """
            , (SELECT COUNT (*)
               FROM tv_episodes
               WHERE showid = tve.showid AND indexer = tve.indexer AND season = tve.season AND location != ''
               AND location = tve.location AND episode != tve.episode
            ) AS share_location
            """

        sql_selection += ' FROM tv_episodes tve WHERE indexer = ? AND showid = ?'
        sql_parameter = [self.tvid, self.prodid]

        if None is not season:
            sql_selection += ' AND season = ?'
            sql_parameter += [season]

        if has_location:
            sql_selection += ' AND location != "" '

        # need ORDER episode ASC to rename multi-episodes in order S01E01-02
        sql_selection += ' ORDER BY season ASC, episode ASC'

        my_db = db.DBConnection()
        sql_result = my_db.select(sql_selection, sql_parameter)

        ep_obj_list = []
        for cur_row in sql_result:
            ep_obj = self.get_episode(int(cur_row['season']), int(cur_row['episode']), ep_result=[cur_row])
            if ep_obj:
                ep_obj.related_ep_obj = []
                if check_related_eps and ep_obj.location:
                    # if there is a location, check if it's a multi-episode (share_location > 0)
                    # and put into related_ep_obj
                    if 0 < cur_row['share_location']:
                        # noinspection SqlRedundantOrderingDirection
                        related_ep_sql_result = my_db.select(
                            """
                            SELECT * 
                            FROM tv_episodes
                            WHERE indexer = ? AND showid = ? AND season = ? AND location = ? AND episode != ? 
                            ORDER BY episode ASC
                            """, [self.tvid, self.prodid, ep_obj.season, ep_obj.location, ep_obj.episode])
                        for cur_ep_row in related_ep_sql_result:
                            related_ep_obj = self.get_episode(int(cur_ep_row['season']),
                                                              int(cur_ep_row['episode']),
                                                              ep_result=[cur_ep_row])
                            if related_ep_obj not in ep_obj.related_ep_obj:
                                ep_obj.related_ep_obj.append(related_ep_obj)
                ep_obj_list.append(ep_obj)

        return ep_obj_list

    def get_episode(self,
                    season=None,  # type: Optional[int]
                    episode=None,  # type: Optional[int]
                    path=None,  # type: Optional[AnyStr]
                    no_create=False,  # type: bool
                    absolute_number=None,  # type: Optional[int]
                    ep_result=None,  # type: Optional[List[Row]]
                    existing_only=False  # type: bool
                    ):  # type: (...) -> Optional[TVEpisode]
        """
        Initialise sxe_ep_obj with db fetched season keys, and then fill the TVShow episode property
        and return an TVEpisode object if no_create is False

        :param season: Season number
        :param episode: Episode number
        :param path: path to file episode
        :param no_create: return None instead of an instantiated TVEpisode object
        :param absolute_number: absolute number
        :param ep_result:
        :param existing_only: only return existing episodes
        :return: TVEpisode object
        """
        # if we get an anime get the real season and episode
        if self.is_anime and absolute_number and not season and not episode:
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT season, episode
                FROM tv_episodes
                WHERE indexer = ? AND showid = ? AND absolute_number = ? AND season != 0
                LIMIT 2
                """, [self.tvid, self.prodid, absolute_number])

            if 1 != len(sql_result):
                msg = 'found for absolute number: %s in show: %s' % (absolute_number, self._name)
                if not len(sql_result):
                    logger.debug('No entries %s' % msg)
                else:
                    logger.error('Multiple entries %s' % msg)
                return

            season = int(sql_result[0]['season'])
            episode = int(sql_result[0]['episode'])
            logger.debug('Found episode by absolute_number: %s which is %sx%s' % (absolute_number, season, episode))

        if season not in self.sxe_ep_obj:
            self.sxe_ep_obj[season] = {}

        if episode not in self.sxe_ep_obj[season] or None is self.sxe_ep_obj[season][episode]:
            if no_create:
                return

            # logger.debug('%s: An object for episode %sx%s did not exist in the cache, trying to create it' %
            #              (self.tvid_prodid, season, episode))

            if path and not existing_only:
                ep_obj = TVEpisode(self, season, episode, path, show_result=ep_result)
            else:
                ep_obj = TVEpisode(self, season, episode, show_result=ep_result, existing_only=existing_only)

            if None is not ep_obj:
                self.sxe_ep_obj[season][episode] = ep_obj

        return self.sxe_ep_obj[season][episode]

    def _load_cast_from_db(self):
        # type: (...) -> List[Character]
        # cast_list = []
        old_cast = [] if None is self._cast_list else self._cast_list()
        old_list = {c.id for c in old_cast or []}
        my_db = db.DBConnection()
        sql_result = my_db.select(
            """
            SELECT castlist.sort_order AS sort_order, characters.name AS name,
            characters.bio AS c_bio, characters.id AS c_id,
            characters.image_url AS image_url, characters.thumb_url AS thumb_url,
            characters.updated AS c_updated, castlist.updated AS cast_updated,
            persons.name AS p_name, persons.gender AS gender, persons.bio AS p_bio,
            persons.birthdate AS birthdate, persons.thumb_url AS p_thumb,
            persons.image_url AS p_image, persons.deathdate AS deathdate, persons.id AS p_id,
            persons.birthplace AS birthplace, persons.updated AS p_updated,
            persons.deathplace AS deathplace, persons.height AS height,
            persons.realname AS realname, persons.nicknames AS nicknames,
            persons.akas AS akas,            
            (SELECT group_concat(person_ids.src || ':' || person_ids.src_id, ';;;')
            FROM person_ids WHERE person_ids.person_id = persons.id) AS p_ids,
            (SELECT group_concat(character_ids.src || ':' || character_ids.src_id, ';;;')
            FROM character_ids WHERE character_ids.character_id = characters.id) AS c_ids,
            (SELECT group_concat(character_person_years.person_id || ':' ||
            character_person_years.start_year || '-' || character_person_years.end_year, ';;;')
            FROM character_person_years WHERE
            character_person_years.character_id = characters.id) AS p_years
            FROM castlist
            LEFT JOIN character_person_map
            ON castlist.character_id = character_person_map.character_id
            LEFT JOIN characters ON character_person_map.character_id = characters.id
            LEFT JOIN persons ON character_person_map.person_id = persons.id
            WHERE castlist.indexer = ? AND castlist.indexer_id = ?
            ORDER BY castlist.sort_order       
            """, [self.tvid, self.prodid])
        old_cast = old_cast or []
        for cur_row in sql_result:
            existing_character = next(
                (c for c in old_cast or [] if None is not c.id and c.id == cur_row['c_id']),
                None)  # type: Optional[Character]
            birthdate = try_int(cur_row['birthdate'], None)
            birthdate = birthdate and datetime.date.fromordinal(cur_row['birthdate'])
            deathdate = try_int(cur_row['deathdate'], None)
            deathdate = deathdate and datetime.date.fromordinal(cur_row['deathdate'])
            p_years = {}
            for cur_p in (cur_row['p_years'] and cur_row['p_years'].split(';;;')) or []:
                p_id, py = cur_p.split(':', 1)
                start, end = py.split('-', 1)
                p_years[int(p_id)] = {'start': try_int(start, None), 'end': try_int(end, None)}

            p_ids, c_ids = {}, {}
            for cur_i in (cur_row['p_ids'] and cur_row['p_ids'].split(';;;')) or []:
                k, v = cur_i.split(':', 1)
                k = try_int(k, None)
                if v:
                    if k in (TVINFO_INSTAGRAM, TVINFO_TWITTER, TVINFO_FACEBOOK, TVINFO_WIKIPEDIA, TVINFO_TIKTOK,
                             TVINFO_FANSITE, TVINFO_YOUTUBE, TVINFO_REDDIT, TVINFO_LINKEDIN, TVINFO_WIKIDATA):
                        p_ids[k] = v
                    else:
                        p_ids[k] = try_int(v, None)
            for cur_i in (cur_row['c_ids'] and cur_row['c_ids'].split(';;;')) or []:
                k, v = cur_i.split(':', 1)
                v = try_int(v, None)
                if v:
                    c_ids[int(k)] = try_int(v, None)
            person = Person(cur_row['p_name'], cur_row['gender'],
                            akas=set((cur_row['akas'] and cur_row['akas'].split(';;;')) or []),
                            bio=cur_row['p_bio'],
                            birthday=birthdate, birthplace=cur_row['birthplace'],
                            deathday=deathdate, deathplace=cur_row['deathplace'],
                            height=cur_row['height'],
                            ids=p_ids,
                            image_url=cur_row['p_image'],
                            nicknames=set((cur_row['nicknames'] and cur_row['nicknames'].split(';;;')) or []),
                            real_name=cur_row['realname'], show_obj=self, sid=cur_row['p_id'],
                            thumb_url=cur_row['p_thumb'], updated=cur_row['p_updated'])
            if existing_character:
                existing_character.updated = cur_row['cast_updated']
                try:
                    old_list.remove(existing_character.id)
                except (BaseException, Exception):
                    pass
                existing_person = next((_p for _p in existing_character.person if (None is not _p.id
                                        and _p.ids.get(self.tvid) == person.ids.get(self.tvid))
                                        or _p.name == person.name),
                                       None)  # type: Optional[Person]
                existing_character.combine_start_end_years(p_years)
                if existing_person:
                    existing_person.update_properties(
                        akas=set((cur_row['akas'] and cur_row['akas'].split(';;;')) or []),
                        biography=person.biography,
                        birthday=person.birthday, birthplace=person.birthplace,
                        deathday=person.deathday, deathplace=cur_row['deathplace'],
                        gender=person.gender, height=cur_row['height'],
                        ids=dict(chain.from_iterable(iteritems(_d) for _d in (existing_person.ids, person.ids or {}))),
                        image_url=person.image_url, name=person.name,
                        nicknames=set((cur_row['nicknames'] and cur_row['nicknames'].split(';;;')) or []),
                        real_name=cur_row['realname'], thumb_url=person.thumb_url
                    )
                else:
                    existing_character.person.append(person)
            else:
                old_cast.append(Character(
                    cur_row['name'],
                    bio=cur_row['c_bio'], ids=c_ids, image_url=cur_row['image_url'], person=[person],
                    persons_years=p_years, show_obj=self, sid=cur_row['c_id'],
                    thumb_url=cur_row['thumb_url'], updated=cur_row['cast_updated']))
        cast_list = WeakList(c for c in old_cast or [] if c.id not in old_list)
        self.cast_list = cast_list
        return cast_list

    def cast_list_id(self):
        # type: (...) -> Set
        """
        return an identifier that represents the current state of the show cast list

        used to tell if a change has occurred in a cast list after time/process
        """
        return set((_c.name, _c.image_url or '', _c.thumb_url or '',
                    hash(*([', '.join(_p.name for _p in _c.person or [] if _p.name)])))
                   for _c in self.cast_list or [] if _c.name)

    @staticmethod
    def orphaned_cast_sql():
        # type: (...) -> List
        """
        returns list of sql that removes all character and person entries that are not linked to any show
        """
        return [
            ['DELETE FROM castlist WHERE castlist.id IN (SELECT c.id FROM castlist c'
             ' LEFT JOIN tv_shows ON tv_shows.indexer = c.indexer AND tv_shows.indexer_id = c.indexer_id'
             ' WHERE tv_shows.indexer_id is NULL);'],
            ['DELETE FROM characters WHERE characters.id IN (SELECT c.id FROM characters c'
             ' LEFT JOIN castlist on castlist.character_id = c.id WHERE castlist.id is NULL);'],
            ['DELETE FROM character_ids WHERE character_ids.character_id IN'
             ' (SELECT c.character_id FROM character_ids c'
             ' LEFT JOIN characters ON c.character_id = characters.id WHERE characters.id is NULL);'],
            ['DELETE FROM character_person_map WHERE character_id IN (SELECT c.character_id FROM character_person_map c'
             ' LEFT JOIN characters ON c.character_id = characters.id WHERE characters.id is NULL)'],
            ['DELETE FROM persons WHERE persons.id IN (SELECT p.id FROM persons p'
             ' LEFT JOIN character_person_map c on p.id = c.person_id WHERE c.id is NULL);'],
            ['DELETE FROM person_ids WHERE person_ids.person_id IN (SELECT p.person_id FROM person_ids p'
             ' LEFT JOIN persons ON p.person_id = persons.id WHERE persons.id is NULL);'],
            ['DELETE FROM castlist WHERE castlist.id IN (SELECT c.id FROM castlist c'
             ' LEFT JOIN character_person_map cpm on c.character_id = cpm.character_id WHERE cpm.id IS NULL);'],
            ['DELETE FROM character_person_years WHERE character_person_years.ROWID IN (SELECT c.ROWID FROM'
             ' character_person_years c'
             ' LEFT JOIN characters ch on c.character_id = ch.id WHERE ch.id IS NULL);'],
            ['DELETE FROM character_person_years WHERE character_person_years.ROWID IN (SELECT c.ROWID FROM'
             ' character_person_years c'
             ' LEFT JOIN persons p on c.person_id = p.id WHERE p.id IS NULL);'],
        ]

    def _save_cast_list(self, removed_char_ids=None, force=False, stop_event=None, cast_list=None):
        # type: (Union[List[integer_types], Set[integer_types]], bool, threading.Event, List[Character]) -> None
        if cast_list:
            my_db = db.DBConnection()
            cl = []
            for cur_id in removed_char_ids or []:
                cl.extend([[
                    """
                    DELETE FROM castlist
                    WHERE indexer = ? AND indexer_id = ? AND character_id = ?;
                    """, [self.tvid, self.prodid, cur_id]]
                ])
            update_date = datetime.date.today().toordinal()
            for cur_enum, cur_cast in enumerate(cast_list, 1):
                if stop_event and stop_event.is_set():
                    return
                cur_cast.save_to_db(show_obj=self, force=force, stop_event=stop_event)
                cl.extend([[
                    """
                    UPDATE castlist SET sort_order = ?, updated = ?
                    WHERE indexer = ? AND indexer_id = ?
                    AND character_id = ?;
                    """, [cur_enum, update_date, self.tvid, self.prodid, cur_cast.id]
                ], [
                    """
                    INSERT INTO castlist (indexer, indexer_id, character_id, sort_order, updated)
                    SELECT %s, %s, %s, %s, %s WHERE changes() == 0;
                    """ % (self.tvid, self.prodid, cur_cast.id, cur_enum, update_date)]
                ])
            if removed_char_ids:
                # remove orphaned entries
                cl.extend(self.orphaned_cast_sql())
            if cl:
                my_db.mass_action(cl)

    def should_update(self, update_date=datetime.date.today(), last_indexer_change=None):
        # type: (datetime.date, integer_types) -> bool
        if last_indexer_change and self._src_update_time:
            # update if show was updated or not updated within the last 30 days
            if self._src_update_time < last_indexer_change or \
                    (self._last_update_indexer and datetime.date.today().toordinal() - self._last_update_indexer > 30):
                return True
            return False

        # In some situations self.status = None, need to figure out where that is!
        if not self._status:
            self.status = ''
            logger.debug(f'Status missing for show: [{self.tvid_prodid}] with status: [{self._status}]')

        last_update_indexer = datetime.date.fromordinal(self._last_update_indexer)

        # if show was not found for 1 week, only retry to update once a week
        if (concurrent_show_not_found_days < abs(self.not_found_count)) \
                and (update_date - last_update_indexer) < datetime.timedelta(days=show_not_found_retry_days):
            return False

        my_db = db.DBConnection()
        sql_result = my_db.mass_action([[
            """
            SELECT airdate
            FROM [tv_episodes]
            WHERE indexer = ? AND showid = ? AND season > 0
            ORDER BY season DESC, episode DESC
            LIMIT 1
            """, [self.tvid, self.prodid]
        ], [
            """
            SELECT airdate
            FROM [tv_episodes]
            WHERE indexer = ? AND showid = ? AND season > 0 AND airdate > 1
            ORDER BY airdate DESC
            LIMIT 1
            """, [self.tvid, self.prodid]]])

        last_airdate_unknown = 1 >= int(sql_result[0][0]['airdate']) if sql_result and sql_result[0] else True

        last_airdate = datetime.date.fromordinal(sql_result[1][0]['airdate']) \
            if sql_result and sql_result[1] else datetime.date.fromordinal(1)

        # if show is not 'Ended' and last episode aired less than 460 days ago
        # or don't have an airdate for the last episode always update (status 'Continuing' or '')
        update_days_limit = 2013
        ended_limit = datetime.timedelta(days=update_days_limit)
        if 'Ended' not in self._status and (last_airdate == datetime.date.fromordinal(1)
                                            or last_airdate_unknown
                                            or (update_date - last_airdate) <= ended_limit
                                            or (update_date - last_update_indexer) > ended_limit):
            return True

        # in the first 460 days (last airdate), update regularly
        airdate_diff = update_date - last_airdate
        last_update_diff = update_date - last_update_indexer

        update_step_list = [[60, 1], [120, 3], [180, 7], [1281, 15], [update_days_limit, 30]]
        for cur_date_diff, cur_iv in update_step_list:
            if airdate_diff <= datetime.timedelta(days=cur_date_diff) \
                    and last_update_diff >= datetime.timedelta(days=cur_iv):
                return True

        # update shows without an airdate for the last episode for update_days_limit days every 7 days
        return last_airdate_unknown and airdate_diff <= ended_limit and last_update_diff >= datetime.timedelta(days=7)

    def write_show_nfo(self, force=False):
        # type: (bool) -> bool

        result = False

        if not os.path.isdir(self._location):
            logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
            return False

        logger.log('%s: Writing NFOs for show' % self.tvid_prodid)
        for cur_provider in itervalues(sickgear.metadata_provider_dict):
            result = cur_provider.create_show_metadata(self, force) or result

        return result

    def write_metadata(self, show_only=False, force=False):
        # type:(bool, bool) -> None
        """
        :param show_only: only for show
        :param force:
        """
        if not os.path.isdir(self._location):
            logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
            return

        self.get_images()

        force_nfo = force or not db.DBConnection().has_flag('kodi_nfo_uid')

        self.write_show_nfo(force_nfo)

        if not show_only:
            self.write_episode_nfo(force_nfo)

    def write_episode_nfo(self, force=False):
        # type: (bool) -> None

        if not os.path.isdir(self._location):
            logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
            return

        logger.log('%s: Writing NFOs for all episodes' % self.tvid_prodid)

        my_db = db.DBConnection()
        # noinspection SqlResolve
        sql_result = my_db.select(
            """
            SELECT *
            FROM tv_episodes
            WHERE indexer = ? AND showid = ? AND location != ''
            """, [self.tvid, self.prodid])

        processed = []
        for cur_row in sql_result:
            if (cur_row['season'], cur_row['episode']) in processed:
                continue
            logger.debug(f'{self.tvid_prodid}: Retrieving/creating episode {cur_row["season"]}x{cur_row["episode"]}')
            ep_obj = self.get_episode(cur_row['season'], cur_row['episode'], ep_result=[cur_row])
            if not ep_obj.related_ep_obj:
                processed += [(cur_row['season'], cur_row['episode'])]
            else:
                logger.debug(f'{self.tvid_prodid}: Found related to {cur_row["season"]}x{cur_row["episode"]} episode(s)'
                             f'... {", ".join(["%sx%s" % (_ep.season, _ep.episode) for _ep in ep_obj.related_ep_obj])}')
                processed += list(set([(cur_row['season'], cur_row['episode'])] +
                                      [(_ep.season, _ep.episode) for _ep in ep_obj.related_ep_obj]))
            ep_obj.create_meta_files(force)

    def update_metadata(self):

        if not os.path.isdir(self._location):
            logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
            return

        self.update_show_nfo()

    def update_show_nfo(self):

        result = False

        if not os.path.isdir(self._location):
            logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
            return False

        logger.log('%s: Updating NFOs for show with new TV info' % self.tvid_prodid)
        for cur_provider in itervalues(sickgear.metadata_provider_dict):
            try:
                result = cur_provider.update_show_indexer_metadata(self) or result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show nfo: %s' % ex(e))

        return result

    # find all media files in the show folder and create episodes for as many as possible
    def load_episodes_from_dir(self):

        if not os.path.isdir(self._location):
            logger.log('%s: Show directory doesn\'t exist, not loading episodes from disk' % self.tvid_prodid)
            return

        logger.log('%s: Loading all episodes from the show directory %s' % (self.tvid_prodid, self._location))

        # get file list
        file_list = helpers.list_media_files(self._location)

        # create TVEpisodes from each media file (if possible)
        sql_l = []
        for cur_media_file in file_list:
            parse_result = None
            ep_obj = None

            logger.debug('%s: Creating episode from %s' % (self.tvid_prodid, cur_media_file))
            try:
                ep_obj = self.ep_obj_from_file(os.path.join(self._location, cur_media_file))
            except (exceptions_helper.ShowNotFoundException, exceptions_helper.EpisodeNotFoundException) as e:
                logger.error('Episode %s returned an exception: %s' % (cur_media_file, ex(e)))
                continue
            except exceptions_helper.EpisodeDeletedException:
                logger.debug('The episode deleted itself when I tried making an object for it')

            if None is ep_obj:
                continue

            # see if we should save the release name in the db
            ep_file_name = os.path.basename(ep_obj.location)
            ep_file_name = os.path.splitext(ep_file_name)[0]

            try:
                parse_result = None
                np = NameParser(False, show_obj=self)
                parse_result = np.parse(ep_file_name)
            except (InvalidNameException, InvalidShowException):
                pass

            if ep_file_name and parse_result and None is not parse_result.release_group and not ep_obj.release_name:
                logger.debug(f'Name {ep_file_name} gave release group of {parse_result.release_group}, seems valid')
                ep_obj.release_name = ep_file_name

            # store the reference in the show
            if None is not ep_obj:
                if sickgear.USE_SUBTITLES and self.subtitles:
                    try:
                        ep_obj.refresh_subtitles()
                    except (BaseException, Exception):
                        logger.error('%s: Could not refresh subtitles' % self.tvid_prodid)
                        logger.error(traceback.format_exc())

                result = ep_obj.get_sql()
                if None is not result:
                    sql_l.append(result)

        if 0 < len(sql_l):
            my_db = db.DBConnection()
            my_db.mass_action(sql_l)

    def load_episodes_from_db(self, update=False):
        # type: (bool) -> Dict[int, Dict[int, TVEpisode]]
        """

        :param update:
        :return:
        """
        logger.log('Loading all episodes for [%s] from the DB' % self._name)

        my_db = db.DBConnection()
        sql_result = my_db.select(
            """
            SELECT *
            FROM tv_episodes
            WHERE indexer = ? AND showid = ?
            """, [self.tvid, self.prodid])

        scanned_eps = {}

        tvinfo_config = sickgear.TVInfoAPI(self.tvid).api_params.copy()

        if self._lang:
            tvinfo_config['language'] = self._lang

        if 0 != self._dvdorder:
            tvinfo_config['dvdorder'] = True

        t = sickgear.TVInfoAPI(self.tvid).setup(**tvinfo_config)

        cached_show = None
        try:
            cached_show = t.get_show(self.prodid, language=self._lang)
        except BaseTVinfoError as e:
            logger.warning(f'Unable to find cached seasons from {sickgear.TVInfoAPI(self.tvid).name}: {ex(e)}')

        if None is cached_show:
            return scanned_eps

        scene_sql_result = my_db.select(
            """
            SELECT * 
            FROM scene_numbering 
            WHERE indexer == ? AND indexer_id = ?
            """, [self.tvid, self.prodid])

        cached_seasons = {}
        cl = []
        for cur_row in sql_result:

            delete_ep = False

            season = int(cur_row['season'])
            episode = int(cur_row['episode'])

            if season not in cached_seasons:
                try:
                    cached_seasons[season] = cached_show[season]
                except BaseTVinfoSeasonnotfound as e:
                    logger.warning(f'Error when trying to load the episode for [{self._name}]'
                                   f' from {sickgear.TVInfoAPI(self.tvid).name}: {ex(e)}')
                    delete_ep = True

            if season not in scanned_eps:
                scanned_eps[season] = {}

            logger.debug('Loading episode %sx%s for [%s] from the DB' % (season, episode, self.name))

            try:
                ep_obj = self.get_episode(season, episode, ep_result=[cur_row])  # type: TVEpisode

                # if we found out that the ep is no longer on TVDB then delete it from our database too
                if delete_ep and helpers.should_delete_episode(ep_obj.status):
                    cl.extend(ep_obj.delete_episode(return_sql=True))
                else:

                    ep_obj.load_from_db(season, episode, show_result=[cur_row], scene_result=scene_sql_result)
                    ep_obj.load_from_tvinfo(tvapi=t, update=update, cached_show=cached_show)
                scanned_eps[season][episode] = True
            except exceptions_helper.EpisodeDeletedException:
                logger.debug(f'Tried loading an episode that should have been deleted from the DB [{self._name}],'
                             f' skipping it')
                continue

        if cl:
            my_db.mass_action(cl)

        return scanned_eps

    def switch_ep_change_sql(self, old_tvid, old_prodid, season, episode, reason):
        # type: (int, integer_types, int, int, int) -> List[AnyStr]
        return [
            """
            REPLACE INTO switch_ep_result
            (old_indexer, old_indexer_id, new_indexer, new_indexer_id, season, episode, reason)
            VALUES (?,?,?,?,?,?,?)
            """, [old_tvid, old_prodid, self.tvid, self.prodid, season, episode, reason]]

    def load_episodes_from_tvinfo(self, cache=True, update=False, tvinfo_data=None, switch=False, old_tvid=None,
                                  old_prodid=None):
        # type: (bool, bool, TVInfoShow, bool, int, integer_types) -> Optional[Dict[int, Dict[int, TVEpisode]]]
        """

        :param cache:
        :param update:
        :param tvinfo_data:
        :param switch:
        :param old_tvid:
        :param old_prodid:
        :return:
        """
        tvinfo_config = sickgear.TVInfoAPI(self.tvid).api_params.copy()

        if not cache:
            tvinfo_config['cache'] = False

        if self._lang:
            tvinfo_config['language'] = self._lang

        if 0 != self._dvdorder:
            tvinfo_config['dvdorder'] = True

        logger.log('%s: Loading all episodes for [%s] from %s..'
                   % (self.tvid_prodid, self._name, sickgear.TVInfoAPI(self.tvid).name))

        if getattr(tvinfo_data, 'id', None) == self.prodid:
            show_obj = tvinfo_data
            t = None
        else:
            try:
                t = sickgear.TVInfoAPI(self.tvid).setup(**tvinfo_config)
                show_obj = t.get_show(self.prodid, language=self._lang)
            except BaseTVinfoError:
                logger.error(f'{sickgear.TVInfoAPI(self.tvid).name} timed out,'
                             f' unable to update episodes for [{self._name}] from {sickgear.TVInfoAPI(self.tvid).name}')
                return None

        scanned_eps = {}

        my_db = db.DBConnection()
        sql_result = my_db.select(
            """
            SELECT * 
            FROM tv_episodes 
            WHERE indexer = ? AND showid = ?
            """, [self.tvid, self.prodid])
        sql_l = []
        for cur_season in show_obj:
            scanned_eps[cur_season] = {}
            for cur_episode in show_obj[cur_season]:
                # need some examples of wtf episode 0 means to decide if we want it or not
                if 0 == cur_episode:
                    continue
                try:
                    ep_obj = self.get_episode(cur_season, cur_episode, ep_result=sql_result)  # type: TVEpisode
                except exceptions_helper.EpisodeNotFoundException:
                    logger.log('%s: %s object for %sx%s from [%s] is incomplete, skipping this episode' %
                               (self.tvid_prodid, sickgear.TVInfoAPI(
                                   self.tvid).name, cur_season, cur_episode, self._name))
                    continue
                else:
                    try:
                        ep_obj.load_from_tvinfo(tvapi=t, update=update, cached_show=show_obj, switch=switch,
                                                old_tvid=old_tvid, old_prodid=old_prodid, switch_list=sql_l)
                    except exceptions_helper.EpisodeDeletedException:
                        logger.log('The episode from [%s] was deleted, skipping the rest of the load' % self._name)
                        continue

                with ep_obj.lock:
                    logger.debug(f'{self.tvid_prodid}: Loading info from {sickgear.TVInfoAPI(self.tvid).name}'
                                 f' for episode {cur_season}x{cur_episode} from [{self._name}]')
                    ep_obj.load_from_tvinfo(cur_season, cur_episode, tvapi=t, update=update, cached_show=show_obj,
                                            switch=switch, old_tvid=old_tvid, old_prodid=old_prodid,
                                            switch_list=sql_l)

                    result = ep_obj.get_sql()
                    if None is not result:
                        sql_l.append(result)

                scanned_eps[cur_season][cur_episode] = True

        if 0 < len(sql_l):
            my_db = db.DBConnection()
            my_db.mass_action(sql_l)

        # Done updating save last update date
        self.last_update_indexer = datetime.date.today().toordinal()
        self.save_to_db()

        return scanned_eps

    def get_images(self):
        fanart_result = poster_result = banner_result = False
        season_posters_result = season_banners_result = season_all_poster_result = season_all_banner_result = False

        for cur_provider in itervalues(sickgear.metadata_provider_dict):
            # FIXME: Needs to not show this message if the option is not enabled?
            logger.debug('Running metadata routines for %s' % cur_provider.name)

            try:
                fanart_result = cur_provider.create_fanart(self) or fanart_result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show fanart: %s' % ex(e))

            try:
                poster_result = cur_provider.create_poster(self) or poster_result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show poster: %s' % ex(e))

            try:
                banner_result = cur_provider.create_banner(self) or banner_result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show banner: %s' % ex(e))

            try:
                season_posters_result = cur_provider.create_season_posters(self) or season_posters_result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show season poster: %s' % ex(e))

            try:
                season_banners_result = cur_provider.create_season_banners(self) or season_banners_result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show season banner: %s' % ex(e))

            try:
                season_all_poster_result = cur_provider.create_season_all_poster(self) or season_all_poster_result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show season poster: %s' % ex(e))

            try:
                season_all_banner_result = cur_provider.create_season_all_banner(self) or season_all_banner_result
            except (BaseException, Exception) as e:
                logger.warning('Error creating show season banner: %s' % ex(e))

        return fanart_result or poster_result or banner_result or season_posters_result or season_banners_result \
            or season_all_poster_result or season_all_banner_result

    # make a TVEpisode object from a media file
    def ep_obj_from_file(self, path):
        # type: (AnyStr) -> Optional[TVEpisode]
        """

        :param path:
        :return:
        """
        if not os.path.isfile(path):
            logger.log('%s: Not a real file... %s' % (self.tvid_prodid, path))
            return None

        logger.debug('%s: Creating episode object from %s' % (self.tvid_prodid, path))

        try:
            my_parser = NameParser(show_obj=self)
            parse_result = my_parser.parse(path)
        except InvalidNameException:
            logger.debug('Unable to parse the filename %s into a valid episode' % path)
            return None
        except InvalidShowException:
            logger.debug('Unable to parse the filename %s into a valid show' % path)
            return None

        if not len(parse_result.episode_numbers):
            logger.log('parse_result: %s' % parse_result)
            logger.error('No episode number found in %s, ignoring it' % path)
            return None

        # for now let's assume that any episode in the show dir belongs to that show
        season_number = parse_result.season_number if None is not parse_result.season_number else 1
        episode_numbers = parse_result.episode_numbers
        root_ep_obj = None

        sql_l = []
        for cur_ep_num in episode_numbers:
            cur_ep_num = int(cur_ep_num)

            logger.debug('%s: %s parsed to %s %sx%s' % (self.tvid_prodid, path, self._name, season_number, cur_ep_num))

            check_quality_again = False
            same_file = False
            ep_obj = self.get_episode(season_number, cur_ep_num)

            if None is ep_obj:
                try:
                    ep_obj = self.get_episode(season_number, cur_ep_num, path)
                except exceptions_helper.EpisodeNotFoundException:
                    logger.error('%s: Unable to figure out what this file is, skipping' % self.tvid_prodid)
                    continue

            else:
                # if there is a new file associated with this ep then re-check the quality
                status, quality = sickgear.common.Quality.split_composite_status(ep_obj.status)

                if IGNORED == status:
                    continue

                if (ep_obj.location and os.path.normpath(ep_obj.location) != os.path.normpath(path)) or \
                        (not ep_obj.location and path) or \
                        (SKIPPED == status):
                    logger.debug('The old episode had a different file associated with it, re-checking the quality '
                                 'based on the new filename %s' % path)
                    check_quality_again = True

                with ep_obj.lock:
                    old_size = ep_obj.file_size if ep_obj.location and status != SKIPPED else 0
                    ep_obj.location = path
                    # if the sizes are the same then it's probably the same file
                    if old_size and ep_obj.file_size == old_size:
                        same_file = True
                    else:
                        same_file = False

                    ep_obj.check_for_meta_files()

            if None is root_ep_obj:
                root_ep_obj = ep_obj
            else:
                if ep_obj not in root_ep_obj.related_ep_obj:
                    root_ep_obj.related_ep_obj.append(ep_obj)

            # if it's a new file then
            if not same_file:
                ep_obj.release_name = ''

            # if user replaces a file, attempt to recheck the quality unless it's know to be the same file
            if check_quality_again and not same_file:
                new_quality = Quality.name_quality(path, self.is_anime)
                if Quality.UNKNOWN == new_quality:
                    new_quality = Quality.file_quality(path)
                logger.debug(f'Since this file was renamed, file {path}'
                             f' was checked and quality "{Quality.qualityStrings[new_quality]}" found')
                status, quality = sickgear.common.Quality.split_composite_status(ep_obj.status)
                if Quality.UNKNOWN != new_quality or status in (SKIPPED, UNAIRED):
                    ep_obj.status = Quality.composite_status(DOWNLOADED, new_quality)

            # check for status/quality changes as long as it's a new file
            elif not same_file and sickgear.helpers.has_media_ext(path)\
                    and ep_obj.status not in Quality.DOWNLOADED + Quality.ARCHIVED + [IGNORED]:

                old_status, old_quality = Quality.split_composite_status(ep_obj.status)
                new_quality = Quality.name_quality(path, self.is_anime)
                if Quality.UNKNOWN == new_quality:
                    new_quality = Quality.file_quality(path)
                    if Quality.UNKNOWN == new_quality:
                        new_quality = Quality.assume_quality(path)

                new_status = None

                # if it was snatched and now exists then set the status correctly
                if SNATCHED == old_status and old_quality <= new_quality:
                    logger.debug(f'STATUS: this episode used to be snatched with quality'
                                 f' {Quality.qualityStrings[old_quality]} but a file exists with quality'
                                 f' {Quality.qualityStrings[new_quality]} so setting the status to DOWNLOADED')
                    new_status = DOWNLOADED

                # if it was snatched proper, and we found a higher quality one then allow the status change
                elif SNATCHED_PROPER == old_status and old_quality < new_quality:
                    logger.debug(f'STATUS: this episode used to be snatched proper with quality'
                                 f' {Quality.qualityStrings[old_quality]} but a file exists with quality'
                                 f' {Quality.qualityStrings[new_quality]} so setting the status to DOWNLOADED')
                    new_status = DOWNLOADED

                elif old_status not in SNATCHED_ANY:
                    new_status = DOWNLOADED

                if None is not new_status:
                    with ep_obj.lock:
                        logger.debug(f'STATUS: we have an associated file, so setting the status from {ep_obj.status}'
                                     f' to DOWNLOADED/{Quality.composite_status(new_status, new_quality)}')
                        ep_obj.status = Quality.composite_status(new_status, new_quality)

            elif same_file:
                status, quality = Quality.split_composite_status(ep_obj.status)
                if status in (SKIPPED, UNAIRED):
                    new_quality = Quality.name_quality(path, self.is_anime)
                    if Quality.UNKNOWN == new_quality:
                        new_quality = Quality.file_quality(path)
                    logger.debug(f'Since this file has status: "{statusStrings[status]}", file {path}'
                                 f' was checked and quality "{Quality.qualityStrings[new_quality]}" found')
                    ep_obj.status = Quality.composite_status(DOWNLOADED, new_quality)

            with ep_obj.lock:
                result = ep_obj.get_sql()
                if None is not result:
                    sql_l.append(result)

        if 0 < len(sql_l):
            my_db = db.DBConnection()
            my_db.mass_action(sql_l)

        # creating metafiles on the root should be good enough
        if sickgear.USE_FAILED_DOWNLOADS and None is not root_ep_obj:
            with root_ep_obj.lock:
                root_ep_obj.create_meta_files()

        return root_ep_obj

    def load_from_db(self, show_result=None, imdb_info_result=None):
        # type: (Optional[Row], Optional[Union[Row, Dict]]) -> Optional[bool]
        """

        :return:
        """
        if not show_result or self.tvid != show_result['indexer'] or self.prodid != show_result['indexer_id']:
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT * 
                FROM tv_shows
                WHERE indexer = ? AND indexer_id = ?
                """, [self.tvid, self.prodid])

            if 1 != len(sql_result):
                if len(sql_result):
                    tvinfo_config = sickgear.TVInfoAPI(self.tvid).api_params.copy()
                    if self._lang:
                        tvinfo_config['language'] = self._lang
                    t = sickgear.TVInfoAPI(self.tvid).setup(**tvinfo_config)
                    cached_show = t.get_show(self.prodid, load_episodes=False, language=self._lang)
                    vals = (self.prodid, '' if not cached_show else ' [%s]' % cached_show['seriesname'].strip())
                    if len(sql_result):
                        logger.log('%s: Loading show info%s from database' % vals)
                        raise exceptions_helper.MultipleDBShowsException()
                logger.log(f'{self.tvid_prodid}: Unable to find the show{self.name} in the database')
                return

            show_result = next(iter(sql_result))

        if not self.tvid:
            self.tvid, self.prodid = int(show_result['indexer']), int(show_result['indexer_id'])

        self._air_by_date = show_result['air_by_date'] or 0
        self._airs = show_result['airs'] or ''
        self._airtime = self._make_airtime(show_result['airtime'])
        self._anime = show_result['anime'] or 0
        self._classification = None is self._classification and show_result['classification'] or ''
        self._dvdorder = show_result['dvdorder'] or 0
        self._flatten_folders = int(show_result['flatten_folders'])
        self._genre = '|'.join([_g for _g in (self._genre or show_result['genre'] or '').split('|') if _g])
        self._lang = self._lang or show_result['lang'] or ''
        self._last_update_indexer = show_result['last_update_indexer']
        self._name = self._name or show_result['show_name'] or ''
        self._network_country = show_result['network_country']
        self._network_country_code = show_result['network_country_code']
        self._network_id = show_result['network_id']
        self._network_is_stream = bool(show_result['network_is_stream'])
        self._overview = self._overview or show_result['overview'] or ''
        self._paused = int(show_result['paused'])
        self._prune = show_result['prune'] or 0
        self._quality = int(show_result['quality'])
        self._runtime = show_result['runtime']
        self._scene = show_result['scene'] or 0
        self._sports = show_result['sports'] or 0
        self._src_update_time = try_int(show_result['src_update_timestamp'], None)
        self._startyear = show_result['startyear'] or 0
        self._status = show_result['status'] or ''
        self._subtitles = show_result['subtitles'] and 1 or 0
        self._tag = show_result['tag'] or 'Show List'
        self._upgrade_once = show_result['archive_firstmatch'] or 0

        if not self._imdbid:
            imdbid = show_result['imdb_id'] or ''
            self._imdbid = ('', imdbid)[2 < len(imdbid)]

        self._rls_global_exclude_ignore = helpers.split_word_str(
            show_result['rls_global_exclude_ignore'])[0]

        self._rls_global_exclude_require = helpers.split_word_str(
            show_result['rls_global_exclude_require'])[0]

        self._rls_ignore_words, self._rls_ignore_words_regex = helpers.split_word_str(
            show_result['rls_ignore_words'])

        self._rls_require_words, self._rls_require_words_regex = helpers.split_word_str(
            show_result['rls_require_words'])

        self.internal_network = self.internal_network or show_result['network'] or ''

        self.internal_timezone = show_result['timezone']
        if not self.internal_timezone and self.internal_network:
            _, self.internal_timezone = network_timezones.get_network_timezone(self.internal_network,
                                                                               return_name=True)
        try:
            self.location = show_result['location']
        except (BaseException, Exception):
            self.dirty_setter('_location')(self, show_result['location'])
            # self._is_location_good = False

        self.release_groups = self._anime and AniGroupList(self.tvid, self.prodid, self.tvid_prodid) or None

        logger.log('Loaded.. {: <9} {: <8} {}'.format(
            sickgear.TVInfoAPI(self.tvid).config.get('name') + ',', '%s,' % self.prodid, self.name))

        # Get IMDb_info from database
        if not imdb_info_result or \
                self.tvid != imdb_info_result['indexer'] or self.prodid != imdb_info_result['indexer_id']:
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT *
                FROM imdb_info
                WHERE indexer = ? AND indexer_id = ?
                """, [self.tvid, self.prodid])
        else:
            sql_result = [imdb_info_result]

        if 0 < len(sql_result):
            # this keys() is not a dict
            if isinstance(sql_result[0], dict):
                self._imdb_info = sql_result[0]
            else:
                self._imdb_info = dict(zip(sql_result[0].keys(), [(_r, '')[None is _r] for _r in sql_result[0]]))
            if 'is_mini_series' in self._imdb_info:
                self._imdb_info['is_mini_series'] = bool(self._imdb_info['is_mini_series'])
        elif sickgear.USE_IMDB_INFO:
            logger.debug(f'{self.tvid_prodid}: The next show update will attempt to find IMDb info for [{self.name}]')
            return

        self.dirty = False
        return True

    def _get_tz_info(self):
        if self.internal_timezone:
            return tz.gettz(self.internal_timezone, zoneinfo_priority=True)
        elif self.internal_network:
            return network_timezones.get_network_timezone(self.internal_network)

    def _make_airtime(self, airtime=None):
        # type: (Optional[integer_types]) -> Optional[datetime.time]
        if isinstance(airtime, datetime.time):
            return airtime
        if isinstance(airtime, integer_types):
            return int_to_time(airtime)
        if self._airs:
            hour, minute = network_timezones.parse_time(self._airs)
            return datetime.time(hour=hour, minute=minute)
        return None

    def _get_airtime(self):
        # type: (...) -> Tuple[Optional[datetime.time], Optional[string_types], Optional[string_types]]
        """
        try to get airtime from trakt
        """
        try:
            tvinfo_config = sickgear.TVInfoAPI(TVINFO_TRAKT).api_params.copy()
            t = sickgear.TVInfoAPI(TVINFO_TRAKT).setup(**tvinfo_config)
            results = t.search_show(ids={self._tvid: self._prodid})
            for _r in results:
                if 'show' != _r['type']:
                    continue
                if _r['ids'][TVINFO_TMDB] == self._prodid:
                    try:
                        h, m = _r['airs']['time'].split(':')
                        h, m = try_int(h, None), try_int(m, None)
                        if None is not h and None is not m:
                            return datetime.time(hour=h, minute=m), _r['airs'].get('time'), _r['airs'].get('day')
                    except (BaseException, Exception):
                        continue
        except (BaseException, Exception):
            return None, None, None
        return None, None, None

    def _should_cast_update(self, show_info_cast):
        # type: (CastList) -> bool
        """
        return if cast list has changed and should be updated
        """
        cast_list = self.cast_list
        existing_cast = set(hash(*([', '.join(p.name for p in c.person or [] if p.name)]))
                            for c in cast_list or [] if c.name)
        new_cast = set(hash(*([', '.join(p.name for p in c.person or [] if p.name)]))
                       for c_t, c_l in iteritems(show_info_cast or {}) for c in c_l or [] if c.name
                       and c_t in (RoleTypes.ActorMain, RoleTypes.Host, RoleTypes.Interviewer, RoleTypes.Presenter))
        now = datetime.date.today().toordinal()
        max_age = random.randint(30, 60)
        no_image_cast = any(not (c.image_url or c.thumb_url) and (random.randint(4, 14) < now - c.updated)
                            for c in cast_list or [] if c.name)
        too_old_char = any(max_age < now - c.updated for c in cast_list or [] if c.name)
        # too_old_person = any(any(max_age < now - p.updated for p in c.person or [] if p.name)
        #                      for c in cast_list or [] if c.name)
        return existing_cast != new_cast or no_image_cast or too_old_char  # or too_old_person

    def load_from_tvinfo(self, cache=True, tvapi=None, tvinfo_data=None, scheduled_update=False, switch=False):
        # type: (bool, bool, TVInfoShow, bool, bool) -> Optional[Union[bool, TVInfoShow]]
        """

        :param cache:
        :param tvapi:
        :param tvinfo_data:
        :param scheduled_update:
        :param switch:
        """
        # There's gotta be a better way of doing this, but we don't want to
        # change the cache value elsewhere
        if None is tvapi:
            tvinfo_config = sickgear.TVInfoAPI(self.tvid).api_params.copy()

            if not cache:
                tvinfo_config['cache'] = False

            if self._lang:
                tvinfo_config['language'] = self._lang

            if 0 != self._dvdorder:
                tvinfo_config['dvdorder'] = True

            t = sickgear.TVInfoAPI(self.tvid).setup(**tvinfo_config)

        else:
            t = tvapi

        if getattr(tvinfo_data, 'id', None) == self.prodid:
            show_info = tvinfo_data
        else:
            show_info = t.get_show(self.prodid, actors=True, language=self._lang)  # type: Optional[TVInfoShow]
        if None is show_info or getattr(t, 'show_not_found', False):
            if getattr(t, 'show_not_found', False):
                self.inc_not_found_count()
                logger.warning('Show [%s] not found (maybe even removed?)' % self._name)
            else:
                logger.warning('Show data [%s] not found' % self._name)
            return False
        self.reset_not_found_count()

        try:
            self.name = show_info['seriesname'].strip()
        except AttributeError:
            raise BaseTVinfoAttributenotfound(
                "Found %s, but attribute 'seriesname' was empty." % self.tvid_prodid)

        if show_info:
            logger.log('%s: Loading show info [%s] from %s' % (
                self.tvid_prodid, self._name, sickgear.TVInfoAPI(self.tvid).name))

        self.classification = self.dict_prevent_nonetype(show_info, 'classification', 'Scripted')
        self.genre = '|'.join([_g for _g in (self.dict_prevent_nonetype(show_info, 'genre') or '').split('|') if _g])
        self.network = self.dict_prevent_nonetype(show_info, 'network')
        self.runtime = self.dict_prevent_nonetype(show_info, 'runtime')
        self.dirty_setter('_src_update_time')(self, show_info.updated_timestamp)

        old_imdb = self.imdbid
        if show_info.ids.imdb:
            self.imdbid = 'tt%07d' % show_info.ids.imdb
        else:
            self.imdbid = self.dict_prevent_nonetype(show_info, 'imdb_id')
        if old_imdb != self.imdbid:
            try:
                imdb_id = try_int(self.imdbid.replace('tt', ''), None)
                mapped_imdb = self.ids.get(TVINFO_IMDB, {'id': 0})['id']
                if imdb_id != mapped_imdb:
                    indexermapper.map_indexers_to_show(self, recheck=True)
            except (BaseException, Exception):
                pass

        # tmdb doesn't provide air time, try to get it from other source
        if TVINFO_TMDB == self._tvid and None is show_info.time:
            show_info.time, show_info.airs_time, show_info.airs_dayofweek = self._get_airtime()

        if None is not getattr(show_info, 'airs_dayofweek', None) and None is not getattr(show_info, 'airs_time', None):
            self.airs = ('%s %s' % (show_info['airs_dayofweek'], show_info['airs_time'])).strip()

        if None is not getattr(show_info, 'firstaired', None):
            self.startyear = int(str(show_info["firstaired"] or '0000-00-00').split('-')[0])

        self.status = self.dict_prevent_nonetype(show_info, 'status')
        self.overview = self.dict_prevent_nonetype(show_info, 'overview')
        self.network_id = show_info.network_id
        self.network_country = show_info.network_country
        self.network_country_code = show_info.network_country_code
        self.network_is_stream = show_info.network_is_stream
        self.timezone = show_info.network_timezone
        if not self.internal_timezone and self.internal_network:
            _, self.timezone = network_timezones.get_network_timezone(self.internal_network, return_name=True)
        self.airtime = self._make_airtime(show_info.time)

        if show_info.cast and self._should_cast_update(show_info.cast):
            sickgear.people_queue_scheduler.action.add_cast_update(show_obj=self, show_info_cast=show_info.cast,
                                                                   scheduled_update=scheduled_update, switch=switch)
        else:
            logger.log('Not updating cast for show because data is unchanged.')
        return show_info

    @staticmethod
    def _update_person_properties_helper(person_obj, src_person, p_ids):
        # type: (Person, TVInfoPerson, Dict) -> None
        person_obj.update_properties(
            name=src_person.name, gender=src_person.gender,
            birthday=src_person.birthdate, deathday=src_person.deathdate,
            biography=src_person.bio,
            ids=dict(chain.from_iterable(iteritems(_d) for _d in (person_obj.ids, p_ids))),
            deathplace=src_person.deathplace, akas=src_person.akas,
            nicknames=src_person.nicknames, real_name=src_person.real_name,
            height=src_person.height)

    def load_cast_from_tvinfo(self, show_info_cast, force=False, stop_event=None):
        # type: (CastList, bool, threading.Event) -> None
        """
        add and fetch cast list info for show
        Note: currently not multithread safe

        :param show_info_cast: tvinfo castlist
        :param force: force reload of cast info
        :param stop_event:
        """
        if stop_event and stop_event.is_set():
            return

        if not show_info_cast:
            tvinfo_config = sickgear.TVInfoAPI(self.tvid).api_params.copy()
            t = sickgear.TVInfoAPI(self.tvid).setup(**tvinfo_config)
            show_info = t.get_show(self.prodid, load_episodes=False, actors=True,
                                   language=self._lang)  # type: Optional[TVInfoShow]
            if None is show_info:
                return
            show_info_cast = show_info.cast

        cast_list = self._load_cast_from_db()
        remove_char_ids = {c.id for c in cast_list or []}
        cast_ordered = WeakList()
        for cur_cast_type, cur_cast_list in iteritems(show_info_cast):  # type: (integer_types, List[TVInfoCharacter])
            if cur_cast_type not in (RoleTypes.ActorMain, RoleTypes.Host, RoleTypes.Interviewer, RoleTypes.Presenter):
                continue
            for cur_cast in cur_cast_list:
                if stop_event and stop_event.is_set():
                    return

                unique_name = 1 == len([_c for _c in cur_cast_list if (None is not cur_cast.id and _c.id == cur_cast.id)
                                        or _c.name == cur_cast.name])
                mc = next((_c for _c in cast_list or []
                           if (None is not cur_cast.id and _c.ids.get(self.tvid) == cur_cast.id)
                           or (unique_name and cur_cast.name and _c.name == cur_cast.name)
                           or any(_c.ids.get(_src) == cur_cast.ids.get(_src) for _src in iterkeys(cur_cast.ids) or {})),
                          None)  # type: Optional[Character]
                if not mc:
                    unique_person = not any(1 for _cp in
                                            Counter([_p.name for _cha in cur_cast_list for _p in _cha.person
                                                     if any(_p.name == _pp.name for _pp in cur_cast.person)]).values()
                                            if 1 != _cp)
                    if unique_person:
                        pc = [_c for _c in cast_list or [] if _c.person
                              and any(1 for _p in _c.person if cur_cast.person
                                      and ((None is not _p.ids.get(self.tvid)
                                            and any(_p.ids.get(self.tvid) == _cp.id for _cp in cur_cast.person))
                                           or any(_p.name == _ccp.name for _ccp in cur_cast.person)))]
                        if 1 == len(pc):
                            mc = pc[0]
                if mc:
                    try:
                        remove_char_ids.remove(mc.id)
                    except KeyError:
                        # can happen with duplicate characters on source
                        logger.debug('%s - error character: %s (%s)' % (self.name, mc.id, mc.name))

                    original_person_ids = {_op.id for _op in mc.person if None is not _op.id}
                    for cur_person in cur_cast.person:
                        if cur_person.id:
                            person_ids = {self.tvid: cur_person.id}
                        else:
                            person_ids = {}
                        existing_person = next(
                            (_p for _p in mc.person
                             if (None is not cur_person.id and _p.ids.get(self.tvid) == cur_person.id)
                             or (_p.name and _p.name == cur_person.name)),
                            None)  # type: Optional[Person]
                        new_person = None
                        if not existing_person:
                            new_person = Person(cur_person.name, cur_person.gender, cur_person.birthdate,
                                                cur_person.deathdate, cur_person.bio, akas=cur_person.akas,
                                                character_obj=mc, deathplace=cur_person.deathplace,
                                                height=cur_person.height, ids=person_ids, image_url=cur_person.image,
                                                nicknames=cur_person.nicknames, real_name=cur_person.real_name,
                                                show_obj=self, thumb_url=cur_person.thumb_url)
                            if new_person and new_person.id and any(1 for _p in mc.person if _p.id == new_person.id):
                                existing_person = next((_pi for _pi in mc.person if _pi.id == new_person.id), None)

                        if existing_person:
                            try:
                                original_person_ids.remove(existing_person.id)
                            except KeyError:
                                logger.error(f'{self.name} -'
                                             f' Person error: {existing_person.name} ({existing_person.id})')
                                pass
                            if force:
                                existing_person.reset(cur_person)
                            self._update_person_properties_helper(existing_person, cur_person, person_ids)
                        elif None is not new_person:
                            mc.person.append(new_person)

                    if original_person_ids:
                        mc.person = [_cp for _cp in mc.person if _cp.id not in original_person_ids]

                    mc.update_properties(
                        name=cur_cast.name, image_url=cur_cast.image, thumb_url=cur_cast.thumb_url,
                        ids=dict(chain.from_iterable(
                            iteritems(_d) for _d in (mc.ids, ({}, {self.tvid: cur_cast.id})[None is not cur_cast.id]))))
                else:
                    persons = []
                    for cur_person in cur_cast.person:
                        existing_person = next((_p for _c in cast_list for _p in _c.person
                                                if (cur_person.id and _p.ids.get(self.tvid) == cur_person.id)
                                                or (not cur_person.id and cur_person.name == _p.name)),
                                               None)  # type: Optional[Person]
                        if cur_person.id:
                            person_ids = {self.tvid: cur_person.id}
                        else:
                            person_ids = {}
                        if existing_person:
                            if force:
                                existing_person.reset(cur_person)
                            self._update_person_properties_helper(existing_person, cur_person, person_ids)
                            persons.append(existing_person)
                        else:
                            tmp_char = Character(cur_cast.name,
                                                 ids=({}, {self.tvid: cur_cast.id})[None is not cur_cast.id],
                                                 image_url=cur_cast.image, show_obj=self,
                                                 thumb_url=cur_cast.thumb_url, tmp=True)
                            new_person = Person(
                                cur_person.name, cur_person.gender, cur_person.birthdate, cur_person.deathdate,
                                cur_person.bio,
                                akas=cur_person.akas, deathplace=cur_person.deathplace, height=cur_person.height,
                                ids=({}, {self.tvid: cur_person.id})[None is not cur_person.id],
                                image_url=cur_person.image, nicknames=cur_person.nicknames,
                                real_name=cur_person.real_name, show_obj=self,
                                thumb_url=cur_person.thumb_url, tmp_character_obj=tmp_char
                            )
                            if force:
                                new_person.reset(cur_person)
                            self._update_person_properties_helper(new_person, cur_person, person_ids)
                            persons.append(new_person)
                    mc = Character(cur_cast.name,
                                   ids=({}, {self.tvid: cur_cast.id})[None is not cur_cast.id],
                                   image_url=cur_cast.image, person=persons,
                                   show_obj=self, thumb_url=cur_cast.thumb_url)
                    cast_list.append(mc)
                cast_ordered.append(mc)

        if stop_event and stop_event.is_set():
            return
        if remove_char_ids:
            [c.remove_all_img(include_person=True) for c in cast_list or [] if c.id in remove_char_ids]
        self.cast_list = cast_ordered
        self._save_cast_list(force=force, removed_char_ids=remove_char_ids, stop_event=stop_event,
                             cast_list=cast_ordered)

    def load_imdb_info(self):

        if not sickgear.USE_IMDB_INFO:
            return

        logger.debug('Retrieving show info [%s] from IMDb' % self._name)
        try:
            self._get_imdb_info()
        except (BaseException, Exception) as e:
            logger.error('Error loading IMDb info: %s' % ex(e))
            logger.error('%s' % traceback.format_exc())

    @staticmethod
    def check_imdb_redirect(imdb_id):
        # type: (Union[AnyStr, integer_types]) -> Optional[AnyStr]
        """

        :param imdb_id: imdb id
        """
        page_url = 'https://www.imdb.com/title/{0}/'.format(imdb_id)
        try:
            response = requests.head(page_url, allow_redirects=True)
            if response.history and any(_h for _h in response.history if 301 == _h.status_code):
                return helpers.parse_imdb_id(response.url)
        except (BaseException, Exception):
            pass

    def _get_imdb_info(self, retry=False):
        # type: (bool) -> None

        if not self._imdbid and 0 >= self.ids.get(indexermapper.TVINFO_IMDB, {'id': 0}).get('id', 0):
            return

        imdb_info = {'imdb_id': self._imdbid or 'tt%07d' % self.ids[indexermapper.TVINFO_IMDB]['id'],
                     'title': '',
                     'year': '',
                     'akas': '',
                     'runtimes': try_int(self._runtime, None),
                     'is_mini_series': False,
                     'episode_count': None,
                     'genres': '',
                     'countries': '',
                     'country_codes': '',
                     'certificates': '',
                     'rating': '',
                     'votes': '',
                     'last_update': ''}

        imdb_id = None
        imdb_certificates = None
        try:
            imdb_id = str(self._imdbid or 'tt%07d' % self.ids[indexermapper.TVINFO_IMDB]['id'])
            redirect_check = self.check_imdb_redirect(imdb_id)
            if redirect_check:
                self._imdbid = redirect_check
                imdb_id = redirect_check
                imdb_info['imdb_id'] = self.imdbid
            i = imdbpie.Imdb(exclude_episodes=True, cachedir=os.path.join(sickgear.CACHE_DIR, 'imdb-pie'))
            if not helpers.parse_imdb_id(imdb_id):
                logger.warning('Not a valid imdbid: %s for show: %s' % (imdb_id, self._name))
                return
            imdb_ratings = i.get_title_ratings(imdb_id=imdb_id)
            imdb_akas = i.get_title_versions(imdb_id=imdb_id)
            imdb_tv = i.get_title_auxiliary(imdb_id=imdb_id)
            ipie = getattr(imdbpie.__dict__.get('imdbpie'), '_SIMPLE_GET_ENDPOINTS', None)
            if ipie:
                ipie.update({
                    'get_title_certificates': '/title/{imdb_id}/certificates',
                    'get_title_parentalguide': '/title/{imdb_id}/parentalguide',
                })
                imdb_certificates = i.get_title_certificates(imdb_id=imdb_id)
        except LookupError as e:
            if 'Title was an episode' in ex(e) and imdb_id == 'tt%07d' % self.ids[indexermapper.TVINFO_IMDB]['id']:
                self.ids[indexermapper.TVINFO_IMDB]['id'] = 0
                self.ids[indexermapper.TVINFO_IMDB]['status'] = MapStatus.NOT_FOUND
                if datetime.date.today() != self.ids[indexermapper.TVINFO_IMDB]['date']:
                    indexermapper.map_indexers_to_show(self, force=True)
                    if not retry and imdb_id != 'tt%07d' % self.ids[indexermapper.TVINFO_IMDB]['id']:
                        # add retry arg to prevent endless loops
                        logger.debug(f'imdbid: {imdb_id} not found. retrying with newly found id:'
                                     f' {"tt%07d" % self.ids[indexermapper.TVINFO_IMDB]["id"]}')
                        self._get_imdb_info(retry=True)
                        return
            logger.warning('imdbid: %s not found. Error: %s' % (imdb_id, ex(e)))
            return
        except ImdbAPIError as e:
            logger.warning('Imdb API Error: %s' % ex(e))
            return
        except (BaseException, Exception) as e:
            logger.warning('Error: %s retrieving imdb id: %s' % (ex(e), imdb_id))
            return

        # ratings
        if isinstance(imdb_ratings.get('rating'), (int, float)):
            imdb_info['rating'] = try_float(imdb_ratings.get('rating'), '')
        if isinstance(imdb_ratings.get('ratingCount'), int):
            imdb_info['votes'] = try_int(imdb_ratings.get('ratingCount'), '')

        en_cc = ['GB', 'US', 'CA', 'AU']
        # akas
        if isinstance(imdb_akas.get('alternateTitles'), (list, tuple)):
            akas_head = OrderedDict([(_k, None) for _k in en_cc])
            akas_tail = []
            for cur_aka in imdb_akas.get('alternateTitles'):
                if isinstance(cur_aka, dict) and cur_aka.get('title') and cur_aka.get('region'):
                    cur_cc = cur_aka.get('region').upper()
                    cc_aka = '%s::%s' % (cur_cc, cur_aka.get('title'))
                    if cur_cc in akas_head:
                        akas_head[cur_cc] = cc_aka
                    else:
                        akas_tail += [cc_aka]
            imdb_info['akas'] = '|'.join([_aka for _aka in itervalues(akas_head) if _aka] + sorted(akas_tail))

        # tv
        if isinstance(imdb_tv.get('title'), string_types):
            imdb_info['title'] = imdb_tv.get('title')
        if isinstance(imdb_tv.get('year'), (int, string_types)):
            imdb_info['year'] = try_int(imdb_tv.get('year'), '')
        if isinstance(imdb_tv.get('runningTimes'), list):
            try:
                for _t in imdb_tv.get('runningTimes'):
                    try:
                        if isinstance(_t.get('attributes'), list) and \
                                any(1 for _a in _t.get('attributes') if 'entire' in _a):
                            continue
                    except (BaseException, Exception):
                        continue
                    imdb_info['runtimes'] = try_int(_t.get('timeMinutes'), '')
                    break
            except (BaseException, Exception):
                pass
        if isinstance(imdb_tv.get('titleType'), string_types):
            imdb_info['is_mini_series'] = 'mini' in imdb_tv.get('titleType').lower()
        if isinstance(imdb_tv.get('numberOfEpisodes'), (int, string_types)):
            imdb_info['episode_count'] = try_int(imdb_tv.get('numberOfEpisodes'), 1)
        if isinstance(imdb_tv.get('genres'), (list, tuple)):
            imdb_info['genres'] = '|'.join(filter(lambda _v: _v, imdb_tv.get('genres')))
        if isinstance(imdb_tv.get('origins'), list):
            imdb_info['country_codes'] = '|'.join(filter(lambda _v: _v, imdb_tv.get('origins')))

        # certificate
        if isinstance(imdb_certificates.get('certificates'), dict):
            certs_head = OrderedDict([(_k, None) for _k in en_cc])
            certs_tail = []
            for cur_cc, cur_values in iteritems(imdb_certificates.get('certificates')):
                if cur_cc and isinstance(cur_values, (list, tuple)):
                    for cur_cert in cur_values:
                        if isinstance(cur_cert, dict) and cur_cert.get('certificate'):
                            extra_info = ''
                            if isinstance(cur_cert.get('attributes'), list):
                                extra_info = ' (%s)' % ', '.join(cur_cert.get('attributes'))
                            cur_cc = cur_cc.upper()
                            cc_cert = '%s:%s%s' % (cur_cc, cur_cert.get('certificate'), extra_info)
                            if cur_cc in certs_head:
                                certs_head[cur_cc] = cc_cert
                            else:
                                certs_tail += [cc_cert]
            imdb_info['certificates'] = '|'.join(
                [_cert for _cert in itervalues(certs_head) if _cert] + sorted(certs_tail))
        if (not imdb_info['certificates'] and isinstance(imdb_tv.get('certificate'), dict)
                and isinstance(imdb_tv.get('certificate').get('certificate'), string_types)):
            imdb_info['certificates'] = f'US:{imdb_tv.get("certificate").get("certificate")}'

        imdb_info['last_update'] = datetime.date.today().toordinal()

        # Rename dict keys without spaces for DB upsert
        self.imdb_info = dict(
            [(_k.replace(' ', '_'), _k(_v) if hasattr(_v, 'keys') else _v) for _k, _v in iteritems(imdb_info)])
        logger.debug('%s: Obtained info from IMDb -> %s' % (self.tvid_prodid, self._imdb_info))

        logger.log('%s: Parsed latest IMDb show info for [%s]' % (self.tvid_prodid, self._name))

    def next_episode(self):
        logger.debug('%s: Finding the episode which airs next for: %s' % (self.tvid_prodid, self._name))

        cur_date = datetime.date.today().toordinal()
        if not self.nextaired or self.nextaired and cur_date > self.nextaired:
            my_db = db.DBConnection()
            # noinspection SqlRedundantOrderingDirection
            sql_result = my_db.select(
                """
                SELECT airdate, season, episode 
                FROM tv_episodes
                WHERE indexer = ? AND showid = ? AND airdate >= ? AND status in (?,?,?)
                ORDER BY airdate ASC
                LIMIT 1
                """, [self.tvid, self.prodid, datetime.date.today().toordinal(), UNAIRED, WANTED, FAILED])

            if None is sql_result or 0 == len(sql_result):
                logger.debug('%s: No episode found... need to implement a show status' % self.tvid_prodid)
                self.nextaired = ''
            else:
                logger.debug(f'{self.tvid_prodid}: Found episode {sql_result[0]["season"]}x{sql_result[0]["episode"]}')
                self.nextaired = sql_result[0]['airdate']

        return self.nextaired

    def delete_show(self, full=False):
        # type: (bool) -> None
        """

        :param full:
        """
        try:
            sickgear.people_queue_scheduler.action.abort_cast_update(show_obj=self)
        except (BaseException, Exception):
            pass
        try:
            sickgear.show_queue_scheduler.action.abort_show(show_obj=self)
        except (BaseException, Exception):
            pass
        try:
            sickgear.search_queue_scheduler.action.abort_show(show_obj=self)
        except (BaseException, Exception):
            pass
        sql_l = [['DELETE FROM tv_episodes WHERE indexer = ? AND showid = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM tv_shows WHERE indexer = ? AND indexer_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM imdb_info WHERE indexer = ? AND indexer_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM xem_refresh WHERE indexer = ? AND indexer_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM scene_numbering WHERE indexer = ? AND indexer_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM allowlist WHERE indexer = ? AND show_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM blocklist WHERE indexer = ? AND show_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM indexer_mapping WHERE indexer = ? AND indexer_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM tv_shows_not_found WHERE indexer = ? AND indexer_id = ?', [self.tvid, self.prodid]],
                 ['DELETE FROM castlist WHERE indexer = ? AND indexer_id = ?', [self.tvid, self.prodid]]
                 ] + self.orphaned_cast_sql()

        my_db = db.DBConnection()
        my_db.mass_action(sql_l)
        self.remove_character_images()

        name_cache.remove_from_namecache(self.tvid, self.prodid)
        try:
            sickgear.name_parser.parser.name_parser_cache.flush(self)
        except (BaseException, Exception):
            pass

        action = ('delete', 'trash')[sickgear.TRASH_REMOVE_SHOW]

        # remove self from show list
        sickgear.showList = list(filter(lambda so: so.tvid_prodid != self.tvid_prodid, sickgear.showList))
        try:
            del sickgear.showDict[self.sid_int]
        except (BaseException, Exception):
            pass
        sickgear.webserve.Home.make_showlist_unique_names()
        sickgear.MEMCACHE['history_tab'] = sickgear.webserve.History.menu_tab(sickgear.MEMCACHE['history_tab_limit'])

        try:
            tvid_prodid = self.tvid_prodid
            if tvid_prodid in sickgear.switched_shows:
                sickgear.switched_shows.pop(tvid_prodid)
            elif tvid_prodid in itervalues(sickgear.switched_shows):
                sickgear.switched_shows = {_k: _v for _k, _v in iteritems(sickgear.switched_shows)
                                            if tvid_prodid != _v}
        except (BaseException, Exception):
            pass

        # clear the cache
        ic = image_cache.ImageCache()
        for cur_cachefile in glob.glob(ic.fanart_path(self.tvid, self.prodid).replace('fanart.jpg', '*')) \
                + glob.glob(ic.poster_thumb_path(self.tvid, self.prodid).replace('poster.jpg', '*')) \
                + glob.glob(ic.poster_path(self.tvid, self.prodid).replace('poster.jpg', '*')):
            cache_dir = os.path.isdir(cur_cachefile)
            result = helpers.remove_file(cur_cachefile, tree=cache_dir, log_level=logger.WARNING)
            if result:
                logger.log('%s cache %s %s' % (result, cache_dir and 'dir' or 'file', cur_cachefile))

        if self.tvid_prodid in sickgear.FANART_RATINGS:
            del sickgear.FANART_RATINGS[self.tvid_prodid]

        # remove entire show folder
        if full:
            try:
                logger.log('Attempt to %s show folder %s' % (action, self._location))
                # check first the read-only attribute
                file_attribute = os.stat(self.location)[0]
                if not file_attribute & stat.S_IWRITE:
                    # File is read-only, so make it writeable
                    logger.debug('Attempting to make writeable the read only folder %s' % self._location)
                    try:
                        os.chmod(self.location, stat.S_IWRITE)
                    except (BaseException, Exception):
                        logger.warning('Unable to change permissions of %s' % self._location)

                result = helpers.remove_file(self.location, tree=True)
                if result:
                    logger.log('%s show folder %s' % (result, self._location))

            except exceptions_helper.ShowDirNotFoundException:
                logger.warning('Show folder does not exist, no need to %s %s' % (action, self._location))
            except OSError as e:
                logger.warning('Unable to %s %s: %s / %s' % (action, self._location, repr(e), ex(e)))

    def populate_cache(self, force=False):
        # type: (bool) -> None
        """

        :param force:
        """
        cache_inst = image_cache.ImageCache()

        logger.log('Checking & filling cache for show %s' % self._name)
        cache_inst.fill_cache(self, force)

    def refresh_dir(self):

        # make sure the show dir is where we think it is unless dirs are created on the fly
        if not os.path.isdir(self._location) and not sickgear.CREATE_MISSING_SHOW_DIRS:
            return False

        # load from dir
        self.load_episodes_from_dir()

        # run through all locations from DB, check that they exist
        logger.log('%s: Loading all episodes for [%s] with a location from the database'
                   % (self.tvid_prodid, self._name))

        my_db = db.DBConnection()
        # noinspection SqlResolve
        sql_result = my_db.select(
            """
            SELECT *
            FROM tv_episodes
            WHERE indexer = ? AND showid = ? AND location != ''
            ORDER BY season DESC, episode DESC
            """, [self.tvid, self.prodid])

        kept = 0
        deleted = 0
        attempted = []
        sql_l = []
        for cur_row in sql_result:
            season = int(cur_row['season'])
            episode = int(cur_row['episode'])
            location = os.path.normpath(cur_row['location'])

            try:
                ep_obj = self.get_episode(season, episode, ep_result=[cur_row])
            except exceptions_helper.EpisodeDeletedException:
                logger.debug(f'The episode from [{self._name}] was deleted while we were refreshing it,'
                             f' moving on to the next one')
                continue

            # if the path exist and if it's in our show dir
            if (self.prune and season and ep_obj.location not in attempted and 0 < helpers.get_size(ep_obj.location) and
                    os.path.normpath(location).startswith(os.path.normpath(self.location))):
                with ep_obj.lock:
                    if ep_obj.status in Quality.DOWNLOADED:
                        # locations repeat but attempt to delete once
                        attempted += ep_obj.location
                        if kept >= self.prune:
                            result = helpers.remove_file(ep_obj.location, prefix_failure=f'{self.tvid_prodid}: ')
                            if result:
                                logger.debug(f'{self.tvid_prodid}: {result} file {ep_obj.location}')
                                deleted += 1
                        else:
                            kept += 1

            # if the path doesn't exist or if it's not in our show dir
            if not os.path.isfile(location) or not os.path.normpath(location).startswith(
                    os.path.normpath(self.location)):

                # check if downloaded files still exist, update our data if this has changed
                if 1 != sickgear.SKIP_REMOVED_FILES:
                    with ep_obj.lock:
                        # if it used to have a file associated with it, and it doesn't anymore then set it to IGNORED
                        if ep_obj.location and ep_obj.status in Quality.DOWNLOADED:
                            if ARCHIVED == sickgear.SKIP_REMOVED_FILES:
                                ep_obj.status = Quality.composite_status(
                                    ARCHIVED, Quality.quality_downloaded(ep_obj.status))
                            else:
                                ep_obj.status = (sickgear.SKIP_REMOVED_FILES, IGNORED)[
                                    not sickgear.SKIP_REMOVED_FILES]
                            logger.debug(f'{self.tvid_prodid}: File no longer at location for'
                                         f' s{season:02d}e{episode:02d}, episode removed'
                                         f' and status changed to {statusStrings[ep_obj.status]}')
                            ep_obj.subtitles = list()
                            ep_obj.subtitles_searchcount = 0
                            ep_obj.subtitles_lastsearch = str(datetime.datetime.min)
                        ep_obj.location = ''
                        ep_obj.hasnfo = False
                        ep_obj.hastbn = False
                        ep_obj.release_name = ''

                        result = ep_obj.get_sql()
                        if None is not result:
                            sql_l.append(result)
            else:
                # the file exists, set its modify file stamp
                if sickgear.AIRDATE_EPISODES:
                    ep_obj.airdate_modify_stamp()

        if deleted:
            logger.log('%s: %s %s media file%s and kept %s most recent downloads' % (
                self.tvid_prodid, ('Permanently deleted', 'Trashed')[sickgear.TRASH_REMOVE_SHOW],
                deleted, helpers.maybe_plural(deleted), kept))

        if 0 < len(sql_l):
            my_db = db.DBConnection()
            my_db.mass_action(sql_l)

    def download_subtitles(self, force=False):
        # type: (bool) -> None
        """

        :param force:
        """
        # TODO: Add support for force option
        if not os.path.isdir(self._location):
            logger.debug('%s: Show directory doesn\'t exist, can\'t download subtitles' % self.tvid_prodid)
            return
        logger.debug('%s: Downloading subtitles' % self.tvid_prodid)

        try:
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT location 
                FROM tv_episodes 
                WHERE indexer = ? AND showid = ? AND LENGTH(location) != 0 
                ORDER BY season DESC, episode DESC
                """, [self.tvid, self.prodid])

            for cur_row in sql_result:
                ep_obj = self.ep_obj_from_file(cur_row['location'])
                _ = ep_obj.download_subtitles(force=force)
        except (BaseException, Exception):
            logger.error('Error occurred when downloading subtitles: %s' % traceback.format_exc())
            return

    def remove_character_images(self):
        try:
            img_obj = image_cache.ImageCache()
            delete_list = []
            for cur_character in self.cast_list:
                for cur_person in cur_character.person:
                    person_img = img_obj.person_both_paths(cur_person)
                    for cur_image in person_img:
                        delete_list.append(cur_image)
                character_img = img_obj.character_both_path(cur_character, self)
                for cur_image in character_img:
                    delete_list.append(cur_image)

            for cur_delete in delete_list:
                try:
                    remove_file_perm(cur_delete)
                except (BaseException, Exception):
                    pass
        except (BaseException, Exception):
            pass

    def switch_infosrc(self, old_tvid, old_prodid, pausestatus_after=None, update_show=True):
        # type: (integer_types, integer_types, Optional[bool], bool) -> None
        """

        :param old_tvid: old tvid
        :param old_prodid: old prodid
        :param pausestatus_after: pause after switch
        :param update_show:
        """
        with self.lock:
            my_db = db.DBConnection()
            my_db.mass_action([
                ['UPDATE tv_shows SET indexer = ?, indexer_id = ? WHERE indexer = ? AND indexer_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE tv_episodes SET indexer = ?, showid = ?, indexerid = 0 WHERE indexer = ? AND showid = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE blocklist SET indexer = ?, show_id = ? WHERE indexer = ? AND show_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE history SET indexer = ?, showid = ? WHERE indexer = ? AND showid = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE imdb_info SET indexer = ?, indexer_id = ? WHERE indexer = ? AND indexer_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE scene_exceptions SET indexer = ?, indexer_id = ? WHERE indexer = ? AND indexer_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE scene_numbering SET indexer = ?, indexer_id = ? WHERE indexer = ? AND indexer_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE allowlist SET indexer = ?, show_id = ? WHERE indexer = ? AND show_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['UPDATE xem_refresh SET indexer = ?, indexer_id = ? WHERE indexer = ? AND indexer_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]],
                ['DELETE FROM tv_shows_not_found WHERE indexer = ? AND indexer_id = ?',
                 [old_tvid, old_prodid]],
                ['UPDATE castlist SET indexer = ?, indexer_id = ? WHERE indexer = ? AND indexer_id = ?',
                 [self.tvid, self.prodid, old_tvid, old_prodid]]
            ])

            my_failed_db = db.DBConnection('failed.db')
            my_failed_db.action('UPDATE history SET indexer = ?, showid = ? WHERE indexer = ? AND showid = ?',
                                [self.tvid, self.prodid, old_tvid, old_prodid])
            del_mapping(old_tvid, old_prodid)
            try:
                for cur_cast in self.cast_list:  # type: Character
                    cur_cast.remove_all_img(tvid=old_tvid, proid=old_prodid)
            except (BaseException, Exception):
                pass
            self._cast_list = None
            self.sxe_ep_obj = {}
            self.ids[old_tvid]['status'] = MapStatus.NONE
            self.ids[self.tvid]['status'] = MapStatus.SOURCE
            self.ids[self.tvid]['id'] = self.prodid
            if isinstance(self.imdb_info, dict):
                self.imdb_info['indexer'] = self.tvid
                self.imdb_info['indexer_id'] = self.prodid
            save_mapping(self)
            name_cache.remove_from_namecache(old_tvid, old_prodid)

            image_cache_dir = os.path.join(sickgear.CACHE_DIR, 'images', 'shows')
            old_dir = os.path.join(image_cache_dir, '%s-%s' % (old_tvid, old_prodid))
            new_dir = os.path.join(image_cache_dir, '%s-%s' % (self.tvid, self.prodid))
            try:
                os.rename(old_dir, new_dir)
            except (BaseException, Exception) as e:
                logger.warning('Unable to rename %s to %s: %s / %s' % (old_dir, new_dir, repr(e), ex(e)))

            old_id = TVidProdid({old_tvid: old_prodid})()
            rating = sickgear.FANART_RATINGS.get(old_id)
            if rating:
                del sickgear.FANART_RATINGS[old_id]
                sickgear.FANART_RATINGS[self.tvid_prodid] = rating
                sickgear.save_config()

            name_cache.build_name_cache(self)
            self.reset_not_found_count()
            old_sid_int = self.create_sid(old_tvid, old_prodid)
            if old_sid_int != self.sid_int:
                try:
                    del sickgear.showDict[old_sid_int]
                except (BaseException, Exception):
                    pass
                sickgear.showDict[self.sid_int] = self

            self.save_to_db()
            if update_show:
                # force the update
                try:
                    sickgear.show_queue_scheduler.action.update_show(
                        self, force=True, web=True, priority=QueuePriorities.VERYHIGH,
                        pausestatus_after=pausestatus_after, switch_src=True)
                except exceptions_helper.CantUpdateException as e:
                    logger.error('Unable to update this show. %s' % ex(e))

    def save_to_db(self, force_save=False):
        # type: (bool) -> None
        """

        :param force_save:
        """
        if not self.dirty and not force_save:
            logger.debug('%s: Not saving show to db - record is not dirty' % self.tvid_prodid)
            return

        logger.debug('%s: Saving show info to database' % self.tvid_prodid)

        new_value_dict = dict(
            air_by_date=self._air_by_date,
            airs=self._airs,
            airtime=time_to_int(self._airtime),
            anime=self._anime,
            archive_firstmatch=self._upgrade_once,
            classification=self._classification,
            dvdorder=self._dvdorder,
            flatten_folders=self._flatten_folders,
            genre=self._genre,
            indexer=self.tvid,
            lang=self._lang, imdb_id=self._imdbid,
            last_update_indexer=self._last_update_indexer,
            location=self._location,
            network=self.internal_network,
            network_country=self._network_country,
            network_country_code=self._network_country_code,
            network_id=self._network_id,
            network_is_stream=self._network_is_stream,
            overview=self._overview,
            paused=self._paused,
            prune=self._prune,
            quality=self._quality,
            rls_global_exclude_ignore=','.join(self._rls_global_exclude_ignore),
            rls_global_exclude_require=','.join(self._rls_global_exclude_require),
            rls_ignore_words=helpers.generate_word_str(self._rls_ignore_words, self._rls_ignore_words_regex),
            rls_require_words=helpers.generate_word_str(self._rls_require_words, self._rls_require_words_regex),
            runtime=self._runtime,
            scene=self._scene,
            show_name=self._name,
            sports=self._sports,
            startyear=self.startyear,
            status=self._status,
            subtitles=self._subtitles,
            tag=self._tag,
            timezone=self.internal_timezone,
        )

        control_value_dict = dict(indexer=self.tvid, indexer_id=self.prodid)

        my_db = db.DBConnection()
        my_db.upsert('tv_shows', new_value_dict, control_value_dict)
        self.dirty = False

        if sickgear.USE_IMDB_INFO and len(self._imdb_info):
            new_value_dict = self._imdb_info

            my_db = db.DBConnection()
            my_db.upsert('imdb_info', new_value_dict, control_value_dict)

    def __ne__(self, o):
        # type: (TVShow) -> bool
        return not self.__eq__(o)

    def __eq__(self, o):
        # type: (TVShow) -> bool
        if not isinstance(o, TVShow):
            return False
        return o.tvid == self.tvid and o.prodid == self.prodid

    def __hash__(self):
        return hash((self.tvid, self.prodid))

    def __repr__(self):
        return 'TVShow(%s)' % self.__str__()

    def __str__(self):
        return 'prodid: %s\n' % self.prodid \
               + 'tvid: %s\n' % self.tvid \
               + 'name: %s\n' % self.name \
               + 'location: %s\n' % self._location \
               + ('', 'network: %s\n' % self.network)[self.network not in (None, '')] \
               + ('', 'airs: %s\n' % self.airs)[self.airs not in (None, '')] \
               + ('', 'status: %s\n' % self.status)[self.status not in (None, '')] \
               + 'startyear: %s\n' % self.startyear \
               + ('', 'genre: %s\n' % self.genre)[self.genre not in (None, '')] \
               + 'classification: %s\n' % self.classification \
               + 'runtime: %s\n' % self.runtime \
               + 'quality: %s\n' % self.quality \
               + 'scene: %s\n' % self.is_scene \
               + 'sports: %s\n' % self.is_sports \
               + 'anime: %s\n' % self.is_anime \
               + 'prune: %s\n' % self.prune

    def want_episode(self, season, episode, quality, manual_search=False, multi_ep=False):
        # type: (integer_types, integer_types, integer_types, bool, bool) -> bool
        """

        :param season: season number
        :param episode: episode number
        :param quality: quality
        :param manual_search: manual search
        :param multi_ep: multiple episodes
        :return:
        """
        logger.debug(f'Checking if found {("", "multi-part ")[multi_ep]}episode {season}x{episode}'
                     f' is wanted at quality {Quality.qualityStrings[quality]}')

        if not multi_ep:
            try:
                wq = getattr(self.sxe_ep_obj.get(season, {}).get(episode, {}), 'wanted_quality', None)
                if None is not wq:
                    if quality in wq:
                        cur_status, cur_quality = Quality.split_composite_status(self.sxe_ep_obj[season][episode].status)
                        if cur_status in (WANTED, UNAIRED, SKIPPED, FAILED):
                            logger.debug('Existing episode status is wanted/unaired/skipped/failed,'
                                         ' getting found episode')
                            return True
                        elif manual_search:
                            logger.debug('Usually ignoring found episode, but forced search allows the quality,'
                                         ' getting found episode')
                            return True
                        elif quality > cur_quality:
                            logger.debug('Episode already exists but the found episode has better quality,'
                                         ' getting found episode')
                            return True
                    logger.debug('None of the conditions were met,'
                                 ' ignoring found episode')
                    return False
            except (BaseException, Exception):
                pass

        # if the quality isn't one we want under any circumstances then just say no
        initial_qualities, archive_qualities = Quality.split_quality(self._quality)
        all_qualities = list(set(initial_qualities + archive_qualities))

        initial = '= (%s)' % ','.join([Quality.qualityStrings[cur_qual] for cur_qual in initial_qualities])
        if 0 < len(archive_qualities):
            initial = '+ upgrade to %s + (%s)'\
                      % (initial, ','.join([Quality.qualityStrings[cur_qual] for cur_qual in archive_qualities]))
        logger.debug('Want initial %s and found %s' % (initial, Quality.qualityStrings[quality]))

        if quality not in all_qualities:
            logger.debug('Don\'t want this quality,'
                         ' ignoring found episode')
            return False

        my_db = db.DBConnection()
        sql_result = my_db.select(
            """
            SELECT status
            FROM tv_episodes
            WHERE indexer = ? AND showid = ? AND season = ? AND episode = ?
            """, [self.tvid, self.prodid, season, episode])

        if not sql_result or not len(sql_result):
            logger.debug('Unable to find a matching episode in database,'
                         ' ignoring found episode')
            return False

        cur_status, cur_quality = Quality.split_composite_status(int(sql_result[0]['status']))
        ep_status_text = statusStrings[cur_status]

        logger.debug('Existing episode status: %s (%s)' % (statusStrings[cur_status], ep_status_text))

        # if we know we don't want it then just say no
        if cur_status in [IGNORED, ARCHIVED] + ([SKIPPED], [])[multi_ep] and not manual_search:
            logger.debug(f'Existing episode status is {("skipped/", "")[multi_ep]}ignored/archived,'
                         f' ignoring found episode')
            return False

        # if it's one of these then we want it as long as it's in our allowed initial qualities
        if quality in all_qualities:
            if cur_status in [WANTED, UNAIRED, SKIPPED, FAILED] + ([], SNATCHED_ANY)[multi_ep]:
                logger.debug('Existing episode status is wanted/unaired/skipped/failed,'
                             ' getting found episode')
                return True
            elif manual_search:
                logger.debug('Usually ignoring found episode, but forced search allows the quality,'
                             ' getting found episode')
                return True
            else:
                logger.debug('Quality is on wanted list, need to check if it\'s better than existing quality')

        downloaded_status_list = SNATCHED_ANY + [DOWNLOADED]
        # special case: already downloaded quality is not in any of the wanted Qualities
        if cur_status in downloaded_status_list and cur_quality not in all_qualities:
            wanted_qualities = all_qualities
        else:
            wanted_qualities = archive_qualities

        # if re-downloading then only keep items in the archiveQualities list and better than what we have
        if cur_status in downloaded_status_list and quality in wanted_qualities and quality > cur_quality:
            logger.debug('Episode already exists but the found episode has better quality,'
                         ' getting found episode')
            return True
        else:
            logger.debug('Episode already exists and the found episode has same/lower quality,'
                         ' ignoring found episode')

        logger.debug('None of the conditions were met, ignoring found episode')
        return False

    def get_overview(self, ep_status, split_snatch=False):
        # type: (integer_types, bool) -> integer_types
        """
        :param ep_status: episode status
        :param split_snatch:
        :return:
        :rtype: int
        """
        return helpers.get_overview(ep_status, self.quality, self.upgrade_once, split_snatch=split_snatch)

    def __getstate__(self):
        d = dict(self.__dict__)
        del d['lock']
        return d

    def __setstate__(self, d):
        d['lock'] = threading.RLock()
        self.__dict__.update(d)

    def __bool__(self):
        return bool(self.tvid) and bool(self.prodid)

    __nonzero__ = __bool__


class TVEpisode(TVEpisodeBase):

    def __init__(self, show_obj, season, episode, path='', existing_only=False, show_result=None):
        # type: (TVShow, integer_types, integer_types, AnyStr, bool, List) -> None
        super(TVEpisode, self).__init__(season, episode, int(show_obj.tvid))

        self._airtime = None  # type: Optional[datetime.time]
        self._epid = 0  # type: int
        self._location = path  # type: AnyStr
        self._network = None  # type: Optional[AnyStr]
        self._network_country = None  # type: Optional[AnyStr]
        self._network_country_code = None  # type: Optional[AnyStr]
        self._network_id = None  # type: Optional[int]
        self._network_is_stream = None  # type: Optional[bool]
        self._runtime = 0  # type: integer_types
        self._show_obj = show_obj  # type: TVShow
        self._timestamp = None  # type: Optional[int]
        self._timezone = None  # type: Optional[AnyStr]
        self._tvid = int(show_obj.tvid)  # type: int

        self.check_for_meta_files()
        self.lock = threading.RLock()
        self.related_ep_obj = []  # type: List
        self.scene_absolute_number = 0  # type: int
        self.scene_episode = 0  # type: int
        self.scene_season = 0  # type: int
        self.specify_episode(self._season, self._episode, existing_only=existing_only, show_result=show_result)
        self.wanted_quality = []  # type: List

    @property
    def network(self):
        return self._network

    @network.setter
    def network(self, *args):
        self.dirty_setter('_network')(self, *args)

    @property
    def network_id(self):
        return self._network_id

    @network_id.setter
    def network_id(self, *args):
        self.dirty_setter('_network_id')(self, *args)

    @property
    def network_country(self):
        return self._network_country

    @network_country.setter
    def network_country(self, *args):
        self.dirty_setter('_network_country')(self, *args)

    @property
    def network_country_code(self):
        return self._network_country_code

    @network_country_code.setter
    def network_country_code(self, *args):
        self.dirty_setter('_network_country_code')(self, *args)

    @property
    def network_is_stream(self):
        return self._network_is_stream

    @network_is_stream.setter
    def network_is_stream(self, *args):
        self.dirty_setter('_network_is_stream')(self, *args)

    @property
    def airtime(self):
        # type: (...) -> Optional[datetime.time]
        return self._airtime

    @airtime.setter
    def airtime(self, *args):
        # type: (Optional[datetime.time, AnyStr]) -> None
        self.dirty_setter('_airtime')(self, *args)

    @property
    def runtime(self):
        return self._runtime

    @runtime.setter
    def runtime(self, *args):
        self.dirty_setter('_runtime')(self, *args)

    @property
    def timezone(self):
        return self._timezone

    @timezone.setter
    def timezone(self, *args):
        self.dirty_setter('_timezone')(self, *args)

    @property
    def timestamp(self):
        return self._timestamp

    @timestamp.setter
    def timestamp(self, *args):
        self.dirty_setter('_timestamp')(self, *args)

    @property
    def show_obj(self):
        """

        :return: TVShow object
        :rtype: TVShow
        """
        return self._show_obj

    @show_obj.setter
    def show_obj(self, val):
        self._show_obj = val

    @property
    def tvid(self):
        """
        :rtype: int
        """
        return self._tvid

    @tvid.setter
    def tvid(self, val):
        self.dirty_setter('_tvid')(self, int(val))
        # TODO: remove the following when indexerid is gone
        # in deprecation transition, tvid will also set indexer so that existing uses continue to work normally
        self.dirty_setter('_indexer')(self, int(val))

    @property
    def epid(self):
        """
        :rtype: int or long
        """
        return self._epid

    @epid.setter
    def epid(self, val):
        self.dirty_setter('_epid')(self, int(val))
        # TODO: remove the following when indexerid is gone
        # in deprecation transition, epid will also set indexerid so that existing uses continue as normal
        self.dirty_setter('_indexerid')(self, int(val))

    def _set_location(self, val):
        log_vals = (('clears', ''), ('sets', ' to ' + val))[any(val)]
        # noinspection PyStringFormat
        logger.debug('Setter %s location%s' % log_vals)

        # self._location = newLocation
        self.dirty_setter('_location')(self, val)

        if val and os.path.isfile(val):
            self.file_size = os.path.getsize(val)
        else:
            self.file_size = 0

    location = property(lambda self: self._location, _set_location)

    def refresh_subtitles(self):
        """Look for subtitles files and refresh the subtitles property"""
        if sickgear.USE_SUBTITLES:
            self.subtitles = subtitles.subtitles_languages(self.location)

    def download_subtitles(self, force=False):
        """

        :param force:
        :type force: bool
        :return:
        :rtype:
        """
        if not sickgear.USE_SUBTITLES:
            return

        # TODO: Add support for force option
        if not os.path.isfile(self.location):
            logger.debug(f'{self.show_obj.tvid_prodid}: Episode file doesn\'t exist,'
                         f' can\'t download subtitles for episode {self.season}x{self.episode}')
            return
        logger.debug(f'{self.show_obj.tvid_prodid}: Downloading subtitles for episode {self.season}x{self.episode}')

        previous_subtitles = self.subtitles

        try:
            need_languages = list(set(sickgear.SUBTITLES_LANGUAGES) - set(self.subtitles))
            subs = subliminal.download_subtitles([self.location], languages=need_languages,
                                                 services=sickgear.subtitles.get_enabled_service_list(),
                                                 force=force, multi=True, cache_dir=sickgear.CACHE_DIR,
                                                 os_auth=sickgear.SUBTITLES_SERVICES_AUTH[0],
                                                 os_hash=sickgear.SUBTITLES_OS_HASH)

            if sickgear.SUBTITLES_DIR:
                for cur_video in subs:
                    subs_new_path = os.path.join(os.path.dirname(cur_video.path), sickgear.SUBTITLES_DIR)
                    dir_exists = helpers.make_dir(subs_new_path)
                    if not dir_exists:
                        logger.error('Unable to create subtitles folder %s' % subs_new_path)
                    else:
                        helpers.chmod_as_parent(subs_new_path)

                    for cur_subtitle in subs.get(cur_video):
                        new_file_path = os.path.join(subs_new_path, os.path.basename(cur_subtitle.path))
                        helpers.move_file(cur_subtitle.path, new_file_path)
                        helpers.chmod_as_parent(new_file_path)
            else:
                for cur_video in subs:
                    for cur_subtitle in subs.get(cur_video):
                        helpers.chmod_as_parent(cur_subtitle.path)

        except (BaseException, Exception):
            logger.error('Error occurred when downloading subtitles: %s' % traceback.format_exc())
            return

        self.refresh_subtitles()
        # added the if because sometimes it raises an error
        self.subtitles_searchcount = self.subtitles_searchcount + 1 if self.subtitles_searchcount else 1
        self.subtitles_lastsearch = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        self.save_to_db()

        newsubtitles = set(self.subtitles).difference(set(previous_subtitles))

        if newsubtitles:
            try:
                subtitle_list = ", ".join([subliminal.language.Language(_x).name for _x in newsubtitles])
            except (BaseException, Exception):
                logger.debug(f'Could not parse a language to use to fetch subtitles'
                             f' for episode {self.season}x{self.episode}')
                return
            logger.debug(f'{self.show_obj.tvid_prodid}: Downloaded {subtitle_list} subtitles'
                         f' for episode {self.season}x{self.episode}')

            notifiers.notify_subtitle_download(self, subtitle_list)

        else:
            logger.debug(f'{self.show_obj.tvid_prodid}: No subtitles downloaded'
                         f' for episode {self.season}x{self.episode}')

        if sickgear.SUBTITLES_HISTORY:
            for cur_video in subs:
                for cur_subtitle in subs.get(cur_video):
                    history.log_subtitle(self.show_obj.tvid, self.show_obj.prodid,
                                         self.season, self.episode, self.status, cur_subtitle)

        return subs

    def check_for_meta_files(self):
        """

        :return:
        :rtype: bool
        """
        oldhasnfo = self._hasnfo
        oldhastbn = self._hastbn

        hasnfo = False
        hastbn = False

        # check for nfo and tbn
        if os.path.isfile(self.location):
            for cur_provider in itervalues(sickgear.metadata_provider_dict):
                if cur_provider.episode_metadata:
                    new_result = cur_provider.has_episode_metadata(self)
                else:
                    new_result = False
                hasnfo = new_result or hasnfo

                if cur_provider.episode_thumbnails:
                    new_result = cur_provider.has_episode_thumb(self)
                else:
                    new_result = False
                hastbn = new_result or hastbn

        self.hasnfo = hasnfo
        self.hastbn = hastbn

        # if either setting has changed return true, if not return false
        return oldhasnfo != self._hasnfo or oldhastbn != self._hastbn

    def specify_episode(self, season, episode, existing_only=False, **kwargs):
        """
        kwargs['show_result']: type: Optional[List[Row]] passed thru

        :param season: season number
        :type season: int
        :param episode: episode number
        :type episode: int
        :param existing_only:
        :type existing_only: bool
        """
        if not self.load_from_db(season, episode, **kwargs):
            # only load from NFO if we didn't load from DB
            if os.path.isfile(self.location):
                try:
                    self.load_from_nfo(self.location)
                except exceptions_helper.NoNFOException:
                    logger.error(f'{self.show_obj.tvid_prodid}: There was an error loading the NFO'
                                 f' for episode {season}x{episode}')
                    pass

                # if we tried loading it from NFO and didn't find the NFO, try the Indexers
                if not self._hasnfo:
                    try:
                        self.load_from_tvinfo(season, episode)
                    except exceptions_helper.EpisodeDeletedException:
                        # if we failed SQL *and* NFO, Indexers then fail
                        raise exceptions_helper.EpisodeNotFoundException(
                            'Couldn\'t find episode %sx%s' % (season, episode))
            elif existing_only:
                raise exceptions_helper.EpisodeNotFoundException(
                    'Couldn\'t find episode %sx%s' % (season, episode))

    def load_from_db(self, season, episode, show_result=None, **kwargs):
        # type: (int, int, Optional[List[Row]], Any) -> bool
        """

        kwargs['scene_result']: type: Optional[List[Row]] passed thru

        :param season: season number
        :param episode: episode number
        :param show_result:
        """
        logger.debug(f'{self._show_obj.tvid_prodid}: Loading episode details from DB for episode {season}x{episode}')

        show_result = show_result and next(iter(show_result), None)
        if not show_result or episode != show_result['episode'] or season != show_result['season']:
            my_db = db.DBConnection()
            sql_result = my_db.select(
                """
                SELECT *
                FROM tv_episodes
                WHERE indexer = ? AND showid = ? AND season = ? AND episode = ?
                LIMIT 2
                """, [self._show_obj.tvid, self._show_obj.prodid, season, episode])

            if 1 != len(sql_result):
                if len(sql_result):
                    raise exceptions_helper.MultipleDBEpisodesException('DB has multiple records for the same show')

                logger.debug(f'{self._show_obj.tvid_prodid}: Episode {self._season}x{self._episode}'
                             f' not found in the database')
                return False

            show_result = next(iter(sql_result))

        # todo: change to _tvid , _epid after removing indexer, indexerid
        self._tvid = int(show_result['indexer'])
        self._epid = int(show_result['indexerid'])

        self._absolute_number = show_result['absolute_number']
        self._airdate = datetime.date.fromordinal(int(show_result['airdate']))
        self._airtime = int_to_time(try_int(show_result['airtime'], None))
        self._description = self._description if not show_result['description'] else show_result['description']
        self._episode = episode
        self._file_size = try_int(show_result['file_size'])
        self._is_proper = self._is_proper if not show_result['is_proper'] else try_int(show_result['is_proper'])
        self._name = self._name if not show_result['name'] else show_result['name']
        self._network = show_result['network'] or self._show_obj.internal_network
        self._network_country = show_result['network_country']
        self._network_country_code = show_result['network_country_code']
        self._network_id = show_result['network_id']
        self._network_is_stream = bool(show_result['network_is_stream'])
        self._runtime = show_result['runtime']
        self._season = season
        self._status = self._status if None is show_result['status'] else int(show_result['status'])
        subt_value = show_result['subtitles']
        if ',,' in subt_value:  # a defensive fix for a data issue
            subt_value = re.sub(r',+', '', subt_value)
            subt_value = ('', subt_value)[2 == len(subt_value)]
        self._subtitles = subt_value and subt_value.split(',') or []
        self._subtitles_lastsearch = show_result['subtitles_lastsearch']
        self._subtitles_searchcount = show_result['subtitles_searchcount']
        self._timestamp = show_result['timestamp'] or self._make_timestamp()
        self._version = self._version if not show_result['version'] else int(show_result['version'])
        self.location = show_result['location'] and os.path.normpath(show_result['location']) or self.location

        if None is not show_result['release_group']:
            self._release_group = show_result['release_group']

        if None is not show_result['release_name']:
            self._release_name = show_result['release_name']

        sickgear.scene_numbering.xem_refresh(self._show_obj.tvid, self._show_obj.prodid)

        self.scene_absolute_number = try_int(show_result['scene_absolute_number'])
        if 0 == self.scene_absolute_number:
            self.scene_absolute_number = sickgear.scene_numbering.get_scene_absolute_numbering(
                self._show_obj.tvid, self._show_obj.prodid,
                absolute_number=self._absolute_number, season=self._season, episode=episode,
                show_result=show_result, show_obj=self._show_obj, **kwargs)

        self.scene_season = try_int(show_result['scene_season'])
        self.scene_episode = try_int(show_result['scene_episode'])
        if 0 == self.scene_season or 0 == self.scene_episode:
            self.scene_season, self.scene_episode = sickgear.scene_numbering.get_scene_numbering(
                self._show_obj.tvid, self._show_obj.prodid, self._season, self._episode, show_obj=self._show_obj,
                show_result=show_result, **kwargs)

        self._timezone = show_result['timezone']
        if not self._timezone and (self._network or self._show_obj.internal_timezone):
            if self._show_obj.internal_timezone:
                self._timezone = self._show_obj.internal_timezone
            else:
                _, self.timezone = network_timezones.get_network_timezone(self._network, return_name=True)

        self.dirty = False
        return True

    # noinspection PyProtectedMember
    def _make_timestamp(self):
        # type: (...) -> Optional[integer_types]
        if self.airdate:
            if isinstance(self._airtime, datetime.time):
                ep_time = self._airtime
            elif isinstance(self._show_obj._airtime, datetime.time):
                ep_time = self._show_obj._airtime
            else:
                ep_time = datetime.time(hour=0, minute=0)
            tzinfo = None
            if isinstance(self._timezone, string_types) and self._timezone:
                tzinfo = tz.gettz(self._timezone, zoneinfo_priority=True)
            elif isinstance(self._network, string_types) and self._network:
                tzinfo = tz.gettz(self._network, zoneinfo_priority=True)
            elif isinstance(self._show_obj.timezone, string_types) and self._show_obj.timezone:
                tzinfo = self._show_obj.timezone
            elif isinstance(self._show_obj.network, string_types) and self._show_obj.network:
                tzinfo = network_timezones.get_network_timezone(self._show_obj.network)
            return SGDatetime.combine(self.airdate, ep_time, tzinfo=tzinfo).timestamp_far()
        return None

    def load_from_tvinfo(
            self,
            season=None,  # type: integer_types
            episode=None,  # type: integer_types
            cache=True,  # type: bool
            tvapi=None,  # type: Any
            cached_season=None,  # type: Dict
            update=False,  # type: bool
            cached_show=None,  # type: Dict
            switch=False,  # type: bool
            old_tvid=None,  # type: int
            old_prodid=None,  # type: integer_types
            switch_list=None  # type: List
    ):  # type: (...) -> Optional[bool]
        """
        :param season: season number
        :param episode: episode number
        :param cache:
        :param tvapi:
        :param cached_season:
        :param update:
        :param cached_show:
        :param switch:
        :param old_tvid:
        :param old_prodid:
        :param switch_list:
        """
        if None is season:
            season = self._season
        if None is episode:
            episode = self._episode

        logger.debug(f'{self._show_obj.tvid_prodid}: Loading episode details from'
                     f' {sickgear.TVInfoAPI(self._show_obj.tvid).name} for episode {season}x{episode}')

        try:
            if cached_show:
                ep_info = cached_show[season][episode]
            elif None is cached_season:
                if None is tvapi:
                    tvinfo_config = sickgear.TVInfoAPI(self.tvid).api_params.copy()

                    if not cache:
                        tvinfo_config['cache'] = False

                    show_lang = self._show_obj.lang

                    if show_lang:
                        tvinfo_config['language'] = show_lang

                    if 0 != self._show_obj.dvdorder:
                        tvinfo_config['dvdorder'] = True

                    t = sickgear.TVInfoAPI(self.tvid).setup(**tvinfo_config)
                else:
                    t = tvapi
                ep_info = t.get_show(self._show_obj.prodid,
                                     language=self.show_obj.lang)[season][episode]  # type: TVInfoEpisode
            else:
                ep_info = cached_season[episode]  # type: TVInfoEpisode

        except (BaseTVinfoEpisodenotfound, BaseTVinfoSeasonnotfound):
            logger.debug(f'Unable to find the episode on {sickgear.TVInfoAPI(self.tvid).name}...'
                         f' has it been removed? Should it be deleted from the db?')
            # if no longer on the Indexers, but once was, then delete it from the DB
            if -1 != self._epid and helpers.should_delete_episode(self._status):
                self.delete_episode()
            elif UNKNOWN == self._status:
                self.status = SKIPPED
            return
        except (BaseTVinfoError, IOError) as e:
            logger.debug('%s threw up an error: %s' % (sickgear.TVInfoAPI(self.tvid).name, ex(e)))
            # if the episode is already valid just log it, if not throw it up
            if UNKNOWN == self._status:
                self.status = SKIPPED

            if self._name:
                logger.debug(f'{sickgear.TVInfoAPI(self.tvid).name}'
                             f' timed out but there is enough info from other sources, allowing the error')
                return

            logger.error('%s timed out, unable to create the episode' % sickgear.TVInfoAPI(self.tvid).name)
            return False

        if getattr(ep_info, 'absolute_number', None) in (None, ''):
            logger.debug('This episode (%s - %sx%s) has no absolute number on %s' %
                         (self.show_obj.unique_name, season, episode, sickgear.TVInfoAPI(self.tvid).name))
        else:
            logger.debug(f'{self._show_obj.tvid_prodid}:'
                         f' The absolute_number for {season}x{episode} is : {ep_info["absolute_number"]}')
            self.absolute_number = int(ep_info['absolute_number'])

        if switch and None is not switch_list:
            if self._name != self.dict_prevent_nonetype(ep_info, 'episodename'):
                switch_list.append(self.show_obj.switch_ep_change_sql(old_tvid, old_prodid, episode, season,
                                                                      TVSWITCH_EP_RENAMED))

        old_name = self._name or ''
        self.name = self.dict_prevent_nonetype(ep_info, 'episodename')
        self.season = season
        self.episode = episode

        sickgear.scene_numbering.xem_refresh(self._show_obj.tvid, self._show_obj.prodid)

        self.scene_absolute_number = sickgear.scene_numbering.get_scene_absolute_numbering(
            self._show_obj.tvid, self._show_obj.prodid,
            absolute_number=self._absolute_number,
            season=self._season, episode=self._episode, show_obj=self._show_obj)

        self.scene_season, self.scene_episode = sickgear.scene_numbering.get_scene_numbering(
            self._show_obj.tvid, self._show_obj.prodid, self._season, self._episode, show_obj=self._show_obj)

        self.description = self.dict_prevent_nonetype(ep_info, 'overview')

        firstaired = getattr(ep_info, 'firstaired', None)
        if None is firstaired or firstaired in '0000-00-00':
            firstaired = str(datetime.date.fromordinal(1))
        raw_airdate = [int(_x) for _x in firstaired.split('-')]

        old_airdate_future = self._airdate == datetime.date.fromordinal(1) or self._airdate >= datetime.date.today()
        try:
            self.airdate = datetime.date(raw_airdate[0], raw_airdate[1], raw_airdate[2])
        except (ValueError, IndexError):
            logger.error('Malformed air date retrieved from %s (%s - %sx%s)' %
                         (sickgear.TVInfoAPI(self.tvid).name, self.show_obj.unique_name, season, episode))
            # if I'm incomplete on TVDB, but I once was complete then just delete myself from the DB for now
            if -1 != self._epid and helpers.should_delete_episode(self._status):
                self.delete_episode()
            elif UNKNOWN == self._status:
                self.status = SKIPPED
            return False

        self.network = ep_info.network
        if not self._network:
            self.network = self._show_obj.internal_network
        self.network_id = ep_info.network_id
        self.network_country = ep_info.network_country
        self.network_country_code = ep_info.network_country_code
        self.timezone = ep_info.network_timezone
        if not self._timezone and (self._network or self._show_obj.internal_timezone):
            if self._show_obj.internal_timezone:
                self._timezone = self._show_obj.internal_timezone
            else:
                _, self.timezone = network_timezones.get_network_timezone(self._network, return_name=True)
        self.network_is_stream = ep_info.network_is_stream
        self.airtime = ep_info.airtime
        self.runtime = ep_info.runtime
        invalid_date = False
        if not (self._airdate and self._airdate < invalid_date_limit):
            self.timestamp = ep_info.timestamp or self._make_timestamp()
        else:
            self.timestamp = None
            invalid_date = True

        today = datetime.date.today()
        delta = datetime.timedelta(days=1)
        if invalid_date:
            show_time = None
        elif self._timestamp and self._timezone:
            try:
                show_time = SGDatetime.from_timestamp(self._timestamp, tz_aware=True, local_time=False,
                                                      tzinfo=tz.gettz(self._timezone))
            except OverflowError:
                logger.debug('Invalid timestamp: %s, using fallback' % self._timestamp)
                show_time = network_timezones.parse_date_time(self._airdate.toordinal(),
                                                              self._airtime or self._show_obj.airs,
                                                              self._network or self._show_obj.network)
        else:
            show_time = network_timezones.parse_date_time(self._airdate.toordinal(),
                                                          self._airtime or self._show_obj.airs,
                                                          self._network or self._show_obj.network)
        tz_now = datetime.datetime.now(network_timezones.SG_TIMEZONE)
        show_length = datetime.timedelta(minutes=helpers.try_int(self._runtime or self._show_obj.runtime, 60))
        future_airtime = not invalid_date and (
            (self._airdate > (today + delta) or
             (not self._airdate < (today - delta) and ((show_time + show_length) > tz_now))))

        # early conversion to int so that episode doesn't get marked dirty
        self.epid = getattr(ep_info, 'id', None)
        if None is self._epid:
            logger.error('Failed to retrieve ID from %s' % sickgear.TVInfoAPI(self.tvid).name)
            if helpers.should_delete_episode(self._status):
                self.delete_episode()
            elif UNKNOWN == self._status:
                self.status = (SKIPPED, UNAIRED)[future_airtime]
            return False

        # don't update show status if show dir is missing, unless it's missing on purpose
        # noinspection PyProtectedMember
        if not os.path.isdir(self._show_obj._location) \
                and not sickgear.CREATE_MISSING_SHOW_DIRS and not sickgear.ADD_SHOWS_WO_DIR:
            if UNKNOWN == self._status:
                self.status = (SKIPPED, UNAIRED)[future_airtime]
                logger.log('The show directory is missing but an episode status found at Unknown is set Skipped')
            else:
                logger.log('The show directory is missing,'
                           ' not bothering to change the episode statuses since it\'d probably be invalid')
            return

        if self._location:
            logger.debug(f'{self._show_obj.tvid_prodid}: Setting status for {season}x{episode}'
                         f' based on status {statusStrings[self._status]} and existence of {self._location}')

        # if we don't have the file
        if not os.path.isfile(self._location):

            if self._status in [SKIPPED, UNAIRED, UNKNOWN, WANTED]:
                very_old_delta = datetime.timedelta(days=90)
                very_old_airdate = datetime.date.fromordinal(1) < self._airdate < (today - very_old_delta)

                # if this episode hasn't aired yet set the status to UNAIRED
                if future_airtime:
                    msg = 'Episode airs in the future, marking it %s'
                    self.status = UNAIRED

                # if there's no airdate then set it to unaired (and respect ignored)
                elif self._airdate == datetime.date.fromordinal(1):
                    if IGNORED == self._status:
                        msg = 'Episode has no air date and marked %s, no change'
                    else:
                        msg = 'Episode has no air date, marking it %s'
                        self.status = UNAIRED

                # if the airdate is in the past
                elif UNAIRED == self._status:
                    msg = ('Episode status %s%s, with air date in the past, marking it ' % (
                        statusStrings[self._status], ','.join([(' is a special', '')[0 < self._season],
                                                              ('', ' is paused')[self._show_obj.paused]])) + '%s')
                    self.status = (SKIPPED, WANTED)[0 < self._season
                                                    and not self._show_obj.paused and not very_old_airdate]

                # if still UNKNOWN or SKIPPED with the deprecated future airdate method
                elif UNKNOWN == self._status or (SKIPPED == self._status and old_airdate_future):
                    msg = ('Episode status %s%s, with air date in the past, marking it ' % (
                        statusStrings[self._status], ','.join([
                            ('', ' has old future date format')[SKIPPED == self._status and old_airdate_future],
                            ('', ' is being updated')[bool(update)], (' is a special', '')[0 < self._season]])) + '%s')
                    self.status = (SKIPPED, WANTED)[update and not self._show_obj.paused and 0 < self._season
                                                    and not very_old_airdate]

                else:
                    msg = 'Not touching episode status %s, with air date in the past, because there is no file'

            else:
                msg = 'Not touching episode status %s, because there is no file'

            logger.debug(msg % statusStrings[self._status])

        # if we have a media file then it's downloaded
        elif sickgear.helpers.has_media_ext(self._location):
            if IGNORED == self._status:
                logger.debug(f'File exists for {self._season}x{self._episode},'
                             f' ignoring because of status {statusStrings[self._status]}')
            # leave propers alone, you have to either post-process them or manually change them back
            elif self._status not in Quality.SNATCHED_ANY + Quality.DOWNLOADED + Quality.ARCHIVED:
                msg = '(1) Status changes from %s to ' % statusStrings[self._status]
                self.status = Quality.status_from_name_or_file(self._location, anime=self._show_obj.is_anime)
                logger.debug('%s%s' % (msg, statusStrings[self._status]))

            if sickgear.RENAME_EPISODES and self.with_ep_name() \
                    and os.path.splitext(ep_filename := os.path.basename(self._location or ''))[0] != \
                        os.path.basename(self.proper_path()) \
                    and (sickgear.RENAME_NAME_CHANGED_EPISODES
                         or (sickgear.RENAME_TBA_EPISODES
                             and (bool(tba_tvinfo_name.search(old_name))
                                  or (not bool(tba_tvinfo_name.search(self._name or ''))
                                      and bool(tba_file_name.search(ep_filename or ''))))
                         )) \
                    and os.path.isfile(self._location):
                # noinspection PySimplifyBooleanCheck
                if re_res := self.rename():
                    notifiers.notify_update_library(self, include_online=False)
                elif False == re_res:
                    logger.debug('Failed to rename files to TV info episode name')

        # shouldn't get here probably
        else:
            msg = '(2) Status changes from %s to ' % statusStrings[self._status]
            self.status = UNKNOWN
            logger.debug('%s%s' % (msg, statusStrings[self._status]))

    def load_from_nfo(self, location):
        """

        :param location:
        :type location: AnyStr
        """
        # noinspection PyProtectedMember
        if not os.path.isdir(self._show_obj._location):
            logger.log('%s: The show directory is missing, not bothering to try loading the episode NFO'
                       % self._show_obj.tvid_prodid)
            return

        logger.debug(f'{self.show_obj.tvid_prodid}'
                     f': Loading episode details from the NFO file associated with {location}')

        self.location = location

        if '' != self.location:

            if UNKNOWN == self._status and sickgear.helpers.has_media_ext(self.location):
                status_quality = Quality.status_from_name_or_file(self.location, anime=self._show_obj.is_anime)
                logger.debug('(3) Status changes from %s to %s' % (self._status, status_quality))
                self.status = status_quality

            nfo_file = sickgear.helpers.replace_extension(self.location, 'nfo')
            logger.debug('%s: Using NFO name %s' % (self._show_obj.tvid_prodid, nfo_file))

            if os.path.isfile(nfo_file):
                try:
                    show_xml = etree.ElementTree(file=nfo_file)
                except (SyntaxError, ValueError) as e:
                    # TODO: figure out what's wrong and fix it
                    logger.error('Error loading the NFO, backing up the NFO and skipping for now: %s' % ex(e))
                    try:
                        os.rename(nfo_file, '%s.old' % nfo_file)
                    except (BaseException, Exception) as e:
                        logger.error(f'Failed to rename episode\'s NFO file - you need to delete it or fix it: {ex(e)}')
                    raise exceptions_helper.NoNFOException('Error in NFO format')

                # TODO: deprecated function getiterator needs to be replaced
                # for epDetails in showXML.getiterator('episodedetails'):
                for cur_detail in list(show_xml.iter('episodedetails')):
                    if None is cur_detail.findtext('season') or int(cur_detail.findtext('season')) != self._season or \
                                    None is cur_detail.findtext('episode') or int(
                            cur_detail.findtext('episode')) != self._episode:
                        logger.debug(f'{self._show_obj.tvid_prodid}'
                                     f': NFO has an <episodedetails> block for a different episode - wanted'
                                     f' {self._season}x{self._episode}'
                                     f' but got {cur_detail.findtext("season")}x{cur_detail.findtext("episode")}')
                        continue

                    if None is cur_detail.findtext('title') or None is cur_detail.findtext('aired'):
                        raise exceptions_helper.NoNFOException('Error in NFO format (missing episode title or airdate)')

                    self.name = cur_detail.findtext('title')
                    self.episode = int(cur_detail.findtext('episode'))
                    self.season = int(cur_detail.findtext('season'))

                    sickgear.scene_numbering.xem_refresh(self._show_obj.tvid, self._show_obj.prodid)

                    self.scene_absolute_number = sickgear.scene_numbering.get_scene_absolute_numbering(
                        self._show_obj.tvid, self._show_obj.prodid,
                        absolute_number=self._absolute_number,
                        season=self._season, episode=self._episode, show_obj=self._show_obj)

                    self.scene_season, self.scene_episode = sickgear.scene_numbering.get_scene_numbering(
                        self._show_obj.tvid, self._show_obj.prodid, self._season, self._episode,
                        show_obj=self._show_obj)

                    self.description = cur_detail.findtext('plot')
                    if None is self._description:
                        self.description = ''

                    if cur_detail.findtext('aired'):
                        raw_airdate = [int(_x) for _x in cur_detail.findtext('aired').split("-")]
                        self.airdate = datetime.date(raw_airdate[0], raw_airdate[1], raw_airdate[2])
                    else:
                        self.airdate = datetime.date.fromordinal(1)

                    self.hasnfo = True
            else:
                self.hasnfo = False

            if os.path.isfile(sickgear.helpers.replace_extension(nfo_file, 'tbn')):
                self.hastbn = True
            else:
                self.hastbn = False

    def __ne__(self, o):
        # type: (TVEpisode) -> bool
        return not self.__eq__(o)

    def __eq__(self, o):
        # type: (TVEpisode) -> bool
        if not isinstance(o, TVEpisode):
            return False
        return o._show_obj == self._show_obj and o._epid == self._epid

    def __hash__(self):
        return hash((self._show_obj, self._epid))

    def __repr__(self):
        return 'TVEpisode(%s)' % self.__str__()

    def __str__(self):

        return '%s - %sx%s - %s\n' % (self.show_obj.unique_name, self.season, self.episode, self.name) \
               + 'location: %s\n' % self.location \
               + 'description: %s\n' % self.description \
               + 'subtitles: %s\n' % ','.join(self.subtitles) \
               + 'subtitles_searchcount: %s\n' % self.subtitles_searchcount \
               + 'subtitles_lastsearch: %s\n' % self.subtitles_lastsearch \
               + 'airdate: %s (%s)\n' % (self.airdate.toordinal(), self.airdate) \
               + 'hasnfo: %s\n' % self.hasnfo \
               + 'hastbn: %s\n' % self.hastbn \
               + 'status: %s\n' % self.status

    def create_meta_files(self, force=False, save_ep=True):
        # type: (bool, bool) -> None
        """
        create meta data files for episode object

        :param force: force writing of meta data files
        :param save_ep: save changed episode data
        """

        # noinspection PyProtectedMember
        if not os.path.isdir(self.show_obj._location):
            logger.log('%s: The show directory is missing, not bothering to try to create metadata'
                       % self.show_obj.tvid_prodid)
            return

        self.create_nfo(force)
        self.create_thumbnail()

        if self.check_for_meta_files() and save_ep:
            self.save_to_db()

    def create_nfo(self, force=False):
        """

        :return:
        :rtype: bool
        """
        result = False

        for cur_provider in itervalues(sickgear.metadata_provider_dict):
            try:
                result = cur_provider.create_episode_metadata(self, force) or result
            except (BaseException, Exception) as e:
                logger.warning('Error creating episode nfo: %s' % ex(e))

        return result

    def create_thumbnail(self):
        """

        :return:
        :rtype: bool
        """
        result = False

        for cur_provider in itervalues(sickgear.metadata_provider_dict):
            try:
                result = cur_provider.create_episode_thumb(self) or result
            except (BaseException, Exception) as e:
                logger.warning('Error creating episode thumb: %s' % ex(e))

        return result

    def delete_episode(self, return_sql=False):
        # type: (bool) -> Optional[List[List]]
        """
        deletes episode from db, alternatively returns sql to remove episode from db

        :param return_sql: only return sql to delete episode
        """

        logger.debug('Deleting %s %sx%s from the DB' % (self._show_obj.unique_name, self._season, self._episode))

        # remove myself from the show dictionary
        if self.show_obj.get_episode(self._season, self._episode, no_create=True) == self:
            logger.debug('Removing myself from my show\'s list')
            del self.show_obj.sxe_ep_obj[self._season][self._episode]

        # delete myself from the DB
        logger.debug('Deleting myself from the database')

        sql = [['DELETE FROM tv_episodes WHERE indexer = ? AND showid = ? AND season = ? AND episode = ?',
               [self._show_obj.tvid, self._show_obj.prodid, self._season, self._episode]]]
        if return_sql:
            return sql

        my_db = db.DBConnection()
        my_db.mass_action(sql)

        raise exceptions_helper.EpisodeDeletedException()

    def get_sql(self, force_save=False):
        # type: (bool) -> Optional[List[AnyStr, List]]
        """
        Creates SQL queue for this episode if any of its data has been changed since the last save.

        :param force_save: If True it will create SQL queue even if no data has been changed since the last save
        (aka if the record is not dirty).
        """

        if not self.dirty and not force_save:
            logger.debug('%s: Not creating SQL queue - record is not dirty' % self._show_obj.tvid_prodid)
            return

        self.dirty = False
        return [
            """
            INSERT OR REPLACE INTO tv_episodes
            (episode_id,
            indexerid, indexer, name, description,
            subtitles, subtitles_searchcount, subtitles_lastsearch,
            airdate, hasnfo, hastbn, status, location, file_size,
            release_name, is_proper, showid, season, episode, absolute_number,
            version, release_group,
            network, network_id, network_country, network_country_code, network_is_stream,
            airtime, runtime, timestamp, timezone,
            scene_absolute_number, scene_season, scene_episode)
            VALUES
            ((SELECT episode_id FROM tv_episodes
            WHERE indexer = ? AND showid = ?
            AND season = ? AND episode = ?)
            ,?,?
            ,?,?
            ,?,?,?
            ,?,?,?,?,?,?
            ,?,?
            ,?,?,?,?
            ,?,?
            ,?,?,?,?,?
            ,?,?,?,?,
            (SELECT scene_absolute_number FROM tv_episodes
             WHERE indexer = ? AND showid = ? AND season = ? AND episode = ?),
            (SELECT scene_season FROM tv_episodes
             WHERE indexer = ? AND showid = ? AND season = ? AND episode = ?),
            (SELECT scene_episode FROM tv_episodes
             WHERE indexer = ? AND showid = ? AND season = ? AND episode = ?));
            """, [self._show_obj.tvid, self._show_obj.prodid,
                  self._season, self._episode,
                  self._epid, self._tvid,
                  self._name, self._description,
                  ','.join([_sub for _sub in self._subtitles]), self._subtitles_searchcount, self._subtitles_lastsearch,
                  self._airdate.toordinal(), self._hasnfo, self._hastbn, self._status, self._location, self._file_size,
                  self._release_name, self._is_proper,
                  self._show_obj.prodid, self._season, self._episode, self._absolute_number,
                  self._version, self._release_group,
                  self._network, self._network_id,
                  self._network_country, self._network_country_code, self._network_is_stream,
                  time_to_int(self._airtime), self._runtime, self._timestamp, self._timezone,
                  self._show_obj.tvid, self._show_obj.prodid, self._season, self._episode,
                  self._show_obj.tvid, self._show_obj.prodid, self._season, self._episode,
                  self._show_obj.tvid, self._show_obj.prodid, self._season, self._episode]]

    def save_to_db(self, force_save=False):
        """
        Saves this episode to the database if any of its data has been changed since the last save.

        :param force_save: If True it will save to the database even if no data has been changed since the
        last save (aka if the record is not dirty).
        """

        if not self.dirty and not force_save:
            logger.debug('%s: Not saving episode to db - record is not dirty' % self._show_obj.tvid_prodid)
            return

        logger.debug('%s: Saving episode details to database' % self._show_obj.tvid_prodid)

        logger.debug('STATUS IS %s' % statusStrings[self._status])

        new_value_dict = dict(
            absolute_number=self._absolute_number,
            airdate=self._airdate.toordinal(),
            airtime=time_to_int(self._airtime),
            description=self._description,
            file_size=self._file_size,
            hasnfo=self._hasnfo,
            hastbn=self._hastbn,
            indexer=self._tvid,
            indexerid=self._epid,
            is_proper=self._is_proper,
            location=self._location,
            name=self._name,
            network=self._network,
            network_country=self._network_country,
            network_country_code=self._network_country_code,
            network_id=self._network_id,
            network_is_stream=self._network_is_stream,
            release_group=self._release_group,
            release_name=self._release_name,
            runtime=self._runtime,
            status=self._status,
            subtitles=','.join([_sub for _sub in self._subtitles]),
            subtitles_lastsearch=self._subtitles_lastsearch,
            subtitles_searchcount=self._subtitles_searchcount,
            timestamp=self._timestamp,
            timezone=self._timezone,
            version=self._version,
        )

        control_value_dict = dict(
            indexer=self.show_obj.tvid, showid=self.show_obj.prodid, season=self.season, episode=self.episode)

        # use a custom update/insert method to get the data into the DB
        my_db = db.DBConnection()
        my_db.upsert('tv_episodes', new_value_dict, control_value_dict)
        self.dirty = False

    # # TODO: remove if unused
    # def full_location(self):
    #     if self.location in (None, ''):
    #         return None
    #     return os.path.join(self.show_obj.location, self.location)
    #
    # # TODO: remove if unused
    # def create_strings(self, pattern=None):
    #     patterns = [
    #         '%S.N.S%SE%0E',
    #         '%S.N.S%0SE%E',
    #         '%S.N.S%SE%E',
    #         '%S.N.S%0SE%0E',
    #         '%SN S%SE%0E',
    #         '%SN S%0SE%E',
    #         '%SN S%SE%E',
    #         '%SN S%0SE%0E'
    #     ]
    #
    #     strings = []
    #     if not pattern:
    #         for p in patterns:
    #             strings += [self._format_pattern(p)]
    #         return strings
    #     return self._format_pattern(pattern)

    def pretty_name(self):
        """
        Returns the name of this episode in a "pretty" human-readable format. Used for logging
        and notifications and such.

        :return: A string representing the episode's name and season/ep numbers
        :rtype: AnyStr
        """

        if self._show_obj.anime and not self._show_obj.scene:
            return self._format_pattern('%SN - %AB - %EN')

        if self._show_obj.air_by_date:
            return self._format_pattern('%SN - %AD - %EN')

        return self._format_pattern('%SN - %Sx%0E - %EN')

    def _ep_name(self):
        """
        :return: the name of the episode to use during renaming. Combines the names of related episodes.
        E.g. "Ep Name (1)" and "Ep Name (2)" becomes "Ep Name"
             "Ep Name" and "Other Ep Name" becomes "Ep Name & Other Ep Name"
        :rtype: AnyStr
        """

        multi_name_regex = r'(.*) \(\d{1,2}\)'

        self.related_ep_obj = sorted(self.related_ep_obj, key=lambda se: se.episode)

        if 0 == len(self.related_ep_obj):
            good_name = self._name
        else:
            single_name = True
            known_good_name = None

            for cur_name in [self._name] + [_x.name for _x in self.related_ep_obj]:
                match = re.match(multi_name_regex, cur_name)
                if not match:
                    single_name = False
                    break

                if None is known_good_name:
                    known_good_name = match.group(1)
                elif known_good_name != match.group(1):
                    single_name = False
                    break

            if single_name:
                good_name = known_good_name
            else:
                good_name = self._name
                for cur_ep_obj in self.related_ep_obj:
                    good_name += ' & ' + cur_ep_obj.name

        return good_name or 'tba'

    def _replace_map(self):
        """
        Generates a replacement map for this episode which maps all possible custom naming patterns to the correct
        value for this episode.

        Returns: A dict with patterns as the keys and their replacement values as the values.
        """

        ep_name = self._ep_name()

        def dot(name):
            return helpers.sanitize_scene_name(name)

        def us(name):
            return re.sub('[ -]', '_', name)

        def release_name(name, is_anime=False):
            if name:
                name = helpers.remove_non_release_groups(name, is_anime)
            return name

        def release_group(show_obj, name):
            if name:
                name = helpers.remove_non_release_groups(name, show_obj.is_anime)
            else:
                return ''

            try:
                np = NameParser(name, show_obj=show_obj, naming_pattern=True)
                parse_result = np.parse(name)
            except (InvalidNameException, InvalidShowException) as e:
                logger.debug('Unable to get parse release_group: %s' % ex(e))
                return ''

            if not parse_result.release_group:
                return ''
            return parse_result.release_group

        ep_status, ep_qual = Quality.split_composite_status(self._status)

        if sickgear.NAMING_STRIP_YEAR:
            show_name = re.sub(r'\(\d+\)$', '', self._show_obj.name).rstrip()
        else:
            show_name = self._show_obj.name

        return {
            '%SN': show_name,
            '%S.N': dot(show_name),
            '%S_N': us(show_name),
            '%EN': ep_name,
            '%E.N': dot(ep_name),
            '%E_N': us(ep_name),
            '%QN': Quality.qualityStrings[ep_qual],
            '%Q.N': dot(Quality.qualityStrings[ep_qual]),
            '%Q_N': us(Quality.qualityStrings[ep_qual]),
            '%S': str(self._season),
            '%0S': '%02d' % self._season,
            '%E': str(self._episode),
            '%0E': '%02d' % self._episode,
            '%XS': str(self.scene_season),
            '%0XS': '%02d' % self.scene_season,
            '%XE': str(self.scene_episode),
            '%0XE': '%02d' % self.scene_episode,
            '%AB': '%(#)03d' % {'#': self._absolute_number},
            '%XAB': '%(#)03d' % {'#': self.scene_absolute_number},
            '%RN': release_name(self._release_name, self._show_obj.is_anime),
            '%RG': release_group(self._show_obj, self._release_name),
            '%AD': str(self._airdate).replace('-', ' '),
            '%A.D': str(self._airdate).replace('-', '.'),
            '%A_D': us(str(self._airdate)),
            '%A-D': str(self._airdate),
            '%Y': str(self._airdate.year),
            '%M': str(self._airdate.month),
            '%D': str(self._airdate.day),
            '%0M': '%02d' % self._airdate.month,
            '%0D': '%02d' % self._airdate.day,
            '%RT': "PROPER" if self.is_proper else "",
            '%V': 'v%s' % self._version if self._show_obj.is_anime and 1 < self._version else '',
        }

    @staticmethod
    def _format_string(pattern, replace_map):
        """
        Replaces all template strings with the correct value
        """

        result_name = pattern

        # do the replacements
        for cur_replacement in sorted(list(replace_map), reverse=True):
            result_name = result_name.replace(cur_replacement, helpers.sanitize_filename(replace_map[cur_replacement]))
            result_name = result_name.replace(cur_replacement.lower(),
                                              helpers.sanitize_filename(replace_map[cur_replacement].lower()))

        return result_name

    def _format_pattern(self, pattern=None, multi=None, anime_type=None):
        """
        Manipulates an episode naming pattern and then fills the template in
        """

        if None is pattern:
            pattern = sickgear.NAMING_PATTERN

        if None is multi:
            multi = sickgear.NAMING_MULTI_EP

        if None is anime_type:
            anime_type = sickgear.NAMING_ANIME

        replace_map = self._replace_map()

        result_name = pattern

        # if there's no release group then replace it with a reasonable facsimile
        if not replace_map['%RN']:
            if self._show_obj.air_by_date or self._show_obj.sports:
                result_name = result_name.replace('%RN', '%S.N.%A.D.%E.N-SickGear')
                result_name = result_name.replace('%rn', '%s.n.%A.D.%e.n-SickGear')
            elif 3 != anime_type:
                result_name = result_name.replace('%RN', '%S.N.%AB.%E.N-SickGear')
                result_name = result_name.replace('%rn', '%s.n.%ab.%e.n-SickGear')
            else:
                result_name = result_name.replace('%RN', '%S.N.S%0SE%0E.%E.N-SickGear')
                result_name = result_name.replace('%rn', '%s.n.s%0se%0e.%e.n-SickGear')

            result_name = result_name.replace('%RG', 'SickGear')
            result_name = result_name.replace('%rg', 'SickGear')
            logger.debug('Episode has no release name, replacing it with a generic one: %s' % result_name)

        if not replace_map['%RT']:
            result_name = re.sub('([ _.-]*)%RT([ _.-]*)', r'\2', result_name)

        # split off ep name part only
        name_groups = re.split(r'[\\/]', result_name)

        # figure out the double-ep numbering style for each group, if applicable
        for cur_name_group in name_groups:

            season_ep_regex = r'''
                                (?P<pre_sep>[ _.-]*)
                                ((?:s(?:eason|eries)?\s*)?%0?S(?![._]?N))
                                (.*?)
                                (%0?E(?![._]?N))
                                (?P<post_sep>[ _.-]*)
                              '''
            ep_only_regex = '(E?%0?E(?![._]?N))'

            # try the normal way
            season_ep_match = re.search(season_ep_regex, cur_name_group, re.I | re.X)
            ep_only_match = re.search(ep_only_regex, cur_name_group, re.I | re.X)

            # if we have a season and episode then collect the necessary data
            if season_ep_match:
                season_format = season_ep_match.group(2)
                ep_sep = season_ep_match.group(3)
                ep_format = season_ep_match.group(4)
                sep = season_ep_match.group('pre_sep')
                if not sep:
                    sep = season_ep_match.group('post_sep')
                if not sep:
                    sep = ' '

                # force 2-3-4 format if they chose to extend
                if multi in (NAMING_EXTEND, NAMING_LIMITED_EXTEND, NAMING_LIMITED_EXTEND_E_PREFIXED):
                    ep_sep = '-'

                regex_used = season_ep_regex

            # if there's no season then there's not much choice so we'll just force them to use 03-04-05 style
            elif ep_only_match:
                season_format = ''
                ep_sep = '-'
                ep_format = ep_only_match.group(1)
                sep = ''
                regex_used = ep_only_regex

            else:
                continue

            # we need at least this much info to continue
            if not ep_sep or not ep_format:
                continue

            # start with the ep string, e.g. E03
            ep_string = self._format_string(ep_format.upper(), replace_map)
            for cur_ep_obj in self.related_ep_obj:

                # for limited extend we only append the last ep
                if multi in (NAMING_LIMITED_EXTEND, NAMING_LIMITED_EXTEND_E_PREFIXED) \
                        and cur_ep_obj != self.related_ep_obj[-1]:
                    continue

                elif multi == NAMING_DUPLICATE:
                    # add " - S01"
                    ep_string += sep + season_format

                elif multi == NAMING_SEPARATED_REPEAT:
                    ep_string += sep

                # add "E04"
                ep_string += ep_sep

                if multi == NAMING_LIMITED_EXTEND_E_PREFIXED:
                    ep_string += 'E'

                # noinspection PyProtectedMember
                ep_string += cur_ep_obj._format_string(ep_format.upper(), cur_ep_obj._replace_map())

            if 3 != anime_type:
                absolute_number = (self._absolute_number, self._episode)[0 == self._absolute_number]

                if 0 != self._season:  # don't set absolute numbers if we are on specials !
                    if 1 == anime_type:  # this crazy person wants both ! (note: +=)
                        ep_string += sep + '%(#)03d' % {'#': absolute_number}
                    elif 2 == anime_type:  # total anime freak only need the absolute number ! (note: =)
                        ep_string = '%(#)03d' % {'#': absolute_number}

                    for cur_ep_obj in self.related_ep_obj:
                        if 0 != cur_ep_obj.absolute_number:
                            ep_string += '-' + '%(#)03d' % {'#': cur_ep_obj.absolute_number}
                        else:
                            ep_string += '-' + '%(#)03d' % {'#': cur_ep_obj.episode}

            regex_replacement = None
            if 2 == anime_type:
                regex_replacement = r'\g<pre_sep>' + ep_string + r'\g<post_sep>'
            elif season_ep_match:
                regex_replacement = r'\g<pre_sep>\g<2>\g<3>' + ep_string + r'\g<post_sep>'
            elif ep_only_match:
                regex_replacement = ep_string

            if regex_replacement:
                # fill out the template for this piece and then insert this piece into the actual pattern
                cur_name_group_result = re.sub('(?i)(?x)' + regex_used, regex_replacement, cur_name_group)
                # cur_name_group_result = cur_name_group.replace(ep_format, ep_string)
                # logger.debug("found "+ep_format+" as the ep pattern using "+regex_used+"
                # and replaced it with "+regex_replacement+" to result in "+cur_name_group_result+"
                # from "+cur_name_group)
                result_name = result_name.replace(cur_name_group, cur_name_group_result)

        result_name = self._format_string(result_name, replace_map)

        logger.debug('formatting pattern: %s -> %s' % (pattern, result_name))

        return result_name

    def proper_path(self):
        """
        Figures out the path where this episode SHOULD live according to the renaming rules, relative from the show dir
        :return:
        :rtype: AnyStr
        """

        anime_type = sickgear.NAMING_ANIME
        if not self._show_obj.is_anime:
            anime_type = 3

        result = self.formatted_filename(anime_type=anime_type)

        # if they want us to flatten it and we're allowed to flatten it then we will
        if self._show_obj.flatten_folders and not sickgear.NAMING_FORCE_FOLDERS:
            return result

        # if not we append the folder on and use that
        return os.path.join(self.formatted_dir(), result)

    def formatted_dir(self, pattern=None, multi=None):
        """
        Just the folder name of the episode
        """
        if None is pattern:
            pattern = self.naming_pattern()

        # split off the dirs only, if they exist
        name_groups = re.split(r'[\\/]', pattern)

        if 1 == len(name_groups):
            logger.debug('No Season Folder set in Naming pattern: %s' % pattern)
            return ''
        return self._format_pattern(os.sep.join(name_groups[:-1]), multi)

    def formatted_filename(self, pattern=None, multi=None, anime_type=None):
        """
        Just the filename of the episode, formatted based on the naming settings
        """
        # split off the dirs only, if they exist
        name_groups = re.split(r'[\\/]', pattern or self.naming_pattern())

        return self._format_pattern(name_groups[-1], multi, anime_type)

    def with_ep_name(self):
        # type: (...) -> bool
        """
        returns if the episode naming contain the episode name
        """
        return bool(pattern_ep_name.search(self.naming_pattern()))

    def naming_pattern(self):
        # type: (...) -> AnyStr
        """
        return a naming pattern for this show
        """
        # we only use ABD if it's enabled, this is an ABD show, AND this is not a multi-ep
        if self._show_obj.air_by_date and sickgear.NAMING_CUSTOM_ABD and not self.related_ep_obj:
            return sickgear.NAMING_ABD_PATTERN
        if self._show_obj.sports and sickgear.NAMING_CUSTOM_SPORTS and not self.related_ep_obj:
            return sickgear.NAMING_SPORTS_PATTERN
        if self._show_obj.anime and sickgear.NAMING_CUSTOM_ANIME:
            return sickgear.NAMING_ANIME_PATTERN

        return sickgear.NAMING_PATTERN

    def rename(self):
        # type: (...) -> Optional[bool]
        """
        Renames an episode file and all related files to the location and filename as specified
        in the naming settings.
        """

        if not os.path.isfile(self.location):
            logger.warning('Can\'t perform rename on %s when it doesn\'t exist, skipping' % self.location)
            return

        proper_path = self.proper_path()
        absolute_proper_path = os.path.join(self._show_obj.location, proper_path)
        absolute_current_path_no_ext, file_ext = os.path.splitext(self.location)
        absolute_current_path_no_ext_length = len(absolute_current_path_no_ext)

        related_subs = []

        current_path = absolute_current_path_no_ext

        if absolute_current_path_no_ext.startswith(self._show_obj.location):
            current_path = absolute_current_path_no_ext[len(self._show_obj.location):]

        logger.debug('Renaming/moving episode from the base path %s to %s' % (self.location, absolute_proper_path))

        # if it's already named correctly then don't do anything
        if proper_path == current_path:
            logger.debug('%s: File %s is already named correctly, skipping' % (self._epid, self.location))
            return

        related_files = postProcessor.PostProcessor(self.location).list_associated_files(
            self.location, base_name_only=True)

        if self.show_obj.subtitles and '' != sickgear.SUBTITLES_DIR:
            related_subs = postProcessor.PostProcessor(self.location).list_associated_files(sickgear.SUBTITLES_DIR,
                                                                                            subtitles_only=True)
            # absolute_proper_subs_path = os.path.join(sickgear.SUBTITLES_DIR, self.formatted_filename())

        logger.debug('Files associated to %s: %s' % (self.location, related_files))

        # move the ep file
        result = helpers.rename_ep_file(self.location, absolute_proper_path, absolute_current_path_no_ext_length,
                                        use_rename=True)

        any_renamed = all_renamed = result
        # move related files
        for cur_related_file in related_files:
            renamed = helpers.rename_ep_file(cur_related_file, absolute_proper_path,
                                             absolute_current_path_no_ext_length, use_rename=True)
            any_renamed |= renamed
            all_renamed &= renamed
            if not renamed:
                logger.error('%s: Unable to rename file %s' % (self._epid, cur_related_file))

        for cur_related_sub in related_subs:
            absolute_proper_subs_path = os.path.join(sickgear.SUBTITLES_DIR, self.formatted_filename())
            renamed = helpers.rename_ep_file(cur_related_sub, absolute_proper_subs_path,
                                             absolute_current_path_no_ext_length, use_rename=True)
            any_renamed |= renamed
            all_renamed &= renamed
            if not renamed:
                logger.error('%s: Unable to rename file %s' % (self._epid, cur_related_sub))

        # save the ep
        if any_renamed:
            with self.lock:
                self.location = absolute_proper_path + file_ext
                for cur_ep_obj in self.related_ep_obj:
                    cur_ep_obj.location = absolute_proper_path + file_ext

                # save any changes to the database
                sql_l = []
                for cur_ep_obj in [self] + self.related_ep_obj:  # type: TVEpisode
                    cur_ep_obj.create_meta_files(force=True, save_ep=False)
                    ep_sql = cur_ep_obj.get_sql()
                    if None is not ep_sql:
                        sql_l.append(ep_sql)

                if 0 < len(sql_l):
                    my_db = db.DBConnection()
                    my_db.mass_action(sql_l)

        return all_renamed

    def airdate_modify_stamp(self):
        """
        Make modify date and time of a file reflect the show air date and time.
        Note: Also called from postProcessor

        """
        has_timestamp = isinstance(self._timestamp, int) and 0 != self._timestamp
        if not has_timestamp and (not isinstance(self._airdate, datetime.date) or 1 == self._airdate.year):
            logger.debug(f'{self._show_obj.tvid_prodid}'
                         f': Did not change modify date of {os.path.basename(self.location)}'
                         f' because episode date is never aired or invalid')
            return

        aired_dt = None
        if has_timestamp:
            try:
                aired_dt = SGDatetime.from_timestamp(self._timestamp)
            except (BaseException, Exception):
                aired_dt = None

        if not aired_dt:
            if isinstance(self._airtime, datetime.time):
                airtime = self._airtime
            else:
                hr, m = network_timezones.parse_time(self._show_obj.airs)
                airtime = datetime.time(hr, m)

            aired_dt = SGDatetime.combine(self.airdate, airtime)

        try:
            aired_epoch = SGDatetime.to_file_timestamp(aired_dt)
            filemtime = int(os.path.getmtime(self.location))
        except (BaseException, Exception):
            return

        if filemtime != aired_epoch:

            result, loglevel = 'Changed', logger.MESSAGE
            if not helpers.touch_file(self.location, aired_epoch):
                result, loglevel = 'Error changing', logger.WARNING

            logger.log('%s: %s modify date of %s to show air date %s'
                       % (self._show_obj.tvid_prodid, result, os.path.basename(self.location),
                          'n/a' if not aired_dt else aired_dt.strftime('%b %d,%Y (%H:%M)')), loglevel)

    def __getstate__(self):
        d = dict(self.__dict__)
        del d['lock']
        return d

    def __setstate__(self, d):
        d['lock'] = threading.RLock()
        self.__dict__.update(d)

    def __bool__(self):
        return bool(self._tvid) and bool(self._epid)

    __nonzero__ = __bool__