#!/usr/bin/python
# coding: utf-8

from configparser import RawConfigParser, NoOptionError, NoSectionError
from os.path import dirname, splitext, basename, isfile, getmtime
import re
import unidecode
import logging
import datetime

logger = logging.getLogger('Prismedia')


VALID_PRIVACY_STATUSES = ('public', 'private', 'unlisted')
VALID_CATEGORIES = (
    "music", "films", "vehicles",
    "sports", "travels", "gaming", "people",
    "comedy", "entertainment", "news",
    "how to", "education", "activism", "science & technology",
    "science", "technology", "animals"
)
VALID_LANGUAGES = ('arabic', 'english', 'french',
                   'german', 'hindi', 'italian',
                   'japanese', 'korean', 'mandarin',
                   'portuguese', 'punjabi', 'russian', 'spanish')
VALID_PROGRESS = ('percentage', 'bigfile', 'accurate')


def validateVideo(path):
    supported_types = ['video/mp4']
    detected_type = magic.from_file(path, mime=True)
    if detected_type not in supported_types:
        print("File", path, "detected type is '" + detected_type + "' which is not one of", supported_types)

        force_file = ['y', 'yes']
        is_forcing = input("Are you sure you selected the correct file? (y/N)")
        if is_forcing.lower() not in force_file:
            return False

    return path


def validateCategory(category):
    if category.lower() in VALID_CATEGORIES:
        return True
    else:
        return False


def validatePrivacy(privacy):
    if privacy.lower() in VALID_PRIVACY_STATUSES:
        return True
    else:
        return False


# TODO: remove me?
# def validatePlatform(platform):
#     for plfrm in platform.split(','):
#         if plfrm.lower().replace(" ", "") not in VALID_PLATFORM:
#             return False
#
#     return True


def validateLanguage(language):
    if language.lower() in VALID_LANGUAGES:
        return True
    else:
        return False


def validatePublishDate(publishDate):
    # Check date format and if date is future
    try:
        now = datetime.datetime.now()
        publishAt = datetime.datetime.strptime(publishDate, '%Y-%m-%dT%H:%M:%S')
        if now >= publishAt:
            return False
    except ValueError:
        return False
    return True


def validateOriginalDate(originalDate):
    # Check date format and if date is past
    try:
        now = datetime.datetime.now()
        originalDate = datetime.datetime.strptime(originalDate, '%Y-%m-%dT%H:%M:%S')
        if now <= originalDate:
            return False
    except ValueError:
        return False
    return True


def validateThumbnail(thumbnail):
    supported_types = ['image/jpg', 'image/jpeg']
    if os.path.exists(thumbnail) and \
            magic.from_file(thumbnail, mime=True) in supported_types:
        return thumbnail
    else:
        return False


def validateLogLevel(loglevel):
    numeric_level = getattr(logging, loglevel, None)
    if not isinstance(numeric_level, int):
        return False
    return True


def validateProgress(progress):
    for prgs in progress.split(','):
        if prgs.lower().replace(" ", "") not in VALID_PROGRESS:
            return False

    return True


def ask_overwrite(question):
    while True:
        reply = str(input(question + ' (Yes/[No]): ') or "No").lower().strip()
        if reply[:1] == 'y':
            return True
        if reply[:1] == 'n':
            return False


def remove_empty_kwargs(**kwargs):
    good_kwargs = {}
    if kwargs is not None:
        for key, value in kwargs.items():
            if value:
                good_kwargs[key] = value
    return good_kwargs


def searchOriginalDate(options):
    fileModificationDate = str(getmtime(options.get('--file'))).split('.')
    return datetime.datetime.fromtimestamp(int(fileModificationDate[0])).isoformat()


# return the nfo as a RawConfigParser object
def loadNFO(filename):
    try:
        logger.info("Loading " + filename + " as NFO")
        nfo = RawConfigParser()
        nfo.read(filename, encoding='utf-8')
        return nfo
    except Exception as e:
        logger.critical("Problem loading NFO file " + filename + ": " + str(e))
        exit(1)
    return False


def parseNFO(options):
    video_directory = dirname(options.get('--file'))
    directory_name = basename(video_directory)
    nfo_txt = False
    nfo_directory = False
    nfo_videoname = False
    nfo_file = False
    nfo_cli = False

    if isfile(video_directory + "/" + "nfo.txt"):
        nfo_txt = loadNFO(video_directory + "/" + "nfo.txt")
    elif isfile(video_directory + "/" + "NFO.txt"):
        nfo_txt = loadNFO(video_directory + "/" + "NFO.txt")

    if isfile(video_directory + "/" + directory_name + ".txt"):
        nfo_directory = loadNFO(video_directory + "/" + directory_name + ".txt")

    if options.get('--name'):
        if isfile(video_directory + "/" + options.get('--name')):
            nfo_videoname = loadNFO(video_directory + "/" + options.get('--name') + ".txt")

    video_file = splitext(basename(options.get('--file')))[0]
    if isfile(video_directory + "/" + video_file + ".txt"):
        nfo_file = loadNFO(video_directory + "/" + video_file + ".txt")

    if options.get('--nfo'):
        if isfile(options.get('--nfo')):
            nfo_cli = loadNFO(options.get('--nfo'))
        else:
            logger.critical("Given NFO file does not exist, please check your path.")
            exit(1)

    # If there is no NFO and strict option is enabled, then stop there
    if options.get('--withNFO'):
        if not isinstance(nfo_cli, RawConfigParser) and \
                not isinstance(nfo_file, RawConfigParser) and \
                not isinstance(nfo_videoname, RawConfigParser) and \
                not isinstance(nfo_directory, RawConfigParser) and \
                not isinstance(nfo_txt, RawConfigParser):
            logger.critical("You have required the strict presence of NFO but none is found, please use a NFO.")
            exit(1)

    # We need to load NFO in this exact order to keep the priorities
    # options in cli > nfo_cli > nfo_file > nfo_videoname > nfo_directory > nfo_txt
    for nfo in [nfo_cli, nfo_file, nfo_videoname, nfo_directory, nfo_txt]:
        if nfo:
            # We need to check all options and replace it with the nfo value if not defined (None or False)
            for key, value in options.items():
                key = key.replace("--", "")
                try:
                    # get string options
                    if value is None and nfo.get('video', key):
                        options['--' + key] = nfo.get('video', key)
                    # get boolean options
                    elif value is False and nfo.getboolean('video', key):
                        options['--' + key] = nfo.getboolean('video', key)
                except NoOptionError:
                    continue
                except NoSectionError:
                    logger.critical(nfo + " misses section [video], please check syntax of your NFO.")
                    exit(1)
    return options


def cleanString(toclean):
    toclean = unidecode.unidecode(toclean)
    cleaned = re.sub('[^A-Za-z0-9]+', '', toclean)

    return cleaned

def getOption(options, optionName, defaultValue = None):
    value = options.get(optionName)
    options.pop(optionName)

    if value is None:
        return defaultValue
    return value