nzbmonkey.py

#! /usr/bin/env python3
# -*- coding: utf-8 -*-

"""
    NZB-Monkey
"""

import argparse
import base64
import io
import json
import operator
import os
import re
import sys
import webbrowser
import xml.etree.ElementTree as ET
from enum import Enum
from glob import glob
from os.path import basename, splitext, isfile, join, expandvars
from pathlib import Path
from time import sleep, time, localtime, strftime
from urllib.parse import urlparse, parse_qs, quote

from unicodedata import normalize

from nzblnkconfig import check_missing_modules

try:
    import pyperclip
    import requests
    import urllib3
    from configobj import ConfigObj, SimpleVal
    from validate import Validator
    from colorama import Fore, init, Style

    init()
except ImportError:
    check_missing_modules()
    sleep(10)
    sys.exit(1)

from nzblnkconfig import config_file, config_nzbmonkey
from version import __version__
from nzbmonkeyspec import getSpec

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

WAITING_TIME_LONG = 5
WAITING_TIME_SHORT = 1
REQUESTS_TIMEOUT = 20
SAVE_STDOUT = sys.stdout
SAVE_STDERR = sys.stderr


class ExeTypes(Enum):
    EXECUTE = 'EXECUTE',
    NZBGET = 'NZBGET',
    SABNZBD = 'SABNZBD',
    SYNOLOGYDLS = 'SYNOLOGYDLS'


class Col:
    OK = Fore.GREEN + Style.BRIGHT
    WARN = Fore.YELLOW + Style.BRIGHT
    FAIL = Fore.RED + Style.BRIGHT
    OFF = Fore.RESET + Style.RESET_ALL


# region NZB-Verifier


class NZBSegment(object):
    def __init__(self, bytes_, number, message_id=None):
        """NZB Segment

        :param int bytes_: Size in bytes
        :param int number: Segment number
        :param str message_id: MessageID
        """
        self.bytes_ = int(bytes_)
        self.number = int(number)

        if message_id:
            self.message_id = message_id

    def set_message_id(self, message_id):
        self.message_id = message_id


class NZBFile(object):
    def __init__(self, poster, date, subject, groups=None, segments=None, debug=False):
        """NZB File

        :param str poster: Poster name
        :param str date: Unix date
        :param str subject: Header/ Subject
        :param list groups: List with groups
        :param list segments: List with segments
        :param boolean debug: Enable verbose output
        """
        self.poster = poster
        self.date = date
        self.subject = subject
        self.groups = groups or list()
        self.segments = segments or list()
        self.debug = debug
        self.segments_total = 0
        self.expected_segments = -1
        self.missing_segments = None

        self.regexes = {'segments_jbin': re.compile(r'.+?\.(\d{1,5})-(\d{1,5})@'),
                        'files_jbin': re.compile(r'.+?_(\d{1,5})o(\d{1,5})@'),
                        'segments_powerpost': re.compile(r'part(\d{1,4})of(\d{1,5})')}

        self.guessed_segments = False

    def add_group(self, group):
        """Append Group to group list"""
        self.groups.append(group)

    def add_segment(self, segment):
        """Append segment to segment list"""
        self.segments.append(segment)

    def get_segment_count(self):
        """Return segment count"""
        self.segments_total = len(self.segments)
        return self.segments_total

    def get_expected_segments(self):
        """"Return expected segments"""

        if self.expected_segments > -1:
            return self.expected_segments
        else:
            return None

    def get_missing_segments(self):
        """Calculate missing segments and return the value"""
        # If expected value is available calculate missing segments

        if self.expected_segments > -1:
            self.missing_segments = self.expected_segments - self.segments_total

        return self.missing_segments

    def guess_expected_segments(self):
        """Guess the expected segments from the number attribute

        <segment bytes="391347" number="1">sdfgsdfhbtzutenur_2o88@videoot.local</segment>
        ...
        <segment bytes="247767" number="55">sdfgsdfhbtzutenur_2o88@videoot.local</segment>
        The highest number for this file is 55. So we guess we should have 55 Segments.
        """
        max_number = 0

        for segment in self.segments:
            if int(segment.number) > max_number:
                max_number = int(segment.number)

        self.expected_segments = max_number
        self.guessed_segments = True

    def determine_expected_segments_message_id(self, skip_segment_debug):
        """Determine expected segments from message id

        :param bool skip_segment_debug: Skip debug output for segment check - NZBKing removes Segment part from Header

        If Upload was done by JBinDown or PowerPost it is possible to get the expected
        segments from MessageID
        """

        try:
            counter = re.search(self.regexes['segments_jbin'], self.segments[0].message_id).groups()
        except AttributeError:
            counter = (0,)
        if counter and len(counter) == 2:
            self.expected_segments = int(counter[1])

            if self.debug and not skip_segment_debug:
                print('      Got expected segments from jBinDown MessageID.')

            return
        try:
            counter = re.search(self.regexes['segments_powerpost'], self.segments[0].message_id).groups()
        except AttributeError:
            counter = (0,)
        if counter and len(counter) == 2:
            if self.debug and not skip_segment_debug:
                print('     Got expected segments from PowerPost MessageID.')

            self.expected_segments = int(counter[1])
            return
        if self.debug and not skip_segment_debug:
            print('       Can\'t get expected segments from MessageID.')
            print('       Try to get them from number attribute.')

        self.guess_expected_segments()

    def determine_expected_files_message_id(self):
        """Determine expected files from message id

        If Upload was done by JBinUp, it is possible to get the expected
        files from MessageID
        """

        try:
            counter = re.search(self.regexes['files_jbin'], self.segments[0].message_id).groups()
        except AttributeError:
            counter = (0,)
        if counter and len(counter) == 2:
            return int(counter[1])

        return -1


class NZBParser(object):
    """Check NZB completion
    1. Check filecount. Used the [1/10] part in Header to get the expected filecount.
        If the uploader uses (1/10) instead of [1/10] as required in yEnc specs NZBindex is filtering this
        and a filecount check is not possible. If the Segment Check is OK and the min age is exceeded
        then the upload should be finished.
    2. Check segments. Used the (1/255) part at the header end to get the expected Segment count.

    For both checks is a limit until the nzb file is OK
    ---------
    Based on pynzb by Eric Florenzano
        Copyright (c) 2009, Eric Florenzano
        All rights reserved.
        http://github.com/ericflo/pynzb/

    """

    def __init__(self, nzb_file, max_missing_files=2, max_missing_segments_percent=2.5, waiting_time=0.5, debug=False,
                 skip_segment_debug=False):
        """Initialize NZB Parser

        :param str,byte nzb_file: nzb file
        :param int max_missing_files: How many files may be missing
        :param float max_missing_segments_percent:  How many segments (in percentage) may be missing
        :param float waiting_time: Waiting time after output
        :param bool debug: Enable verbose output
        :param bool skip_segment_debug: Skip debug output for segment check - NZBKing removes Segment part from Header

        """
        try:
            self.nzb = bytearray(nzb_file, encoding='utf-8')
        except TypeError:
            pass

        # If a NZB download failed we receive sometimes malformed NZB Files or html.
        if self.nzb.lower().find(b'does not exist') != -1 or self.nzb.lower().find(b'doctype html') != -1:
            self.nzb_malformed = True
            print(Col.WARN + '   Received no NZB from Indexer' + Col.OFF)
        else:
            self.nzb_malformed = False

        self.files = list()
        self.segments_total = 0
        self.segments_missing = 0
        self.segments_additional = 0
        self.segments_missing_percent = -1.0
        self.segments_expected_total = 0

        self.files_total = 0
        self.files_expected = -1
        self.files_with_missing_segments = 0
        self.files_with_too_many_segments = 0
        self.files_with_unknown_segments = 0
        self.files_checked = 0
        self.files_missing = -1

        self.files_min_upload_time = 0
        self.files_max_upload_time = 0
        self.files_upload_duration = 0

        self.regexes = {
            'file_count_subject_1': re.compile(r'.*?[(\[](\d{1,4})/(\d{1,4})[)\]].*?\((\d{1,4})/(\d{1,5})\)', re.I),
            'file_count_subject_2': re.compile(r'.*?\[(\d{1,4})/(\d{1,5})\]', re.I),
            'segment_count_subject': re.compile(r'.*?\((\d{1,4})/(\d{1,5})\)$', re.I)}

        self.max_missing_files = int(max_missing_files)
        self.max_missing_segments_percent = float(max_missing_segments_percent)

        self.waiting_time = waiting_time

        self.debug = debug
        self.skip_segment_debug = skip_segment_debug

        self.parse()

    @staticmethod
    def get_etree_iter(xml):

        return iter(ET.iterparse(io.BytesIO(xml), events=('start', 'end')))

    def get_files_missing(self):
        """Return  missing files"""
        return self.files_missing

    def get_segments_missing_percent(self):
        """Return missing segments in percent"""
        return self.segments_missing_percent

    def get_upload_start_time(self):
        """Return upload start time in human readable values

        :return str: Timestamp as YYYY-MM-DD HH:MM:SS if time stamp is available"""

        if self.files_max_upload_time == 0:
            self.determine_time_stamps()
        if self.files_max_upload_time > 0:
            return strftime('%Y-%m-%d', localtime(float(self.files_max_upload_time)))
        else:
            return 'Not available'

    def get_upload_duration(self):
        """Return upload duration time in human readable values

        :return str: Timestamp as [DD day(s)] HH:MM:SS if time stamp is available"""
        if self.files_upload_duration == 0:
            self.determine_time_stamps()
        if self.files_upload_duration > 0:
            return sec_to_time(self.files_upload_duration)
        else:
            return 'Not available'

    def get_upload_age(self):
        """Return Upload age in  human readable values

        :return str: Upload age as [DD day(s)] HH:MM:SS if time stamp is available"""
        if self.files_max_upload_time == 0:
            self.determine_time_stamps()
        if self.files_max_upload_time > 0:
            return sec_to_time(int(time() - self.files_max_upload_time), days_only=True)
        else:
            return 'Not available'

    def parse(self):
        """Parse NZB file"""

        if self.nzb_malformed:
            return
        context = self.get_etree_iter(self.nzb)
        current_file, current_segment = None, None

        try:
            for event, elem in context:
                if event == 'start':
                    # If it's an NZBFile, create an object so that we can add the
                    # appropriate stuff to it.
                    if elem.tag == '{http://www.newzbin.com/DTD/2003/nzb}file':
                        current_file = NZBFile(
                            poster=elem.attrib['poster'],
                            date=elem.attrib['date'],
                            subject=elem.attrib['subject'],
                            debug=self.debug)

                elif event == 'end':
                    if elem.tag == '{http://www.newzbin.com/DTD/2003/nzb}file':
                        self.files.append(current_file)

                    elif elem.tag == '{http://www.newzbin.com/DTD/2003/nzb}group':
                        current_file.add_group(elem.text)

                    elif elem.tag == '{http://www.newzbin.com/DTD/2003/nzb}segment':
                        current_file.add_segment(
                            NZBSegment(
                                bytes_=elem.attrib['bytes'],
                                number=elem.attrib['number'],
                                message_id=elem.text
                            )
                        )
                    # Clear the element, we don't need it any more.
                    elem.clear()
        except Exception:
            pass

    def determine_expected_files(self, nzbfile):
        """Determine expected files

        :param nzbfile: NZBFile Object
        # Search subject for [file counter] (segment counter) or  (file counter) (segment counter)
        # [1/5] (1/235) or (1/5) (1/235)
        """

        try:
            counter = re.search(self.regexes['file_count_subject_1'], nzbfile.subject).groups()
        except AttributeError:
            counter = (0,)
        # Regex matched

        if counter and len(counter) == 4:
            return int(counter[1])

        # Found NZBs without segment counter
        # Second regex searches only for file counter  [1/5]

        if self.debug and not self.skip_segment_debug:
            print('       No segment counter in header - search now only for [x/y]')
        try:
            counter = re.search(self.regexes['file_count_subject_2'], nzbfile.subject).groups()
        except AttributeError:
            counter = (0,)
        # Regex matched

        if counter and len(counter) == 2:
            return int(counter[1])

        # NZBIndex removes filecount from Uploads with ($1/$2) filecount subject
        # If uploaded by jBinUp, filecount is in messageID
        counter = nzbfile.determine_expected_files_message_id()

        if int(counter) > 0:
            return int(counter)
        return -1

    def determine_expected_segments(self, nzbfile):
        """Determine expected segments

        :param nzbfile: NZBFile Object
        """
        try:
            counter = re.search(self.regexes['segment_count_subject'], nzbfile.subject).groups()
        except AttributeError:
            counter = (0,)
        # Regex matched

        if counter and len(counter) == 2:
            nzbfile.expected_segments = int(counter[1])
            return
        if self.debug and not self.skip_segment_debug:
            print(
                '       No segment counter in header found. Check for jBinDown or Powerpost message id segment counter')
        nzbfile.determine_expected_segments_message_id(self.skip_segment_debug)
        return

    def determine_expected_files_and_segments(self):
        """Parse file subjects to get expected file and segment count"""
        if self.nzb_malformed:
            return
        for item in self.files:
            # File count
            filecount = self.determine_expected_files(item)

            if self.files_expected == -1 and int(filecount) > 0:
                self.files_expected = int(filecount)
            # Some uploaders add additional files after download starts
            # Use the highest file count
            elif self.files_expected < int(filecount):
                self.files_expected = int(filecount)

            # Segment count
            self.determine_expected_segments(item)

    def determine_time_stamps(self):
        """Determine lowest and highest upload timestamp from files

        self.files_max_upload_time is the oldest files
        self.files_min_upload_time is the youngest file
        """

        for item in self.files:
            timestamp = int(item.date)
            if timestamp > self.files_max_upload_time:
                self.files_max_upload_time = timestamp

            if self.files_min_upload_time > timestamp:
                self.files_min_upload_time = timestamp
            elif self.files_min_upload_time == 0:
                self.files_min_upload_time = timestamp

        if self.files_min_upload_time > 0 and self.files_max_upload_time > 0:
            self.files_upload_duration = self.files_max_upload_time - self.files_min_upload_time

    def check_completion(self):
        """Check files and segments for completion"""

        # Clear counters
        self.files_total = 0
        self.files_expected = -1
        self.files_with_missing_segments = 0
        self.files_with_too_many_segments = 0
        self.files_with_unknown_segments = 0
        self.files_checked = 0
        self.files_missing = -2

        self.segments_total = 0
        self.segments_missing = 0
        self.segments_additional = 0
        self.segments_expected_total = 0
        self.segments_missing_percent = -1.0

        if self.nzb_malformed:
            return False, 1

        print('   - Check NZB (Max. {0} missing files - Max. {1}% missing Segments)'
              .format(self.max_missing_files, self.max_missing_segments_percent))

        # Update counters
        if self.debug:
            print('     Update counter ... ')
        self.files_total = len(self.files)
        self.determine_expected_files_and_segments()
        self.determine_time_stamps()

        file_check_ok = False
        segment_check_ok = False
        segments_guessed = False

        # Check files
        print('     Check file count ... ', end='', flush=True)
        if self.files_expected > -1:
            self.files_missing = self.files_expected - self.files_total

            # There is one extra file e.g. a nzb file as file number 000 - [000/xxx] "yyy.nzb"
            if self.files_missing == -1:
                self.files_missing = 0
                self.files_expected += 1
                if self.debug:
                    print(Col.WARN + 'One extra file ' + Col.OFF, end='', flush=True)
            # To many missing files
            if not self.files_total >= self.files_expected - self.max_missing_files:
                print(Col.FAIL + 'Failed - Only {0} from {1} files'
                      .format(self.files_total, self.files_expected) + Col.OFF)
                print_and_wait(Col.FAIL + '     Skip Segment check' + Col.OFF, self.waiting_time)
                return False, 2
            # More files than expected
            elif self.files_missing < 0:
                print(Col.WARN + 'More files than expected - {0} from {1} files'
                      .format(self.files_total, self.files_expected) + Col.OFF)
            # Filecount is OK
            else:
                print(Col.OK + 'OK - {0} from {1} files'
                      .format(self.files_total, self.files_expected) + Col.OFF)
                file_check_ok = True
        else:
            self.files_missing = self.files_total
            print(Col.WARN + 'Skip - No information found' + Col.OFF)

        # Check Segments for each file
        print('     Check segments ...')
        for item_count, item in enumerate(self.files, start=1):
            segments = item.get_segment_count()
            segments_missing = item.get_missing_segments()

            if segments_missing is None:
                self.files_with_unknown_segments += 1
            elif segments_missing == 0:
                self.files_checked += 1
            elif segments_missing > 0:
                self.segments_missing += segments_missing
                self.files_with_missing_segments += 1
                self.files_checked += 1
            elif segments_missing < 0:
                self.segments_additional += -segments_missing
                self.files_with_too_many_segments += 1
                self.files_checked += 1

            if item.get_expected_segments():
                self.segments_expected_total += item.get_expected_segments()

            # Because we guessed the expected segments we depreciate the check
            if item.guessed_segments:
                segments_guessed = True
                if self.segments_missing == 0:
                    self.segments_missing = 1
                    self.segments_total += 1

            self.segments_total += segments

        # Results
        if self.files_with_unknown_segments > 0:
            print('       Files with unknown segment count: ', end='', flush=True)
            print(Col.WARN + '{0}'.format(self.files_with_unknown_segments) + Col.OFF)

        if self.files_with_missing_segments > 0:
            print('       Files with missing segments: ', end='', flush=True)
            print(Col.WARN + '{0}'.format(self.files_with_missing_segments) + Col.OFF)

        if self.files_with_too_many_segments > 0:
            print('       Files with too many segments: ', end='', flush=True)
            print(Col.WARN + '{0}'.format(self.files_with_too_many_segments) + Col.OFF)

        if self.debug:
            print('       Total Segments:       {:6d}'.format(self.segments_total))
            print('       Expected Segments:    {:6d}'.format(self.segments_expected_total))
            print('       Missing Segments:     {:6d}'.format(self.segments_missing))
            print('       Additional Segments:  {:6d}'.format(self.segments_additional))

        # Check if missing segments are in OK range
        if self.segments_missing > 0:
            missing_percent = float(self.segments_missing) / (float(self.segments_expected_total) / 100)
            self.segments_missing_percent = missing_percent
            if missing_percent > self.max_missing_segments_percent:
                print_and_wait(Col.FAIL + '       Failed - Too many missing Segments: {0} = {1:.3f}%'
                               .format(self.segments_missing, missing_percent) + Col.OFF, self.waiting_time)
                return False, 3
            else:
                print(Col.WARN + '       Warning - missing Segments: {0} = {1:.3f}%\n'
                      .format(self.segments_missing, missing_percent) + Col.OFF)
                segment_check_ok = True

        if file_check_ok and self.files_with_missing_segments == 0 and self.files_with_too_many_segments == 0 \
                and self.files_with_unknown_segments == 0 and not segments_guessed:
            self.segments_missing_percent = 0.0
            print(Col.OK + '       OK - {0} from {1} segments\n'
                  .format(self.segments_total, self.segments_expected_total) + Col.OFF)
            print('     Overall result: ', end='', flush=True)
            print_and_wait(Col.OK + 'OK - All {0} files are complete'.format(self.files_checked) + Col.OFF,
                           self.waiting_time)
            return True, 1

        print('     Overall result: ', end='', flush=True)
        # File count and Segment count are OK and no files with unknown segment count
        if file_check_ok and segment_check_ok and self.files_with_unknown_segments == 0 and not segments_guessed:
            print_and_wait(Col.OK + 'OK - File check: OK - Segment check: OK' + Col.OFF, self.waiting_time)
            return True, 2

        # File count OK. Segment check is OK, but we had to guess the expected segment count
        if file_check_ok and segment_check_ok and segments_guessed:
            print_and_wait(Col.WARN + 'Warning - ' + Col.OK + 'File check: OK - ' + Col.WARN
                           + 'Segment check is OK, but we used a unreliable source' + Col.OFF, self.waiting_time)
            return True, 3

        # No check possible for file count.
        # Segment check was done for more than 1 file with no missing segments or check was in OK range and
        # no files without segment count
        if self.files_checked > 0 and (
                self.segments_missing == 0 or segment_check_ok) and self.files_with_unknown_segments == 0:
            print_and_wait(Col.OK + 'OK - File count is unknown - Segment check is OK' + Col.OFF, self.waiting_time)
            return True, 4

        # No check possible for file count and segment count
        # Segment check was done for more than 1 file and was in OK range
        if self.files_checked > 0 and (self.segments_missing == 0 or segment_check_ok):
            print(Col.WARN + 'Warning - File count is unknown - Segment count is unknown' + Col.OFF)
            print_and_wait(Col.WARN + '       The odds are good that the download will be successful' + Col.OFF,
                           self.waiting_time)
            return True, 5

        self.segments_missing_percent = 100.0
        print_and_wait(Col.FAIL + 'Skip - No information found' + Col.OFF, self.waiting_time)
        return False, 4


# endregion

# region NZB-Download


class NZBDownload(object):
    """Search for NZB on one and download. Return NZB content if download was successful.

    :param str search_url: Search URL
    :param str regex: Regex to find NZB download data
    :param download_url: Download URL
    :param search_header: Header to search for
    :param debug: Verbose output

    :return bool, str: Status, NZB Content
    """

    def __init__(self, search_url, regex, download_url, search_header, debug=False):
        """Initialize NZB Downloader"""
        self.search_url = search_url
        self.regex = regex
        self.download_url = download_url
        self.header = search_header
        self.debug = debug

        self.nzb_url = ''
        self.nzb = ''

    def search_nzb_url(self):
        """Search for NZB Download URL and return the URL
        :return bool, str: """
        try:
            self.header = self.header.replace('_', ' ')
            res = requests.get(self.search_url.format(quote(self.header, encoding='utf-8')),
                               timeout=REQUESTS_TIMEOUT, headers={'Cookie': 'agreed=true'}, verify=False)
        except requests.exceptions.Timeout:
            print(Col.WARN + ' Timeout' + Col.OFF, flush=True)
            return False, None
        except requests.exceptions.ConnectionError:
            print(Col.WARN + ' Connection Error' + Col.OFF, flush=True)
            return False, None

        m = re.search(self.regex, res.text, re.DOTALL)
        if m is None:
            print(Col.WARN + ' NOT FOUND' + Col.OFF, flush=True)
            return False, None

        self.nzb_url = self.download_url.format(**m.groupdict())

        return True, self.nzb_url

    def download_nzb(self):
        """Download NZB and return the NZB content

        :returns bool, str:"""
        if not self.nzb_url:
            res, _ = self.search_nzb_url()
            if not res:
                return False, None
        try:
            urlparam = self.nzb_url.split('\t')
            headers = {'Content-Type': 'application/x-www-form-urlencoded'}
            if len(urlparam) > 1:
                res = requests.post(urlparam[0], data=urlparam[1], headers=headers, timeout=REQUESTS_TIMEOUT,
                                    verify=False)
            else:
                res = requests.get(self.nzb_url, timeout=REQUESTS_TIMEOUT, verify=False)
        except requests.exceptions.Timeout:
            print(Col.WARN + ' Timeout' + Col.OFF, flush=True)
            return False, None
        except requests.exceptions.ConnectionError:
            print(Col.WARN + ' Connection Error' + Col.OFF, flush=True)
            return False, None

        if res.status_code != 200:
            print(Col.WARN + ' NOT FOUND' + Col.OFF, flush=True)
            return False, None

        print(Col.OK + ' DONE' + Col.OFF)

        self.nzb = res.text

        return True, self.nzb


def search_nzb(header, password, search_engines, best_nzb, max_missing_files, max_missing_segments_percent,
               skip_failed=True, debug=False):
    """Search for NZB file on several search engines and returns a NZB if successful

    :param str header: Header to search for
    :param str password: NZB password
    :param dict search_engines: List with search engines and their priority
    :param bool best_nzb: Search for best incomplete NZB if no complete NZB available
    :param int max_missing_files: How many missing files until NZB  file check failed
    :param int max_missing_segments_percent: How many missing segments (in percent) until NZB segment check failed
    :param bool skip_failed: Skip download for failed NZB files
    :param bool debug: Enable verbose output
    :returns int, str, str: Return code, NZB content, search engine name. Return code 0 is OK, return code > 0 is NOK
    """
    print(' - Searching NZB{}'.format(' - Search for best NZB enabled' if best_nzb else ''))

    search_defs = {
        'binsearch':
            {
                'name': 'BinSearch',
                'searchUrl': 'https://binsearch.info/?q={0}',
                'regex': r'href="/details/(?P<id>[^"]+)"',
                'downloadUrl': 'https://binsearch.info/nzb?{id}=on',
                'skip_segment_debug': False
            },
        'nzbking':
            {
                'name': 'NZBKing',
                'searchUrl': 'https://www.nzbking.com/search/?q={0}',
                'regex': r'href="/nzb:(?P<id>.*?)/".*"',
                'downloadUrl': 'https://www.nzbking.com/nzb:{id}/',
                'skip_segment_debug': True
            },
        'nzbindex':
            {
                'name': 'NZBIndex',
                'searchUrl': 'https://nzbindex.com/search/rss?q={0}&hidespam=1&sort=agedesc&complete=1',
                'regex': r'<link>https:\/\/nzbindex\.com\/download\/(?P<id>\d+)\/?<\/link>',
                'downloadUrl': 'https://nzbindex.com/download/{id}/',
                'skip_segment_debug': False
            }
    }

    downloaded_nzbs = list()
    active_search_engines = dict()

    for engine in search_engines:
        if engine not in search_defs:
            print('   with {}{} is no valid value for search engines{}'.format(engine, Col.FAIL, Col.OFF))
            continue
        priority = int(search_engines[engine])
        if priority == 0:
            print('   with {} ... {}Disabled{}'.format(search_defs[engine]['name'], Col.OK, Col.OFF))
            continue
        if priority < 0 or priority > 9:
            print('   with {} ... {}Only values between 0-9 allowed!{}'.format(search_defs[engine]['name'], Col.FAIL,
                                                                               Col.OFF))
            continue
        if priority not in active_search_engines:
            active_search_engines[priority] = list()
        active_search_engines[priority].append(engine)

    found_complete_nzb = False

    for prio in sorted(active_search_engines):
        for engine in active_search_engines[prio]:
            if found_complete_nzb:
                continue
            print('   with {} ...'.format(search_defs[engine]['name']), end='', flush=True)

            result, nzb = NZBDownload(search_defs[engine]['searchUrl'],
                                      search_defs[engine]['regex'],
                                      search_defs[engine]['downloadUrl'],
                                      header).download_nzb()
            if not result:
                continue

            nzb_check = NZBParser(nzb,
                                  max_missing_files,
                                  max_missing_segments_percent,
                                  WAITING_TIME_SHORT if best_nzb else WAITING_TIME_LONG,
                                  debug,
                                  search_defs[engine]['skip_segment_debug'])
            nzb_complete, _ = nzb_check.check_completion()

            tmp_nzb = [search_defs[engine]['name'],
                       nzb,
                       nzb_check.get_files_missing(),
                       nzb_check.get_segments_missing_percent(),
                       nzb_complete,
                       nzb_check.get_upload_start_time(),
                       nzb_check.get_upload_duration(),
                       nzb_check.get_upload_age()]
            # NZB is complete
            if nzb_complete:
                tmp_nzb.append(True)
                downloaded_nzbs.append(tmp_nzb)
                # Stop downloading more NZB files
                if not best_nzb or (tmp_nzb[2] == 0 and tmp_nzb[3] == 0.0):
                    found_complete_nzb = True

            # NZB not complete. Add NZB if no complete NZB until now and we allow incomplete NZBs
            elif not downloaded_nzbs and not skip_failed:
                tmp_nzb.append(False)
                downloaded_nzbs.append(tmp_nzb)

    # No NZB download
    if not downloaded_nzbs:
        print(Col.FAIL + '\nNo NZB downloaded!\n' + Col.OFF, flush=True)
        return 2, '', ''

    res_best_nzb = get_best_nzb(downloaded_nzbs)
    nzb = res_best_nzb[1]
    if res_best_nzb:
        print('\n   use NZB from {}'.format(res_best_nzb[0]), flush=True)
        print('     Upload age:      {}'.format(res_best_nzb[7]))
        if debug:
            print('     Upload started:  {}'.format(res_best_nzb[5]))
            print('     Upload duration: {}'.format(res_best_nzb[6]))
        # Output warning if we push a failed NZB
        if not res_best_nzb[4]:
            print(Col.FAIL + '\n     You use a NZB with a failed completion test!\n' + Col.OFF, flush=True)
            sleep(WAITING_TIME_LONG)

    # inject password into nzb file, see: http://wiki.sabnzbd.org/nzb-specs
    if password is not None and nzb.find('<head>') < 0:
        # Check for illegal characters in xml &, <, >, " and '
        if re.search('[&"\'<>]', password) is not None:
            print(Col.WARN + ' - Can\'t inject password in NZB file, forbidden characters included.' + Col.OFF)
        else:
            nzb = nzb.replace('</nzb>', '<head><meta type="password">%s</meta></head></nzb>' % password)
    return 0, nzb, res_best_nzb[0]


def get_best_nzb(nzb_downloads):
    """Sort the NZB to return the first complete or best incomplete NZB

    :param nzb_downloads: NZB downloads
    :returns: list with values from best NZB
    """
    # Only one NZB file
    if len(nzb_downloads) == 1:
        return nzb_downloads[0]

    sorted_nzb = sorted(nzb_downloads, key=operator.itemgetter(2, 3))
    return sorted_nzb[0]


# endregion

# region  Misc Tools


def clean_nzb_folder(source_path, max_age=2):
    """Delete NZB files older than max_days and returns nu,ber of deleted files

     :param source_path: Folder to search for NZB files
     :param max_age: Max NZB file age
     :returns: number of deleted files
     """
    if not os.path.exists(source_path):
        return -1
    current_time = time()
    try:
        files = list()
        file_list = glob(os.path.join(source_path, '*.nzb'))
        for f in file_list:
            if not os.path.isfile(f):
                continue
            modification_time = os.path.getmtime(f)
            if (current_time - modification_time) // (24 * 3600) >= int(max_age):
                files.append(f)
        for f in files:
            os.remove(f)
        return len(files)

    except OSError as e:
        print(Col.FAIL + '  OSError: {}'.format(e) + Col.OFF)

    return -1


def check_folder(path):
    """ Check if path exists. If not create it. Returns a boolean status

    :param str path: Folder path to check
    :returns bool: Returns True if folder exists or successful created otherwise False
    """

    result = False
    if Path(path).exists():
        return True
    try:
        Path(path).mkdir(parents=True)
        result = True
    except OSError:
        return result
    return result


def print_and_wait(text, wait_time):
    """Print String and wait

    :param str text: string to print
    :param  wait_time: Waiting time after print
    :type text: str
    :type wait_time: float, int
    """
    print(text)
    sleep(float(wait_time))


class Writers(object):
    """Writer class for redirecting output for stderr and stdout

    :Example:
        logfile = open('logfile.log', 'a')
        sys.stdout = Writers(sys.stdout, logfile)
        sys.stderr = Writers(sys.stderr, logfile)"""

    def __init__(self, *writers):
        self.writers = writers
        self.ansi_escape = re.compile(r'(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]')

    def write(self, string):
        for w in self.writers:
            w.write(self.escape_ansi(string))

    def flush(self):
        for w in self.writers:
            w.flush()

    def escape_ansi(self, string):
        return self.ansi_escape.sub('', string[:])


def debug_output_open(file_name, debug, message=''):
    """Enable Debug output

    :param str file_name: Path for a logfile
    :param bool debug:  Enable debug output if True
    :param str message: A message to inform user that debug output is enabled

    :return file: return a file handler
    """
    if debug:
        logfile = open(file_name, 'a')
        sys.stdout = Writers(sys.stdout, logfile)
        sys.stderr = Writers(sys.stderr, logfile)
        sys.stderr.write(message)
        return logfile
    return None


def debug_output_close(file_handler, debug):
    """Disable debug output and set back stdout and stderr

    :param file file_handler: file handler to close
    :param debug: Close only if debug is enabled
    """
    if debug:
        sys.stdout.flush()
        sys.stderr.flush()
        sys.stdout = SAVE_STDOUT
        sys.stderr = SAVE_STDERR
        file_handler.close()


def sec_to_time(seconds, days_only=False, ):
    """Convert seconds in human readable values

    :param int seconds: Time in seconds
    :param bool days_only: Output only in days
    :return str: Human readable string """
    seconds = int(seconds)
    if seconds == 0:
        seconds = 1
    if seconds < 0:
        seconds *= (-1)

    days = seconds // 86400
    seconds -= days * 86400

    if not days_only:
        hours = seconds // 3600
        seconds -= hours * 3600
    else:
        hours = -1

    if not days_only:
        minutes = seconds // 60
        seconds -= minutes * 60
    else:
        minutes = -1

    return '{}{}{}{}'.format(
        '{} day{} '.format(days, 's' if days > 1 else '') if days > 0 else '< 1 day' if days_only else '',
        '{:02d}:'.format(hours) if hours > -1 else '',
        '{:02d}:'.format(minutes) if minutes > -1 else '',
        '{:02d}'.format(seconds) if minutes > -1 else '').strip()


# endregion

# region NZB Targets


def push_nzb_sabnzbd(host, port, ssl, api_key, basepath, basicauth_username, basicauth_password, category, paused,
                     sabnzbd_name, nzb_content, start_message='Pushing to SABNZBD', debug=False):
    """Push a NZB to SABnzbd

    :param str host: SABnzbd Hostname or IP
    :param str port: SABnzbd Port
    :param bool ssl: Use https
    :param str api_key: NZB Api Key
    :param str basepath: Basepath where SABnzbd lives
    :param str basicauth_username: Username for Basic Auth
    :param str basicauth_password: Password for Basic Auth
    :param str category: SABnzbd Category
    :param str paused: Add the nzb paused
    :param str sabnzbd_name: Name of the SABnzbd job. To send also the RAR password add {{password}} to the job name
    :param str nzb_content: Content for the NZB File upload
    :param str start_message: Customized start message
    :param bool debug: Verbose output

    :returns int: Return code 0 is OK, return code > 0 is NOK
    """

    print(start_message, end='', flush=True)

    scheme = 'https' if ssl else 'http'
    req_url = '{0}://{1}:{2}/{3}/api'.format(scheme, host, port, basepath)

    post_data = {
        'output': 'xml',
        'mode': 'addfile',
        'nzbname': sabnzbd_name,
        'apikey': api_key,
        'cat': category,
        'priority': -2 if paused else -100
    }

    nzbname = '{}.nzb'.format(normalize('NFKD', sabnzbd_name).encode('ascii', 'ignore').decode("utf-8", "ignore"))
    nzb_data = {'nzbfile': (nzbname, io.BytesIO(nzb_content.encode('utf8')))}

    try:
        auth = None
        if basicauth_username and basicauth_password:
            auth = (basicauth_username, basicauth_password)

        res = requests.post(req_url, data=post_data, files=nzb_data, verify=False, timeout=REQUESTS_TIMEOUT * 2,
                            auth=auth)
    except requests.exceptions.RequestException as e:
        print(Col.FAIL + 'FAILED: {}'.format(e) + Col.OFF)
        return 1

    if res.status_code == 200 and res.text.lower().find('<status>true') > 0:
        print(Col.OK + 'OK' + Col.OFF)
        return 0
    else:
        print(Col.FAIL + 'FAILED' + Col.OFF)

        if debug:
            print('   Response-Text: "{}"'.format(res.text))

        return 1


def push_nzb_nzbget(host, port, ssl, user, password, basepath, category, paused, nzb_filename, nzb_content,
                    start_message='Pushing to NZBGet', debug=False):
    """Push a NZB to NZBGet

    :param str host: NZBGet Hostname or IP
    :param str port: NZBGet Port
    :param bool ssl: Use https
    :param str user: NZBGet User
    :param str password: NZBGet password
    :param str basepath: NZBGet basepath
    :param str category: NZBGet category
    :param str paused: Add the nzb paused
    :param str nzb_filename: NZB filename for NZBGet
    :param str nzb_content: Content for the NZB File upload
    :param str start_message: Customized start message
    :param bool debug: Verbose output

    :returns int: Return code 0 is OK, return code > 0 is NOK
    """

    print(start_message, end='', flush=True)

    scheme = 'https' if ssl else 'http'

    req_url = '{0}://{1}:{2}/{3}'.format(scheme, host, port, basepath)

    # XMLRPC-request, see https://github.com/nzbget/nzbget/wiki/API-Method-%22append%22

    data = ('<?xml version="1.0"?><methodCall><methodName>append</methodName><params>' +
            '<param><value><string>{0}.nzb</string></value></param>' +  # Filename
            '<param><value><string>{1}</string></value></param>' +  # Content (NZB File)
            '<param><value><string>{2}</string></value></param>' +  # Category
            '<param><value><i4>0</i4></value></param>' +  # Priority
            '<param><value><boolean>0</boolean></value></param>' +  # AddToTop
            '<param><value><boolean>{3}</boolean></value></param>' +  # AddPaused
            '<param><value><string></string></value></param>' +  # DupeKey
            '<param><value><i4>0</i4></value></param>' +  # DupeScore
            '<param><value><string>ALL</string></value></param>' +  # DupeMode
            '</params></methodCall>').format(
        nzb_filename,
        base64.b64encode(nzb_content.encode('utf8')).decode('ascii'),
        category,
        1 if paused else 0
    )

    auth = None
    if password is not None:
        auth = (user, password)
    try:
        res = requests.post(req_url, data=data, auth=auth, verify=False, timeout=REQUESTS_TIMEOUT)

        if res.status_code == 200 and res.text.find('<fault>') < 0:
            print(Col.OK + 'OK' + Col.OFF)
        else:
            print(Col.FAIL + 'FAILED' + Col.OFF)
            if debug:
                print('   Response-Text: "{}"'.format(res.text))
            return 1

    except requests.exceptions.RequestException as e:
        print(Col.FAIL + 'FAILED' + Col.OFF)
        if debug:
            print('   Requests-Exception: {}'.format(e))
        return 1

    return 0


def write_nzb_file(nzb_folder, tag, password, nzb_content, debug=False):
    """Write NZB file

    :param str nzb_folder: Destination folder for the NZB file
    :param str tag: NZB Filename without .nzb
    :param str password: Password - append to filename
    :param str nzb_content: Content for the NZB File
    :param bool debug: Verbose output and append unix time to nzb file

    :returns int, str: status and nzb filename
    """
    # Append timestamp to file
    if debug:
        tag += '.{}'.format(int(time()))

    # append password to filename
    if password:
        if re.search('[*?:/"<>|]', password) is not None:
            print(' - Can not add password to filename, forbidden characters included - sorry.')
        else:
            tag += '{{%s}}' % password

    nzb_file = join(nzb_folder, tag + '.nzb')

    try:
        print(' - Saving NZB-file ... ', end='', flush=True)
        with open(nzb_file, 'w', encoding='utf8') as f:
            f.write(nzb_content)
            print(Col.OK + 'OK' + Col.OFF)

    except IOError as e:
        print(Col.FAIL + 'Failed: {}'.format(e) + Col.OFF)
        return 1, None
    return 0, nzb_file


def nzb_execute(nzb_folder, nzb_content, tag, nzb_password, passtofile, passtoclipboard, dontexecute, debug=False):
    """Handle NZB execution Task

    1. Copy password to clipboard
    2. append password to NZB filename {{password}}
    3. Write NZB to file

    :param str nzb_folder: Path to save NZB file
    :param str nzb_content: NZB content to save
    :param str tag: First part from file name
    :param str nzb_password: Password to append to filename
    :param bool passtofile: If enabled append password to file
    :param bool passtoclipboard: If enabled copy password to clipboard
    :param bool dontexecute: If enabled don't Execute default programm for .nzb extension
    :param bool debug: Enable verbose output

    :returns int: Return code 0 is OK, return code > 0 is NOK
    """

    # copy password to clipboard
    if nzb_password and passtoclipboard:
        pyperclip.copy(nzb_password)
        print(' - Password copied to clipboard!')

    # prepare password for nzb file
    if nzb_password and passtofile:
        password = nzb_password
    else:
        password = None

    res, nzb_file = write_nzb_file(nzb_folder, tag, password, nzb_content, debug)

    if res:
        print_and_wait('Close window in {} second(s)'.format(2 * WAITING_TIME_LONG), 2 * WAITING_TIME_LONG)
        return res

    if not dontexecute:
        print(' - Executing NZB-file ... ', end='', flush=True)

        # Let the system decide how to open a .NZB-file
        webbrowser.open(nzb_file)

        print(Col.OK + 'OK' + Col.OFF)

    return 0


def push_nzb_synologydls(host, port, ssl, username, password, basepath, tag, nzb_content, nzb_pass,
                         start_message=' - Pushing to SYNOLOGYDLS', debug=False):
    """Push a NZB to Synology DLS

    :param str host: Diskstation hostname or IP
    :param str port: Diskstation Port
    :param bool ssl: Use https
    :param str username: admin username
    :param str password: admin password
    :param str basepath: Basepath where Diskstation API lives
    :param str tag: Filename without extension .nzb
    :param str nzb_content: Content for the NZB File upload
    :param str nzb_pass: Unpack password
    :param str start_message: Customized start message
    :param bool debug: Verbose output

    :returns int: Return code 0 is OK, return code > 0 is NOK
    """

    print(start_message, end='', flush=True)

    scheme = 'https' if ssl else 'http'

    req_url = '{0}://{1}:{2}/{3}/auth.cgi?api=SYNO.API.Auth&version=3&method=login&account={4}&passwd={5}' \
              '&session=DownloadStation&format=sid'.format(scheme, host, port, basepath, username, password)

    try:
        sid = json.loads(requests.get(req_url, verify=False, timeout=REQUESTS_TIMEOUT).text)['data']['sid']
    except requests.exceptions.RequestException as e:
        print(Col.FAIL + 'FAILED' + Col.OFF)
        if debug:
            print('   Requests-Exception: {}'.format(e))
        return 1

    req_url = '{0}://{1}:{2}/{3}/entry.cgi'.format(scheme, host, port, basepath)

    nzbname = '{}.nzb'.format(normalize('NFKD', tag).encode('ascii', 'ignore').decode("utf-8", "ignore"))

    # API reverse engineered, for some stupid reason the order of parameters matters - thx Synology!
    file_data = [
        ('api', (None, 'SYNO.DownloadStation2.Task', None)),
        ('method', (None, 'create', None)),
        ('version', (None, '2', None)),
        ('extract_password', (None, '"' + nzb_pass + '"', None)),
        ('destination', (None, '""', None)),
        ('create_list', (None, 'false', None)),
        ('type', (None, '"file"', None)),
        ('file', (None, '["torrent"]', None)),
        ('torrent', (nzbname, io.BytesIO(nzb_content.encode('utf8')), 'application/x-nzb; charset="UTF-8"'))
    ]

    try:
        res = requests.post(req_url, files=file_data, verify=False, timeout=REQUESTS_TIMEOUT, cookies={'id': sid})
        if res.status_code == 200 and res.text.find('success":true') > 0:
            print(Col.OK + 'OK' + Col.OFF)
        else:
            print(Col.FAIL + 'FAILED' + Col.OFF)
            if debug:
                print('   Response-Text: "{}"'.format(res.text))
            return 1

    except requests.exceptions.RequestException as e:
        print(Col.FAIL + 'FAILED' + Col.OFF)
        if debug:
            print('   Requests-Exception: {}'.format(e))
        return 1

    return 0


# endregion


def main():
    """NZB-Monkey - The easy way to download NZB files"""

    name = 'NZB-Monkey v{}'.format(__version__)
    print('\n %s\n %s' % (name, '=' * len(name)))

    script_path = sys.argv[0] if not hasattr(sys, 'frozen') else os.path.normpath(os.path.abspath(sys.executable))
    cfg_filename = splitext(script_path)[0] + '.cfg'
    log_filename = splitext(script_path)[0] + '.log'

    cfg = ConfigObj(cfg_filename, configspec=getSpec(), encoding='UTF-8', default_encoding='UTF-8',
                    write_empty_values=True)

    if isfile(cfg_filename):
        val = SimpleVal()
        test = cfg.validate(val)
        # We have to check explicit for not test == True
        # If everything is OK validate returns True
        # If a keyword or section is missing validate returns a dictionary
        if not test == True:
            val = Validator()
            cfg.validate(val, copy=True)
            cfg.write()

    else:
        val = Validator()
        cfg.validate(val, copy=True)
        config_file(cfg)
        config_nzbmonkey()
        sleep(WAITING_TIME_LONG)
        return 0

    exe_target = cfg['GENERAL'].get('target', 'EXECUTE').upper()
    exe_target_cfg = {} if exe_target not in cfg.keys() else cfg[exe_target]

    debug = cfg['GENERAL'].as_bool('debug')
    if debug:
        debug_message = 'Debug output enabled for {}'.format(name)
        debug_logfile = debug_output_open(log_filename, debug, '\n {}\n {}\n {}\n\n'.format(
            '=' * len(debug_message), debug_message, '=' * len(debug_message)))
        print(' Started: {} ({})'.format(strftime('%Y-%m-%d %H:%M:%S'), int(time())))
        text = 'Command line arguments passed to NZB-Monkey'
        print(' {}\n {}'.format(text, '-' * len(text)))
        for count, arg in enumerate(sys.argv):
            print(' Arg[{}]: {}'.format(count, arg))
        print(' {}\n'.format('-' * len(text)))
    else:
        debug_logfile = None

    # region Processing Input
    parser = argparse.ArgumentParser()
    parser.add_argument('-t', '--tag', action='store', help='Tag for Releasename')
    parser.add_argument('-s', '--subject', action='store', help='Subject (Header) for NZB Search')
    parser.add_argument('-p', '--password', action='store', help='Password to extract files')
    parser.add_argument('-c', '--category', action='store', help='Category for SABnzbd or NZBGet')
    parser.add_argument('nzblnk', nargs=argparse.REMAINDER, help='NZBLNK URI')
    args = parser.parse_args()

    if args.category:
        category_args = args.category
    else:
        category_args = None

    if len(args.nzblnk) > 0:
        called_by = 'by NZBLNK scheme'

        lnk = urlparse(args.nzblnk[0])
        if lnk.scheme.lower() != 'nzblnk':
            print_and_wait(Col.FAIL + ' ERROR: ' + Col.OFF + 'Please provide a NZBLNK.', WAITING_TIME_LONG)
            debug_output_close(debug_logfile, debug)
            return 1

        # parse query-part

        lnk = parse_qs(lnk.query)
        nzbsrc = {
            'tag': lnk.get('t', [None])[0],
            'header': lnk.get('h', [None])[0],
            'pass': lnk.get('p', [None])[0]
        }

    elif args.subject and args.tag:
        called_by = 'by Arguments'

        tag = args.tag
        header = args.subject
        if args.password:
            password = args.password
        else:
            password = ''

        nzbsrc = {
            'tag': tag,
            'header': header,
            'pass': password
        }

    else:
        called_by = 'with clipboard'
        tag = 'NZB Monkey'

        clip = pyperclip.paste()

        if clip is None or clip == '':
            print_and_wait(' Clipboard is empty. So please call {} <nzblnk> or with text in clipboard.'.format(
                basename(sys.argv[0])),
                WAITING_TIME_LONG)
            return 1

        found = re.search(r'(?mi)(^.*?S\d+E\d+.*$)', clip)
        if found is not None:
            tag = found.group(1)
        else:
            found = re.search(r'(?mi)(^.*?(?:720p|1080p|x264|x265|XviD|BluRay).*$)', clip)
            if found is not None:
                tag = found.group(1)
            else:
                found = re.search(r'(?m)(^(.*)$)', clip.strip())
                if found is not None:
                    tag = found.group(1)

        tag = re.sub('([^{]*).*', '\\1', tag.strip().replace(' ', '.'))

        header = None
        found = re.search(r'(?mi)(?:subject:|header:)\s+?(?:header:\s+)?(\S+)', clip.strip())
        if found is not None:
            header = found.group(1)

        password = ''
        found = re.search(r'(?mi)(?:passwor[dt]|pw|pwd):\s*?(\S+)', clip.strip())
        if found is not None:
            password = found.group(1)

        nzbsrc = {
            'tag': tag,
            'header': header,
            'pass': password
        }

    if nzbsrc['tag'] is None or nzbsrc['header'] is None:
        print_and_wait(Col.FAIL + ' ERROR: Please provide a tag and header info.' + Col.OFF, WAITING_TIME_LONG)
        debug_output_close(debug_logfile, debug)
        return 1

    print(""" Called {3}:\n
     - Tag     : {0}
     - Header  : {1}
     - Password: {2}
    """.format(nzbsrc['tag'],
               nzbsrc['header'],
               nzbsrc['pass'] or Col.WARN + 'EMPTY' + Col.OFF,
               called_by))
    # endregion

    # region Seach NZB

    res, nzb, used_search_engine, = search_nzb(nzbsrc['header'],
                                               nzbsrc['pass'],
                                               {'binsearch': cfg['Searchengines'].as_int('binsearch'),
                                                'nzbking': cfg['Searchengines'].as_int('nzbking'),
                                                'nzbindex': cfg['Searchengines'].as_int('nzbindex')},
                                               cfg['NZBCheck'].as_bool('best_nzb'),
                                               cfg['NZBCheck'].get('max_missing_files', 2),
                                               cfg['NZBCheck'].get('max_missing_segments_percent', 2.5),
                                               cfg['NZBCheck'].as_bool('skip_failed'),
                                               debug)
    if res:
        print_and_wait('Close window in {} second(s)'.format(2 * WAITING_TIME_LONG), 2 * WAITING_TIME_LONG)
        debug_output_close(debug_logfile, debug)
        return res
    # endregion

    # region Categorizer

    category = category_args if category_args else exe_target_cfg.get('category', '')

    SEC_CATEGORIZER = 'CATEGORIZER'

    categorize_mode = cfg['GENERAL'].get('categorize', 'off').lower()
    categorize_mode = categorize_mode if categorize_mode in ['off', 'auto', 'manual'] else 'off'

    # Auto categorizer

    if categorize_mode == 'auto' and SEC_CATEGORIZER in cfg.keys():
        for cat in cfg[SEC_CATEGORIZER].keys():
            try:
                if re.compile(cfg[SEC_CATEGORIZER].get(cat), re.IGNORECASE).search(nzbsrc['tag']):
                    category = cat
                    print("\n - Categorizer set category to: {}{}{}".format(Col.OK, cat, Col.OFF))
                    break
            except:
                print_and_wait(Col.WARN + " > ERROR: Your category \"{}\" is a invalid regex!".format(cat) + Col.OFF,
                               WAITING_TIME_LONG)

    elif categorize_mode == 'manual':
        cat_choice = []

        # Ask SabNZBs for categories

        if ExeTypes.SABNZBD.name == exe_target:
            scheme = 'https' if exe_target_cfg.as_bool('ssl') else 'http'
            req_url = '{0}://{1}:{2}/{3}/api?mode=get_cats&output=json' \
                      '&apikey={4}'.format(scheme,
                                           exe_target_cfg.get('host', 'localhost'),
                                           exe_target_cfg.get('port', '8080'),
                                           exe_target_cfg.get('basepath', 'sabnzbd'),
                                           exe_target_cfg.get('nzbkey', ''))

            try:
                res = requests.get(req_url, verify=False, timeout=REQUESTS_TIMEOUT * 2)
                if res.status_code == 403:
                    print_and_wait(Col.FAIL + ' - Please use the API KEY not the NZB KEY in your config!' + Col.OFF,
                                   WAITING_TIME_LONG)
                    raise EnvironmentError

                res = json.loads(res.text)

                if 'categories' not in res.keys():
                    print(Col.FAIL + ' - Reading categories failed!' + Col.OFF)
                    raise EnvironmentError

                sabcats = res['categories']
                for sabcat in sabcats:
                    if sabcat != '*':
                        cat_choice.append(sabcat)

            except (EnvironmentError, ValueError):
                cat_choice = []

        if ExeTypes.NZBGET.name == exe_target:

            scheme = 'https' if exe_target_cfg.as_bool('ssl') else 'http'

            req_url = '{0}://{1}:{2}/{3}/config'.format(scheme,
                                                        exe_target_cfg.get('host', 'localhost'),
                                                        exe_target_cfg.get('port', '6789'),
                                                        exe_target_cfg.get('basepath', 'xmlrpc')
                                                        .replace('xmlrpc', 'jsonrpc'))
            auth = None
            if exe_target_cfg.get('pass', '') is not None:
                auth = (exe_target_cfg.get('user', ''), exe_target_cfg.get('pass', ''))

            try:
                res = json.loads(requests.get(req_url, auth=auth, verify=False, timeout=REQUESTS_TIMEOUT).text)
                if 'result' not in res.keys():
                    print(Col.FAIL + ' - Reading categories failed!' + Col.OFF)
                    raise EnvironmentError

                cfgregex = re.compile('Category\d\.Name', re.IGNORECASE)

                for cfg in res['result']:
                    if cfgregex.match(cfg['Name']):
                        cat_choice.append(cfg['Value'])

            except (ValueError, EnvironmentError):
                cat_choice = []

        if cat_choice:
            print(' - Choose from one of the categories or\n   just press enter to choose no category:\n')

            for idx, cat in enumerate(cat_choice):
                print('   [{}] {}'.format(idx + 1, cat))

            try:
                uch = int(input('\n   Your choice: ')) - 1
                if uch < 0 or uch >= len(cat_choice):
                    raise ValueError

                category = cat_choice[uch]
                print("\n - You set the category to: {}{}{}".format(Col.OK, category, Col.OFF))
            except ValueError:
                pass

    # endregion

    # region Exec NZBGET
    if ExeTypes.NZBGET.name == exe_target:
        res = push_nzb_nzbget(exe_target_cfg.get('host', 'localhost'),
                              exe_target_cfg.get('port', '6789'),
                              exe_target_cfg.as_bool('ssl'),
                              exe_target_cfg.get('user', ''),
                              exe_target_cfg.get('pass', ''),
                              exe_target_cfg.get('basepath', 'xmlrpc'),
                              category,
                              exe_target_cfg.as_bool('addpaused'),
                              nzbsrc['tag'],
                              nzb,
                              ' - Pushing to NZBGET ... ',
                              debug)
        if not debug:
            print(' - Done')
            if res:
                waiting_time = WAITING_TIME_LONG
            else:
                waiting_time = WAITING_TIME_SHORT
            print_and_wait('Close window in {} second(s)'.format(waiting_time), waiting_time)
            debug_output_close(debug_logfile, debug)
            return res
    # endregion

    # region Exec SABNZBD
    elif ExeTypes.SABNZBD.name == exe_target:

        res = push_nzb_sabnzbd(exe_target_cfg.get('host', 'localhost'),
                               exe_target_cfg.get('port', '8080'),
                               exe_target_cfg.as_bool('ssl'),
                               exe_target_cfg.get('nzbkey', ''),
                               exe_target_cfg.get('basepath', 'sabnzbd'),
                               exe_target_cfg.get('basicauth_username', ''),
                               exe_target_cfg.get('basicauth_password', ''),
                               category,
                               exe_target_cfg.as_bool('addpaused'),
                               nzbsrc['tag'] if nzbsrc['pass'] is None else '%s{{%s}}' % (
                                   nzbsrc['tag'], nzbsrc['pass']),
                               nzb,
                               ' - Pushing to SABNZBD ...',
                               debug)
        if not debug:
            print(' - Done')
            if res:
                waiting_time = WAITING_TIME_LONG
            else:
                waiting_time = WAITING_TIME_SHORT
            print_and_wait('Close window in {} second(s)'.format(waiting_time), waiting_time)
            debug_output_close(debug_logfile, debug)
            return res
    # endregion

    # region Exec SYNOLOGYDLS

    elif ExeTypes.SYNOLOGYDLS.name == exe_target:
        res = push_nzb_synologydls(exe_target_cfg.get('host', 'localhost'),
                                   exe_target_cfg.get('port', '8080'),
                                   exe_target_cfg.as_bool('ssl'),
                                   exe_target_cfg.get('user', ''),
                                   exe_target_cfg.get('pass', ''),
                                   exe_target_cfg.get('basepath', 'webapi'),
                                   nzbsrc['tag'],
                                   nzb,
                                   nzbsrc['pass'],
                                   ' - Pushing to SYNOLOGY-DLS ...',
                                   debug)
        if not debug:
            print(' - Done')
            if res:
                waiting_time = WAITING_TIME_LONG
            else:
                waiting_time = WAITING_TIME_SHORT
            print_and_wait('Close window in {} second(s)'.format(waiting_time), waiting_time)
            debug_output_close(debug_logfile, debug)
            return res

    # endregion

    # region Exec EXECUTE
    if ExeTypes.EXECUTE.name == exe_target or debug:

        if debug and exe_target != 'EXECUTE':
            # Read EXECUTE config to handle NZB saving if target is not EXECUTE
            exe_target_cfg = {} if exe_target not in cfg.keys() else cfg['EXECUTE']

        # Check NZB Folder
        nzb_folder = expandvars(exe_target_cfg.get('nzbsavepath', '%%TEMP%%'))
        if not check_folder(nzb_folder):
            print(Col.FAIL + " - Can't access or create NZB folder {}".format(nzb_folder)
                  + Col.OFF)
            print_and_wait('Close window in {} second(s)'.format(2 * WAITING_TIME_LONG), 2 * WAITING_TIME_LONG)
            debug_output_close(debug_logfile, debug)
            return 1

        # Nzb Save and execute
        nzb_execute(nzb_folder,
                    nzb,
                    nzbsrc['tag'] if not debug else '{}.{}'.format(nzbsrc['tag'], used_search_engine.lower()),
                    nzbsrc['pass'],
                    exe_target_cfg.as_bool('passtofile'),
                    exe_target_cfg.as_bool('passtoclipboard'),
                    exe_target_cfg.as_bool('dontexecute'),
                    debug)

        # Clean up NZB Folder
        if exe_target_cfg.as_bool('clean_up_enable') and int(time()) - exe_target_cfg.as_int(
                'clean_up_last_run') >= 24 * 3600:
            print(' - Clean up NZB folder ... ', end='', flush=True)
            counter = clean_nzb_folder(nzb_folder)
            if counter == -1:
                print(Col.FAIL + 'Cleaning failed.' + Col.OFF)
            elif counter == 0:
                print(Col.OK + 'Nothing to do.')
            elif counter > 0:
                print(Col.OK + 'Deleted {} NZB file(s)'.format(counter))
            exe_target_cfg['clean_up_last_run'] = int(time())
            cfg.write()

        print(' - Done')
        if res:
            waiting_time = WAITING_TIME_LONG
        else:
            waiting_time = WAITING_TIME_SHORT
        print_and_wait('Close window in {} second(s)'.format(waiting_time), waiting_time)
        debug_output_close(debug_logfile, debug)
        return 0
    # endregion

    else:
        print_and_wait(Col.FAIL + ' ERROR: ' + Col.OFF + ' Target "' + exe_target + '" unknown!', 2 * WAITING_TIME_LONG)
        debug_output_close(debug_logfile, debug)
        return 1


if __name__ == '__main__':
    sys.exit(main())