plex.py

import logging
import os
import sqlite3
import time
from contextlib import closing

import db

try:
    from shlex import quote as cmd_quote
except ImportError:
    from pipes import quote as cmd_quote

import requests
import utils

logger = logging.getLogger("PLEX")


def show_detailed_sections_info(conf):
    from xml.etree import ElementTree
    try:
        logger.info("Requesting section info from Plex...")
        resp = requests.get('%s/library/sections/all?X-Plex-Token=%s' % (
            conf.configs['PLEX_LOCAL_URL'], conf.configs['PLEX_TOKEN']), timeout=30)
        if resp.status_code == 200:
            logger.info("Requesting of section info was successful.")
            logger.debug("Request response: %s", resp.text)
            root = ElementTree.fromstring(resp.text)
            print('')
            print("Plex Sections:")
            print("==============")
            for document in root.findall("Directory"):
                print('')
                print(document.get('key') + ') ' + document.get('title'))
                dashes_length = len(document.get('key') + ') ' + document.get('title'))
                print('-' * dashes_length)
                print("\n".join([os.path.join(k.get('path'), '') for k in document.findall("Location")]))
    except Exception as e:
        logger.exception("Issue encountered when attempting to list detailed sections info.")


def scan(config, lock, path, scan_for, section, scan_type, resleep_paths, scan_title=None, scan_lookup_type=None,
         scan_lookup_id=None):
    scan_path = ""

    # sleep for delay
    while True:
        logger.info("Scan request from %s for '%s'.", scan_for, path)

        if config['SERVER_SCAN_DELAY']:
            logger.info("Sleeping for %d seconds...", config['SERVER_SCAN_DELAY'])
            time.sleep(config['SERVER_SCAN_DELAY'])

        # check if root scan folder for
        if path in resleep_paths:
            logger.info("Another scan request occurred for folder of '%s'.", path)
            logger.info("Sleeping again for %d seconds...", config['SERVER_SCAN_DELAY'])
            utils.remove_item_from_list(path, resleep_paths)
        else:
            break

    # check file exists
    checks = 0
    check_path = utils.map_pushed_path_file_exists(config, path)
    scan_path_is_directory = os.path.isdir(check_path)

    while True:
        checks += 1
        if os.path.exists(check_path):
            logger.info("File '%s' exists on check %d of %d.", check_path, checks, config['SERVER_MAX_FILE_CHECKS'])
            if not scan_path or not len(scan_path):
                scan_path = os.path.dirname(path).strip() if not scan_path_is_directory else path.strip()
            break
        elif not scan_path_is_directory and config['SERVER_SCAN_FOLDER_ON_FILE_EXISTS_EXHAUSTION'] and \
                config['SERVER_MAX_FILE_CHECKS'] - checks == 1:
            # penultimate check but SERVER_SCAN_FOLDER_ON_FILE_EXISTS_EXHAUSTION was turned on
            # lets make scan path the folder instead for the final check
            logger.warning(
                "File '%s' reached the penultimate file check. Changing scan path to '%s'. Final check commences "
                "in %s seconds...", check_path, os.path.dirname(path), config['SERVER_FILE_CHECK_DELAY'])
            check_path = os.path.dirname(check_path).strip()
            scan_path = os.path.dirname(path).strip()
            scan_path_is_directory = os.path.isdir(check_path)
            time.sleep(config['SERVER_FILE_CHECK_DELAY'])
            # send Rclone cache clear if enabled
            if config['RCLONE']['RC_CACHE_REFRESH']['ENABLED']:
                utils.rclone_rc_clear_cache(config, check_path)

        elif checks >= config['SERVER_MAX_FILE_CHECKS']:
            logger.warning("File '%s' exhausted all available checks. Aborting scan request.", check_path)
            # remove item from database if sqlite is enabled
            if config['SERVER_USE_SQLITE']:
                if db.remove_item(path):
                    logger.info("Removed '%s' from Plex Autoscan database.", path)
                    time.sleep(1)
                else:
                    logger.error("Failed removing '%s' from Plex Autoscan database.", path)
            return

        else:
            logger.info("File '%s' did not exist on check %d of %d. Checking again in %s seconds...", check_path,
                        checks,
                        config['SERVER_MAX_FILE_CHECKS'],
                        config['SERVER_FILE_CHECK_DELAY'])
            time.sleep(config['SERVER_FILE_CHECK_DELAY'])
            # send Rclone cache clear if enabled
            if config['RCLONE']['RC_CACHE_REFRESH']['ENABLED']:
                utils.rclone_rc_clear_cache(config, check_path)

    # build plex scanner command
    if os.name == 'nt':
        final_cmd = '"%s" --scan --refresh --section %s --directory "%s"' \
                    % (config['PLEX_SCANNER'], str(section), scan_path)
    else:
        cmd = 'export LD_LIBRARY_PATH=' + config['PLEX_LD_LIBRARY_PATH'] + ';'
        if not config['USE_DOCKER']:
            cmd += 'export PLEX_MEDIA_SERVER_APPLICATION_SUPPORT_DIR=' + config['PLEX_SUPPORT_DIR'] + ';'
        cmd += config['PLEX_SCANNER'] + ' --scan --refresh --section ' + str(section) + ' --directory ' + cmd_quote(
            scan_path)

        if config['USE_DOCKER']:
            final_cmd = 'docker exec -u %s -i %s bash -c %s' % \
                        (cmd_quote(config['PLEX_USER']), cmd_quote(config['DOCKER_NAME']), cmd_quote(cmd))
        elif config['USE_SUDO']:
            final_cmd = 'sudo -u %s bash -c %s' % (config['PLEX_USER'], cmd_quote(cmd))
        else:
            final_cmd = cmd

    # invoke plex scanner
    priority = utils.get_priority(config, scan_path)
    logger.debug("Waiting for turn in the scan request backlog with priority '%d'...", priority)

    lock.acquire(priority)
    try:
        logger.info("Scan request is now being processed...")
        # wait for existing scanners being ran by Plex
        if config['PLEX_WAIT_FOR_EXTERNAL_SCANNERS']:
            scanner_name = os.path.basename(config['PLEX_SCANNER']).replace('\\', '')
            if not utils.wait_running_process(scanner_name, config['USE_DOCKER'], cmd_quote(config['DOCKER_NAME'])):
                logger.warning(
                    "There was a problem waiting for existing '%s' process(s) to finish. Aborting scan.", scanner_name)
                # remove item from database if sqlite is enabled
                if config['SERVER_USE_SQLITE']:
                    if db.remove_item(path):
                        logger.info("Removed '%s' from Plex Autoscan database.", path)
                        time.sleep(1)
                    else:
                        logger.error("Failed removing '%s' from Plex Autoscan database.", path)
                return
            else:
                logger.info("No '%s' processes were found.", scanner_name)

        # run external command before scan if supplied
        if len(config['RUN_COMMAND_BEFORE_SCAN']) > 2:
            logger.info("Running external command: %r", config['RUN_COMMAND_BEFORE_SCAN'])
            utils.run_command(config['RUN_COMMAND_BEFORE_SCAN'])
            logger.info("Finished running external command.")

        # wait for Plex to become responsive (if PLEX_CHECK_BEFORE_SCAN is enabled)
        if 'PLEX_CHECK_BEFORE_SCAN' in config and config['PLEX_CHECK_BEFORE_SCAN']:
            plex_account_user = wait_plex_alive(config)
            if plex_account_user is not None:
                logger.info("Plex is available for media scanning - (Server Account: '%s')", plex_account_user)

        # begin scan
        logger.info("Running Plex Media Scanner for: %s", scan_path)
        logger.debug(final_cmd)
        utils.run_command(final_cmd.encode("utf-8"))
        logger.info("Finished scan!")

        # remove item from Plex database if sqlite is enabled
        if config['SERVER_USE_SQLITE']:
            if db.remove_item(path):
                logger.debug("Removed '%s' from Plex Autoscan database.", path)
                time.sleep(1)
                logger.info("There are %d queued item(s) remaining.", db.queued_count())
            else:
                logger.error("Failed removing '%s' from Plex Autoscan database.", path)

        # empty trash if configured
        if config['PLEX_EMPTY_TRASH'] and config['PLEX_TOKEN'] and config['PLEX_EMPTY_TRASH_MAX_FILES']:
            logger.debug("Checking deleted items count in 10 seconds...")
            time.sleep(10)

            # check deleted item count, don't proceed if more than this value
            deleted_items = get_deleted_count(config)
            if deleted_items > config['PLEX_EMPTY_TRASH_MAX_FILES']:
                logger.warning("There were %d deleted files. Skip emptying of trash for Section '%s'.", deleted_items,
                               section)
            elif deleted_items == -1:
                logger.error("Could not determine deleted item count. Abort emptying of trash.")
            elif not config['PLEX_EMPTY_TRASH_ZERO_DELETED'] and not deleted_items and scan_type != 'Upgrade':
                logger.debug("Skipping emptying trash as there were no deleted items.")
            else:
                logger.info("Emptying trash to clear %d deleted items...", deleted_items)
                empty_trash(config, str(section))

        # analyze movie/episode
        if config['PLEX_ANALYZE_TYPE'].lower() != 'off' and not scan_path_is_directory:
            logger.debug("Sleeping for 10 seconds...")
            time.sleep(10)
            logger.debug("Sending analysis request...")
            analyze_item(config, path)

        # match item
        if config['PLEX_FIX_MISMATCHED'] and config['PLEX_TOKEN'] and not scan_path_is_directory:
            # were we initiated with the scan_title/scan_lookup_type/scan_lookup_id parameters?
            if scan_title is not None and scan_lookup_type is not None and scan_lookup_id is not None:
                logger.debug("Sleeping for 10 seconds...")
                time.sleep(10)
                logger.debug("Validating match for '%s' (%s ID: %s)...",
                             scan_title,
                             scan_lookup_type, str(scan_lookup_id))
                match_item_parent(config, path, scan_title, scan_lookup_type, scan_lookup_id)

        # run external command after scan if supplied
        if len(config['RUN_COMMAND_AFTER_SCAN']) > 2:
            logger.info("Running external command: %r", config['RUN_COMMAND_AFTER_SCAN'])
            utils.run_command(config['RUN_COMMAND_AFTER_SCAN'])
            logger.info("Finished running external command.")

    except Exception:
        logger.exception("Unexpected exception occurred while processing: '%s'", scan_path)
    finally:
        lock.release()
    return


def show_sections(config):
    if os.name == 'nt':
        final_cmd = '""%s" --list"' % config['PLEX_SCANNER']
    else:
        cmd = 'export LD_LIBRARY_PATH=' + config['PLEX_LD_LIBRARY_PATH'] + ';'
        if not config['USE_DOCKER']:
            cmd += 'export PLEX_MEDIA_SERVER_APPLICATION_SUPPORT_DIR=' + config['PLEX_SUPPORT_DIR'] + ';'
        cmd += config['PLEX_SCANNER'] + ' --list'

        if config['USE_DOCKER']:
            final_cmd = 'docker exec -u %s -it %s bash -c %s' % (
                cmd_quote(config['PLEX_USER']), cmd_quote(config['DOCKER_NAME']), cmd_quote(cmd))
        elif config['USE_SUDO']:
            final_cmd = 'sudo -u %s bash -c "%s"' % (config['PLEX_USER'], cmd)
        else:
            final_cmd = cmd
    logger.info("Using Plex Scanner")
    print("\n")
    print("Plex Sections:")
    print("==============")
    logger.debug(final_cmd)
    os.system(final_cmd)


def match_item_parent(config, scan_path, scan_title, scan_lookup_type, scan_lookup_id):
    if not os.path.exists(config['PLEX_DATABASE_PATH']):
        logger.info("Could not analyze '%s' because Plex database could not be found.", scan_path)
        return

    # get files metadata_item_id
    metadata_item_id = get_file_metadata_item_id(config, scan_path)
    if metadata_item_id is None:
        logger.error("Aborting match of '%s' as could not find 'metadata_item_id'.", scan_path)
        return

    # find metadata_item_id parent info
    metadata_item_parent_info = get_metadata_parent_info(config, int(metadata_item_id))
    if metadata_item_parent_info is None or 'parent_id' not in metadata_item_parent_info \
            or metadata_item_parent_info['parent_id'] is not None or 'id' not in metadata_item_parent_info \
            or 'title' not in metadata_item_parent_info:
        # parent_id should always be null as we are looking for a series or movie metadata_item_id which has no parent!
        logger.error(
            "Aborting match of '%s' because could not find 'metadata_item_id' of parent for 'metadata_item_id': %d",
            scan_path, int(metadata_item_id))
        return

    parent_metadata_item_id = metadata_item_parent_info['id']
    parent_title = metadata_item_parent_info['title']
    parent_guid = metadata_item_parent_info['guid']
    logger.debug("Found parent 'metadata_item' of '%s': %d = '%s'.", scan_path, int(parent_metadata_item_id),
                 parent_title)

    # did the metadata_item_id have matches already (dupes)?
    scan_directory = os.path.dirname(scan_path)
    metadata_item_id_has_dupes = get_metadata_item_id_has_duplicates(config, metadata_item_id, scan_directory)
    if metadata_item_id_has_dupes:
        # there are multiple media_items with this metadata_item_id who's folder does not match the scan directory
        # we must split the parent metadata_item, wait 10 seconds and then repeat the steps above
        if not split_plex_item(config, parent_metadata_item_id):
            logger.error(
                "Aborting match of '%s' as could not split duplicate 'media_items' with 'metadata_item_id': '%d'",
                scan_path, int(parent_metadata_item_id))
            return

        # reset variables from last lookup
        metadata_item_id = None
        parent_metadata_item_id = None
        parent_title = None
        parent_guid = None

        # sleep before looking up metadata_item_id again
        time.sleep(10)
        metadata_item_id = get_file_metadata_item_id(config, scan_path)
        if metadata_item_id is None:
            logger.error("Aborting match of '%s' as could not find post split 'metadata_item_id'.", scan_path)
            return

        # now lookup parent again
        metadata_item_parent_info = get_metadata_parent_info(config, int(metadata_item_id))
        if metadata_item_parent_info is None or 'parent_id' not in metadata_item_parent_info \
                or metadata_item_parent_info['parent_id'] is not None or 'id' not in metadata_item_parent_info \
                or 'title' not in metadata_item_parent_info:
            # parent_id should always be null as we are looking for a series or movie metadata_item_id
            # which has no parent!
            logger.error(
                "Aborting match of '%s' as could not find post-split 'metadata_item_id' of parent for "
                "'metadata_item_id': %d", scan_path, int(metadata_item_id))
            return

        parent_metadata_item_id = metadata_item_parent_info['id']
        parent_title = metadata_item_parent_info['title']
        parent_guid = metadata_item_parent_info['guid']
        logger.debug("Found parent 'metadata_item' of '%s': %d = '%s'.", scan_path, int(parent_metadata_item_id),
                     parent_title)

    else:
        # there were no duplicate media_items with this metadata_item_id
        logger.info("No duplicate 'media_items' found with 'metadata_item_id': '%d'", int(parent_metadata_item_id))

    # generate new guid
    new_guid = 'com.plexapp.agents.%s://%s?lang=%s' % (scan_lookup_type.lower(), str(scan_lookup_id).lower(),
                                                       config['PLEX_FIX_MISMATCHED_LANG'].lower())
    # does good match?
    if parent_guid and (parent_guid.lower() != new_guid):
        logger.debug("Fixing match for 'metadata_item' '%s' as existing 'GUID' '%s' does not match '%s' ('%s').",
                     parent_title,
                     parent_guid, new_guid, scan_title)
        logger.info("Fixing match of '%s' (%s) to '%s' (%s).", parent_title, parent_guid, scan_title, new_guid)
        # fix item
        match_plex_item(config, parent_metadata_item_id, new_guid, scan_title)
        refresh_plex_item(config, parent_metadata_item_id, scan_title)
    else:
        logger.debug(
            "Skipped match fixing for 'metadata_item' parent '%s' as existing 'GUID' (%s) matches what was "
            "expected (%s).", parent_title, parent_guid, new_guid)
        logger.info("Match validated for '%s' (%s).", parent_title, parent_guid)

    return


def analyze_item(config, scan_path):
    if not os.path.exists(config['PLEX_DATABASE_PATH']):
        logger.warning("Could not analyze of '%s' because Plex database could not be found.", scan_path)
        return
    # get files metadata_item_id
    metadata_item_ids = get_file_metadata_ids(config, scan_path)
    if metadata_item_ids is None or not len(metadata_item_ids):
        logger.warning("Aborting analysis of '%s' because could not find any 'metadata_item_id' for it.", scan_path)
        return
    metadata_item_id = ','.join(str(x) for x in metadata_item_ids)

    # build Plex analyze command
    analyze_type = 'analyze-deeply' if config['PLEX_ANALYZE_TYPE'].lower() == 'deep' else 'analyze'
    if os.name == 'nt':
        final_cmd = '"%s" --%s --item %s' % (config['PLEX_SCANNER'], analyze_type, metadata_item_id)
    else:
        cmd = 'export LD_LIBRARY_PATH=' + config['PLEX_LD_LIBRARY_PATH'] + ';'
        if not config['USE_DOCKER']:
            cmd += 'export PLEX_MEDIA_SERVER_APPLICATION_SUPPORT_DIR=' + config['PLEX_SUPPORT_DIR'] + ';'
        cmd += config['PLEX_SCANNER'] + ' --' + analyze_type + ' --item ' + metadata_item_id

        if config['USE_DOCKER']:
            final_cmd = 'docker exec -u %s -i %s bash -c %s' % \
                        (cmd_quote(config['PLEX_USER']), cmd_quote(config['DOCKER_NAME']), cmd_quote(cmd))
        elif config['USE_SUDO']:
            final_cmd = 'sudo -u %s bash -c %s' % (config['PLEX_USER'], cmd_quote(cmd))
        else:
            final_cmd = cmd

    # begin analysis
    logger.debug("Starting %s analysis of 'metadata_item': %s",
                 'deep' if config['PLEX_ANALYZE_TYPE'].lower() == 'deep' else 'basic', metadata_item_id)
    logger.debug(final_cmd)
    utils.run_command(final_cmd.encode("utf-8"))
    logger.info("Finished %s analysis of 'metadata_item': %s",
                'deep' if config['PLEX_ANALYZE_TYPE'].lower() == 'deep' else 'basic', metadata_item_id)


def get_file_metadata_item_id(config, file_path):
    try:
        with sqlite3.connect(config['PLEX_DATABASE_PATH']) as conn:
            conn.row_factory = sqlite3.Row
            with closing(conn.cursor()) as c:
                # query media_parts to retrieve media_item_row for this file
                for x in range(5):
                    media_item_row = c.execute("SELECT * FROM media_parts WHERE file=?", (file_path,)).fetchone()
                    if media_item_row:
                        logger.debug("Found row in 'media_parts' where 'file' = '%s' after %d of 5 tries.", file_path,
                                     x + 1)
                        break
                    else:
                        logger.error(
                            "Could not locate record in 'media_parts' where 'file' = '%s' in %d of 5 attempts...",
                            file_path, x + 1)
                        time.sleep(10)

                if not media_item_row:
                    logger.error("Could not locate record in 'media_parts' where 'file' = '%s' after 5 tries.",
                                 file_path)
                    return None

                media_item_id = media_item_row['media_item_id']
                if media_item_id and int(media_item_id):
                    # query db to find metadata_item_id
                    metadata_item_id = \
                        c.execute("SELECT * FROM media_items WHERE id=?", (int(media_item_id),)).fetchone()[
                            'metadata_item_id']
                    if metadata_item_id and int(metadata_item_id):
                        logger.debug("Found 'metadata_item_id' for '%s': %d", file_path, int(metadata_item_id))
                        return int(metadata_item_id)

    except Exception:
        logger.exception("Exception finding 'metadata_item_id' for '%s': ", file_path)
    return None


def get_metadata_item_id_has_duplicates(config, metadata_item_id, scan_directory):
    try:
        with sqlite3.connect(config['PLEX_DATABASE_PATH']) as conn:
            conn.row_factory = sqlite3.Row
            with closing(conn.cursor()) as c:
                # retrieve matches for metadata_item_id
                metadata_item_id_matches = c.execute('select '
                                                     'count(mi.id) as matches '
                                                     'from media_items mi '
                                                     'join media_parts mp on mp.media_item_id = mi.id '
                                                     'where mi.metadata_item_id=? and mp.file not like ?',
                                                     (metadata_item_id, scan_directory + '%',)).fetchone()
                if metadata_item_id_matches:
                    row_dict = dict(metadata_item_id_matches)
                    if 'matches' in row_dict and row_dict['matches'] >= 1:
                        logger.info(
                            "Found %d 'media_items' with 'metadata_item_id' %d where folder does not match: '%s'",
                            int(row_dict['matches']), int(metadata_item_id), scan_directory)
                        return True
                    else:
                        return False

        logger.error("Failed determining if 'metadata_item_id' '%d' has duplicate 'media_items'.",
                     int(metadata_item_id))
    except Exception:
        logger.exception("Exception determining if 'metadata_item_id' '%d' has duplicate 'media_items': ",
                         int(metadata_item_id))
    return False


def get_metadata_parent_info(config, metadata_item_id):
    try:
        with sqlite3.connect(config['PLEX_DATABASE_PATH']) as conn:
            conn.row_factory = sqlite3.Row
            with closing(conn.cursor()) as c:
                # retrieve parent info for metadata_item_id
                metadata_item_parent_info = c.execute('WITH cte_MediaItems AS ('
                                                      'SELECT '
                                                      'mi.* '
                                                      'FROM metadata_items mi '
                                                      'WHERE mi.id = ? '
                                                      'UNION '
                                                      'SELECT mi.* '
                                                      'FROM cte_MediaItems cte '
                                                      'JOIN metadata_items mi ON mi.id = cte.parent_id'
                                                      ') '
                                                      'SELECT '
                                                      'cte.id'
                                                      ', cte.parent_id'
                                                      ', cte.guid'
                                                      ', cte.title '
                                                      'FROM cte_MediaItems cte '
                                                      'WHERE cte.parent_id IS NULL '
                                                      'LIMIT 1', (metadata_item_id,)).fetchone()
                if metadata_item_parent_info:
                    metadata_item_row = dict(metadata_item_parent_info)
                    if 'parent_id' in metadata_item_row and not metadata_item_row['parent_id']:
                        logger.debug("Found parent row in 'metadata_items' for 'metadata_item_id' '%d': %s",
                                     int(metadata_item_id), metadata_item_row)
                        return metadata_item_row

                logger.error("Failed finding parent row in 'metadata_items' for 'metadata_item_id': %d",
                             int(metadata_item_id))

    except Exception:
        logger.exception("Exception finding parent info for 'metadata_item_id' '%d': ", int(metadata_item_id))
    return None


def get_file_metadata_ids(config, file_path):
    results = []
    media_item_row = None

    try:
        with sqlite3.connect(config['PLEX_DATABASE_PATH']) as conn:
            conn.row_factory = sqlite3.Row
            with closing(conn.cursor()) as c:
                # query media_parts to retrieve media_item_row for this file
                for x in range(5):
                    media_item_row = c.execute("SELECT * FROM media_parts WHERE file=?", (file_path,)).fetchone()
                    if media_item_row:
                        logger.debug("Found row in 'media_parts' where 'file' = '%s' after %d of 5 tries.", file_path,
                                     x + 1)
                        break
                    else:
                        logger.error(
                            "Could not locate record in 'media_parts' where 'file' = '%s' in %d of 5 attempts...",
                            file_path, x + 1)
                        time.sleep(10)

                if not media_item_row:
                    logger.error("Could not locate record in 'media_parts' where 'file' = '%s' after 5 tries",
                                 file_path)
                    return None

                media_item_id = media_item_row['media_item_id']
                if media_item_id and int(media_item_id):
                    # query db to find metadata_item_id
                    metadata_item_id = \
                        c.execute("SELECT * FROM media_items WHERE id=?", (int(media_item_id),)).fetchone()[
                            'metadata_item_id']
                    if metadata_item_id and int(metadata_item_id):
                        logger.debug("Found 'metadata_item_id' for '%s': %d", file_path, int(metadata_item_id))

                        # query db to find parent_id of metadata_item_id
                        if config['PLEX_ANALYZE_DIRECTORY']:
                            parent_id = \
                                c.execute("SELECT * FROM metadata_items WHERE id=?",
                                          (int(metadata_item_id),)).fetchone()['parent_id']
                            if not parent_id or not int(parent_id):
                                # could not find parent_id of this item, likely its a movie...
                                # lets just return the metadata_item_id
                                return [int(metadata_item_id)]
                            logger.debug("Found 'parent_id' for '%s': %d", file_path, int(parent_id))

                            # if mode is basic, single parent_id is enough
                            if config['PLEX_ANALYZE_TYPE'].lower() == 'basic':
                                return [int(parent_id)]

                            # lets find all metadata_item_id's with this parent_id for use with deep analysis
                            metadata_items = c.execute("SELECT * FROM metadata_items WHERE parent_id=?",
                                                       (int(parent_id),)).fetchall()
                            if not metadata_items:
                                # could not find any results, lets just return metadata_item_id
                                return [int(metadata_item_id)]

                            for row in metadata_items:
                                if row['id'] and int(row['id']) and int(row['id']) not in results:
                                    results.append(int(row['id']))

                            logger.debug("Found 'media_item_id' for '%s': %s", file_path, results)
                            logger.info("Found %d 'media_item_id' to deep analyze for: '%s'", len(results), file_path)
                        else:
                            # user had PLEX_ANALYZE_DIRECTORY as False - lets just scan the single metadata_item_id
                            results.append(int(metadata_item_id))

    except Exception as ex:
        logger.exception("Exception finding metadata_item_id for '%s': ", file_path)
    return results


def empty_trash(config, section):
    if len(config['PLEX_EMPTY_TRASH_CONTROL_FILES']):
        logger.info("Control file(s) are specified.")

        for control in config['PLEX_EMPTY_TRASH_CONTROL_FILES']:
            if not os.path.exists(control):
                logger.info("Skip emptying of trash as control file is not present: '%s'", control)
                return

        logger.info("Commence emptying of trash as control file(s) are present.")

    for x in range(5):
        try:
            resp = requests.put('%s/library/sections/%s/emptyTrash?X-Plex-Token=%s' % (
                config['PLEX_LOCAL_URL'], section, config['PLEX_TOKEN']), data=None, timeout=30)
            if resp.status_code == 200:
                logger.info("Trash cleared for Section '%s' after %d of 5 tries.", section, x + 1)
                break
            else:
                logger.error("Unexpected response status_code for empty trash request: %d in %d of 5 attempts...",
                             resp.status_code, x + 1)
                time.sleep(10)
        except Exception as ex:
            logger.exception("Exception sending empty trash for Section '%s' in %d of 5 attempts: ", section, x + 1)
            time.sleep(10)
    return


def wait_plex_alive(config):
    if not config['PLEX_LOCAL_URL'] or not config['PLEX_TOKEN']:
        logger.error(
            "Unable to check if Plex was ready for scan requests because 'PLEX_LOCAL_URL' and/or 'PLEX_TOKEN' are missing in config.")
        return None

    # PLEX_LOCAL_URL and PLEX_TOKEN was provided
    check_attempts = 0
    while True:
        check_attempts += 1
        try:
            resp = requests.get('%s/myplex/account' % (config['PLEX_LOCAL_URL']),
                                headers={'X-Plex-Token': config['PLEX_TOKEN'], 'Accept': 'application/json'},
                                timeout=30, verify=False)
            if resp.status_code == 200 and 'json' in resp.headers['Content-Type']:
                resp_json = resp.json()
                if 'MyPlex' in resp_json:
                    plex_user = resp_json['MyPlex']['username'] if 'username' in resp_json['MyPlex'] else 'Unknown'
                    return plex_user

            logger.error("Unexpected response when checking if Plex was available for scans "
                         "(Attempt: %d): status_code = %d - resp_text =\n%s",
                         check_attempts, resp.status_code, resp.text)
        except Exception:
            logger.exception("Exception checking if Plex was available at %s: ", config['PLEX_LOCAL_URL'])

        logger.warning("Checking again in 15 seconds (attempt %d)...", check_attempts)
        time.sleep(15)
        continue
    return None


def get_deleted_count(config):
    try:
        with sqlite3.connect(config['PLEX_DATABASE_PATH']) as conn:
            with closing(conn.cursor()) as c:
                deleted_metadata = \
                    c.execute('SELECT count(*) FROM metadata_items WHERE deleted_at IS NOT NULL').fetchone()[0]
                deleted_media_parts = \
                    c.execute('SELECT count(*) FROM media_parts WHERE deleted_at IS NOT NULL').fetchone()[0]

        return int(deleted_metadata) + int(deleted_media_parts)

    except Exception as ex:
        logger.exception("Exception retrieving deleted item count from Plex DB: ")
    return -1


def split_plex_item(config, metadata_item_id):
    try:
        url_params = {
            'X-Plex-Token': config['PLEX_TOKEN']
        }
        url_str = '%s/library/metadata/%d/split' % (config['PLEX_LOCAL_URL'], int(metadata_item_id))

        # send options request first (webui does this)
        requests.options(url_str, params=url_params, timeout=30)
        resp = requests.put(url_str, params=url_params, timeout=30)
        if resp.status_code == 200:
            logger.info("Successfully split 'metadata_item_id': '%d'", int(metadata_item_id))
            return True
        else:
            logger.error("Failed splitting 'metadata_item_id': '%d'... Response =\n%s\n", int(metadata_item_id),
                         resp.text)

    except Exception:
        logger.exception("Exception splitting 'metadata_item' %d: ", int(metadata_item_id))
    return False


def match_plex_item(config, metadata_item_id, new_guid, new_name):
    try:
        url_params = {
            'X-Plex-Token': config['PLEX_TOKEN'],
            'guid': new_guid,
            'name': new_name,
        }
        url_str = '%s/library/metadata/%d/match' % (config['PLEX_LOCAL_URL'], int(metadata_item_id))

        requests.options(url_str, params=url_params, timeout=30)
        resp = requests.put(url_str, params=url_params, timeout=30)
        if resp.status_code == 200:
            logger.info("Successfully matched 'metadata_item_id' '%d' to '%s' (%s).", int(metadata_item_id), new_name,
                        new_guid)
            return True
        else:
            logger.error("Failed matching 'metadata_item_id' '%d' to '%s': %s... Response =\n%s\n",
                         int(metadata_item_id),
                         new_name, new_guid, resp.text)

    except Exception:
        logger.exception("Exception matching 'metadata_item' %d: ", int(metadata_item_id))
    return False


def refresh_plex_item(config, metadata_item_id, new_name):
    try:
        url_params = {
            'X-Plex-Token': config['PLEX_TOKEN'],
        }
        url_str = '%s/library/metadata/%d/refresh' % (config['PLEX_LOCAL_URL'], int(metadata_item_id))

        requests.options(url_str, params=url_params, timeout=30)
        resp = requests.put(url_str, params=url_params, timeout=30)
        if resp.status_code == 200:
            logger.info("Successfully refreshed 'metadata_item_id' '%d' of '%s'.", int(metadata_item_id),
                        new_name)
            return True
        else:
            logger.error("Failed refreshing 'metadata_item_id' '%d' of '%s': Response =\n%s\n",
                         int(metadata_item_id),
                         new_name, resp.text)

    except Exception:
        logger.exception("Exception refreshing 'metadata_item' %d: ", int(metadata_item_id))
    return False