# This work is licensed under the GNU GPLv2 or later.
# See the COPYING file in the top-level directory.

import configparser
import os
from logging import getLogger
import urllib.parse

from ._util import listify

log = getLogger(__name__)


def _parse_hostname(url):
    # If http://example.com is passed, netloc=example.com path=""
    # If just example.com is passed, netloc="" path=example.com
    parsedbits = urllib.parse.urlparse(url)
    return parsedbits.netloc or parsedbits.path


def _makedirs(path):
    if os.path.exists(os.path.dirname(path)):
        return
    os.makedirs(os.path.dirname(path), 0o700)


def _default_cache_location(filename):
    """
    Determine default location for passed xdg filename.
    example: ~/.cache/python-bugzilla/bugzillarc
    """
    return os.path.expanduser("~/.cache/python-bugzilla/%s" % filename)


class _BugzillaRCFile(object):
    """
    Helper class for interacting with bugzillarc files
    """
    @staticmethod
    def get_default_configpaths():
        paths = [
            '/etc/bugzillarc',
            '~/.bugzillarc',
            '~/.config/python-bugzilla/bugzillarc',
        ]
        return paths

    def __init__(self):
        self._cfg = None
        self._configpaths = None
        self.set_configpaths(None)

    def set_configpaths(self, configpaths):
        configpaths = [os.path.expanduser(p) for p in
                       listify(configpaths or [])]

        cfg = configparser.ConfigParser()
        read_files = cfg.read(configpaths)
        if read_files:
            log.info("Found bugzillarc files: %s", read_files)

        self._cfg = cfg
        self._configpaths = configpaths or []

    def get_configpaths(self):
        return self._configpaths[:]

    def get_default_url(self):
        """
        Grab a default URL from bugzillarc [DEFAULT] url=X
        """
        cfgurl = self._cfg.defaults().get("url", None)
        if cfgurl is not None:
            log.debug("bugzillarc: found cli url=%s", cfgurl)
            return cfgurl

    def parse(self, url):
        """
        Find the section for the passed URL domain, and return all the fields
        """
        section = ""
        log.debug("bugzillarc: Searching for config section matching %s", url)

        urlhost = _parse_hostname(url)
        for sectionhost in sorted(self._cfg.sections()):
            # If the section is just a hostname, make it match
            # If the section has a / in it, do a substring match
            if "/" not in sectionhost:
                if sectionhost == urlhost:
                    section = sectionhost
            elif sectionhost in url:
                section = sectionhost
            if section:
                log.debug("bugzillarc: Found matching section: %s", section)
                break

        if not section:
            log.debug("bugzillarc: No section found")
            return {}
        return dict(self._cfg.items(section))


    def save_api_key(self, url, api_key):
        """
        Save the API_KEY in the config file. We use the last file
        in the configpaths list, which is the one with the highest
        precedence.
        """
        configpaths = self.get_configpaths()
        if not configpaths:
            return None

        config_filename = configpaths[-1]
        section = _parse_hostname(url)
        cfg = configparser.ConfigParser()
        cfg.read(config_filename)

        if section not in cfg.sections():
            cfg.add_section(section)

        cfg.set(section, 'api_key', api_key.strip())

        _makedirs(config_filename)
        with open(config_filename, 'w') as configfile:
            cfg.write(configfile)

        return config_filename


class _BugzillaTokenCache(object):
    """
    Class for interacting with a .bugzillatoken cache file
    """
    @staticmethod
    def get_default_path():
        return _default_cache_location("bugzillatoken")

    def __init__(self):
        self._filename = None
        self._cfg = None

    def _get_domain(self, url):
        domain = urllib.parse.urlparse(url)[1]
        if domain and domain not in self._cfg.sections():
            self._cfg.add_section(domain)
        return domain

    def get_value(self, url):
        domain = self._get_domain(url)
        if domain and self._cfg.has_option(domain, 'token'):
            return self._cfg.get(domain, 'token')
        return None

    def set_value(self, url, value):
        if self.get_value(url) == value:
            return

        domain = self._get_domain(url)
        if value is None:
            self._cfg.remove_option(domain, 'token')
        else:
            self._cfg.set(domain, 'token', value)

        if self._filename:
            _makedirs(self._filename)
            with open(self._filename, 'w') as _cfg:
                log.debug("Saving to _cfg")
                self._cfg.write(_cfg)

    def get_filename(self):
        return self._filename

    def set_filename(self, filename):
        log.debug("Using tokenfile=%s", filename)
        cfg = configparser.ConfigParser()
        if filename:
            cfg.read(filename)
        self._filename = filename
        self._cfg = cfg