import os
import urllib2
from urllib import urlretrieve
import urlparse
import hashlib

from charmhelpers.fetch import (
    BaseFetchHandler,
    UnhandledSource
)
from charmhelpers.payload.archive import (
    get_archive_handler,
    extract,
)
from charmhelpers.core.host import mkdir

"""
This class is a plugin for charmhelpers.fetch.install_remote.

It grabs, validates and installs remote archives fetched over "http", "https", "ftp" or "file" protocols. The contents of the archive are installed in $CHARM_DIR/fetched/.

Example usage:
install_remote("https://example.com/some/archive.tar.gz")
# Installs the contents of archive.tar.gz in $CHARM_DIR/fetched/.

See charmhelpers.fetch.archiveurl.get_archivehandler for supported archive types.
"""
class ArchiveUrlFetchHandler(BaseFetchHandler):
    """Handler for archives via generic URLs"""
    def can_handle(self, source):
        url_parts = self.parse_url(source)
        if url_parts.scheme not in ('http', 'https', 'ftp', 'file'):
            return "Wrong source type"
        if get_archive_handler(self.base_url(source)):
            return True
        return False

    def download(self, source, dest):
        # propogate all exceptions
        # URLError, OSError, etc
        proto, netloc, path, params, query, fragment = urlparse.urlparse(source)
        if proto in ('http', 'https'):
            auth, barehost = urllib2.splituser(netloc)
            if auth is not None:
                source = urlparse.urlunparse((proto, barehost, path, params, query, fragment))
                username, password = urllib2.splitpasswd(auth)
                passman = urllib2.HTTPPasswordMgrWithDefaultRealm()
                # Realm is set to None in add_password to force the username and password
                # to be used whatever the realm
                passman.add_password(None, source, username, password)
                authhandler = urllib2.HTTPBasicAuthHandler(passman)
                opener = urllib2.build_opener(authhandler)
                urllib2.install_opener(opener)
        response = urllib2.urlopen(source)
        try:
            with open(dest, 'w') as dest_file:
                dest_file.write(response.read())
        except Exception as e:
            if os.path.isfile(dest):
                os.unlink(dest)
            raise e

    def install(self, source):
        url_parts = self.parse_url(source)
        dest_dir = os.path.join(os.environ.get('CHARM_DIR'), 'fetched')
        if not os.path.exists(dest_dir):
            mkdir(dest_dir, perms=0755)
        dld_file = os.path.join(dest_dir, os.path.basename(url_parts.path))
        try:
            self.download(source, dld_file)
        except urllib2.URLError as e:
            raise UnhandledSource(e.reason)
        except OSError as e:
            raise UnhandledSource(e.strerror)
        return extract(dld_file)

    # Mandatory file validation via Sha1 or MD5 hashing.
    def download_and_validate(self, url, hashsum, validate="sha1"):
        if validate == 'sha1' and len(hashsum) != 40:
            raise ValueError("HashSum must be = 40 characters when using sha1"
                             " validation")
        if validate == 'md5' and len(hashsum) != 32:
            raise ValueError("HashSum must be = 32 characters when using md5"
                             " validation")
        tempfile, headers = urlretrieve(url)
        self.validate_file(tempfile, hashsum, validate)
        return tempfile

    # Predicate method that returns status of hash matching expected hash.
    def validate_file(self, source, hashsum, vmethod='sha1'):
        if vmethod != 'sha1' and vmethod != 'md5':
            raise ValueError("Validation Method not supported")

        if vmethod == 'md5':
            m = hashlib.md5()
        if vmethod == 'sha1':
            m = hashlib.sha1()
        with open(source) as f:
            for line in f:
                m.update(line)
        if hashsum != m.hexdigest():
            msg = "Hash Mismatch on {} expected {} got {}"
            raise ValueError(msg.format(source, hashsum, m.hexdigest()))