import os
import re
import sys
import copy
import pickle
import json
from urllib.request import urlopen
from urllib.error import HTTPError
from urllib.parse import urlencode

try:
    import pylast
    has_pylast = True
except ImportError:
    has_pylast = False

from . import g, c, paths, util


mswin = os.name == "nt"

class ConfigItem:

    """ A configuration item. """

    def __init__(self, name, value, minval=None, maxval=None, check_fn=None,
            require_known_player=False, allowed_values=None):
        """ If specified, the check_fn should return a dict.

        {valid: bool, message: success/fail mesage, value: value to set}

        """
        self.default = self.value = value
        self.temp_value = None
        self.name = name
        self.type = type(value)
        self.maxval, self.minval = maxval, minval
        self.check_fn = check_fn
        self.require_known_player = require_known_player
        self.allowed_values = []
        if allowed_values:
            self.allowed_values = allowed_values

    @property
    def get(self):
        """ Return value. """
        if self.temp_value is None:
            return self.value
        else:
            return self.temp_value

    @property
    def display(self):
        """ Return value in a format suitable for display. """
        return self.display_helper(self.value)

    @property
    def display_temp(self):
        if self.temp_value is None: return ""
        return self.display_helper(self.temp_value)

    def display_helper(self, retval):
        if self.name == "max_res":
            retval = str(retval) + "p"

        if self.name == "encoder":
            retval = str(retval) + " [%s]" % (str(g.encoders[retval]['name']))

        return retval

    def set(self, value, is_temp=False):
        """ Set value with checks. """
        # note: fail_msg should contain %s %s for self.name, value
        #       success_msg should not
        # pylint: disable=R0912
        # too many branches

        success_msg = fail_msg = ""
        value = value.strip()
        value_orig = value

        # handle known player not set

        if self.allowed_values and value not in self.allowed_values:
            fail_msg = "%s must be one of * - not %s"
            allowed_values = copy.copy(self.allowed_values)
            if '' in allowed_values:
                allowed_values[allowed_values.index('')] = "<nothing>"
            fail_msg = fail_msg.replace("*", ", ".join(allowed_values))

        if self.require_known_player and \
                not util.is_known_player(Config.PLAYER.get):
            fail_msg = "%s requires mpv or mplayer, can't set to %s"

        # handle true / false values

        elif self.type == bool:

            if value.upper() in "0 OFF NO DISABLED FALSE".split():
                value = False
                success_msg = "%s set to False" % c.c("g", self.name)

            elif value.upper() in "1 ON YES ENABLED TRUE".split():
                value = True
                success_msg = "%s set to True" % c.c("g", self.name)

            else:
                fail_msg = "%s requires True/False, got %s"

        # handle int values

        elif self.type == int:

            if not value.isdigit():
                fail_msg = "%s requires a number, got %s"

            else:
                value = int(value)

                if self.maxval and self.minval:

                    if not self.minval <= value <= self.maxval:
                        m = " must be between %s and %s, got "
                        m = m % (self.minval, self.maxval)
                        fail_msg = "%s" + m + "%s"

                if not fail_msg:
                    dispval = value or "None"
                    success_msg = "%s set to %s" % (c.c("g", self.name),
                                                    dispval)

        # handle space separated list

        elif self.type == list:
            success_msg = "%s set to %s" % (c.c("g", self.name), value)
            value = value.split()

        # handle string values

        elif self.type == str:
            dispval = value or "None"
            success_msg = "%s set to %s" % (c.c("g", self.name),
                                            c.c("g", dispval))

        # handle failure

        if fail_msg:
            failed_val = value_orig.strip() or "<nothing>"
            colvals = c.y + self.name + c.w, c.y + failed_val + c.w
            return fail_msg % colvals

        elif self.check_fn:
            checked = self.check_fn(value)
            value = checked.get("value") or value

            if checked['valid']:
                value = checked.get("value", value)
                set_save(self, value, is_temp)
                return checked.get("message", success_msg)

            else:
                return checked.get('message', fail_msg)

        elif success_msg:
            set_save(self, value, is_temp)
            return success_msg

def set_save(self, value, is_temp):
    if not is_temp:
        self.temp_value = None
        self.value = value
        Config.save()
    else:
        self.temp_value = value

def check_console_width(val):
    """ Show ruler to check console width. """
    valid = True
    message = "-" * val + "\n"
    message += "console_width set to %s, try a lower value if above line ove"\
        "rlaps" % val
    return dict(valid=valid, message=message)


# def check_api_key(key):
#     """ Validate an API key by calling an API endpoint with no quota cost """
#     url = "https://www.googleapis.com/youtube/v3/i18nLanguages"
#     query = {"part": "snippet", "fields": "items/id", "key": key}
#     try:
#         urlopen(url + "?" + urlencode(query)).read()
#         message = "The key, '" + key + "' will now be used for API requests."
#
#         # Make pafy use the same api key
#         pafy.set_api_key(Config.API_KEY.get)
#
#         return dict(valid=True, message=message)
#     except HTTPError:
#         message = "Invalid key or quota exceeded, '" + key + "'"
#         return dict(valid=False, message=message)


def check_ddir(d):
    """ Check whether dir is a valid directory. """
    expanded = os.path.expanduser(d)
    if os.path.isdir(expanded):
        message = "Downloads will be saved to " + c.y + d + c.w
        return dict(valid=True, message=message, value=expanded)

    else:
        message = "Not a valid directory: " + c.r + d + c.w
        return dict(valid=False, message=message)


def check_win_pos(pos):
    """ Check window position input. """
    if not pos.strip():
        return dict(valid=True, message="Window position not set (default)")

    pos = pos.lower()
    reg = r"(TOP|BOTTOM).?(LEFT|RIGHT)"

    if not re.match(reg, pos, re.I):
        msg = "Try something like top-left or bottom-right (or default)"
        return dict(valid=False, message=msg)

    else:
        p = re.match(reg, pos, re.I).groups()
        p = "%s-%s" % p
        msg = "Window position set to %s" % p
        return dict(valid=True, message=msg, value=p)


def check_win_size(size):
    """ Check window size input. """
    if not size.strip():
        return dict(valid=True, message="Window size not set (default)")

    size = size.lower()
    reg = r"\d{1,4}x\d{1,4}"

    if not re.match(reg, size, re.I):
        msg = "Try something like 720x480"
        return dict(valid=False, message=msg)

    else:
        return dict(valid=True, value=size)


def check_encoder(option):
    """ Check encoder value is acceptable. """
    encs = g.encoders

    if option >= len(encs):
        message = "%s%s%s is too high, type %sencoders%s to see valid values"
        message = message % (c.y, option, c.w, c.g, c.w)
        return dict(valid=False, message=message)

    else:
        message = "Encoder set to %s%s%s"
        message = message % (c.y, encs[option]['name'], c.w)
        return dict(valid=True, message=message)


def check_player(player):
    """ Check player exefile exists and get mpv version. """
    if util.has_exefile(player):
        print(player)
        util.assign_player(player)
        if "mpv" in player:
            version = "%s.%s.%s" % g.mpv_version
            fmt = c.g, c.w, c.g, c.w, version
            msg = "%splayer%s set to %smpv%s (version %s)" % fmt
            return dict(valid=True, message=msg, value=player)

        else:
            msg = "%splayer%s set to %s%s%s" % (c.g, c.w, c.g, player, c.w)
            return dict(valid=True, message=msg, value=player)

    else:
        if mswin and not (player.endswith(".exe") or player.endswith(".com")):
            # Using mpv.exe has issues; use mpv.com
            if "mpv" in player:
                retval = check_player(player + ".com")
                if retval["valid"]:
                    return retval
            return check_player(player + ".exe")

        else:
            msg = "Player application %s%s%s not found" % (c.r, player, c.w)
            return dict(valid=False, message=msg)


def check_lastfm_password(password):
    if not has_pylast:
        msg = "pylast not installed"
        return dict(valid=False, message=msg)
    password_hash = pylast.md5(password)
    return dict(valid=True, value=password_hash)


class _Config:

    """ Holds various configuration values. """

    _configitems = [
            ConfigItem("order", "relevance",
                allowed_values="relevance date views rating title".split()),
            ConfigItem("user_order", "", allowed_values =
                [""] + "relevance date views rating".split()),
            ConfigItem("max_results", 19, maxval=50, minval=1),
            ConfigItem("console_width", 80, minval=70,
                maxval=880, check_fn=check_console_width),
            ConfigItem("max_res", 2160, minval=360, maxval=2160),
            ConfigItem("player", "vlc" + ".exe" * mswin,
                check_fn=check_player),
            ConfigItem("playerargs", ""),
            ConfigItem("encoder", 0, minval=0, check_fn=check_encoder),
            ConfigItem("notifier", ""),
            ConfigItem("checkupdate", True),
            ConfigItem("show_player_keys", True, require_known_player=True),
            ConfigItem("fullscreen", False, require_known_player=True),
            ConfigItem("show_status", True),
            ConfigItem("always_repeat", False),
            ConfigItem("columns", "date user"),
            ConfigItem("ddir", paths.get_default_ddir(), check_fn=check_ddir),
            ConfigItem("overwrite", True),
            ConfigItem("show_video", True),
            ConfigItem("search_music", False),
            ConfigItem("window_pos", "", check_fn=check_win_pos,
                require_known_player=True),
            ConfigItem("window_size", "",
                check_fn=check_win_size, require_known_player=True),
            ConfigItem("download_command", ''),
            ConfigItem("lookup_metadata", True),
            ConfigItem("lastfm_username", ''),
            ConfigItem("lastfm_password", '', check_fn=check_lastfm_password),
            ConfigItem("lastfm_api_key", ''),
            ConfigItem("lastfm_api_secret", ''),
            ConfigItem("audio_format", "auto",
                allowed_values="auto webm m4a".split()),
            ConfigItem("video_format", "auto",
                allowed_values="auto webm mp4 3gp".split()),
            ConfigItem("pages", 3, minval=1, maxval=100),
            ConfigItem("autoplay", False),
            ConfigItem("set_title", True),
            ConfigItem("mpris", not mswin),
            ConfigItem("show_qrcode", False),
            ConfigItem("history", True), 
            ConfigItem("input_history", True),
            ConfigItem("vlc_dummy_interface", False),
            ConfigItem("show_subtitles", True),
            ]

    def __getitem__(self, key):
        # TODO: Possibly more efficient algorithm, w/ caching
        for i in self._configitems:
            if i.name.upper() == key:
                return i
        raise KeyError

    def __getattr__(self, name):
        try:
            # todo: remove this later
            if name != 'API_KEY':
                return self[name]
        except KeyError:
            raise AttributeError

    def __iter__(self):
        return (i.name.upper() for i in self._configitems)

    def save(self):
        """ Save current config to file. """
        config = {setting: self[setting].value for setting in self}

        with open(g.CFFILE, "w") as cf:
            json.dump(config, cf, indent=2)

        util.dbg(c.p + "Saved config: " + g.CFFILE + c.w)

    def convert_old_cf_to_json(self):
        """
        check if old-style config exists,
        convert old-style pickled binary config to json and save to disk,
        delete old-style config
        """
        if os.path.exists(g.OLD_CFFILE):
            with open(g.OLD_CFFILE, "rb") as cf:
                with open(g.CFFILE, "w") as cfj:
                    json.dump(pickle.load(cf), cfj, indent=2)
            os.remove(g.OLD_CFFILE)

    def load(self):
        """ Override config if config file exists. """
        if os.path.exists(g.CFFILE):
            with open(g.CFFILE, "r") as cf:
                saved_config = json.load(cf)

            for k, v in saved_config.items():

                try:
                    self[k].value = v

                except KeyError:  # Ignore unrecognised data in config
                    util.dbg("Unrecognised config item: %s", k)

            # Update config files from versions <= 0.01.41
            if isinstance(self.PLAYERARGS.get, list):
                self.WINDOW_POS.value = "top-right"
                redundant = ("-really-quiet --really-quiet -prefer-ipv4 -nolirc "
                             "-fs --fs".split())

                for r in redundant:
                    util.dbg("removing redundant arg %s", r)
                    util.list_update(r, self.PLAYERARGS.value, remove=True)

                self.PLAYERARGS.value = " ".join(self.PLAYERARGS.get)
                self.save()

Config = _Config()
del _Config # _Config is a singleton and should not have more instances
# Prevent module from being deleted
# http://stackoverflow.com/questions/5365562/why-is-the-value-of-name-changing-after-assignment-to-sys-modules-name
ref = sys.modules[__name__]
# Any module trying to import config will get the Config object instead
sys.modules[__name__] = Config
