# -*- coding: utf-8 -*-
"""

    @author: Fabio Erculiani <lxnay@sabayon.org>
    @contact: lxnay@sabayon.org
    @copyright: Fabio Erculiani
    @license: GPL-2

    B{Entropy Package Manager Client}.

"""
import os
import sys

from entropy.const import const_is_python3

if const_is_python3():
    from subprocess import getoutput
else:
    from commands import getoutput
import shutil
import tempfile

from entropy.const import etpConst, etpSys, etpUi, const_setup_directory
from entropy.output import red, darkred, darkgreen, brown, bold, \
    print_info, print_error, print_warning
from entropy.i18n import _
import entropy.dep
import entropy.tools

def smart(options):

    # check if I am root
    if not entropy.tools.is_root():
        mytxt = _("You are not") # you are not root
        print_error(red(mytxt)+" "+bold("root")+red("."))
        return 1

    # Options available for all the packages submodules
    smart_req_savedir = None
    savedir = False
    newopts = []
    for opt in options:
        if opt == "--savedir":
            savedir = True
        elif opt.startswith("--"):
            print_error(red(" %s." % (_("Wrong parameters"),) ))
            return
        else:
            if savedir:
                try:
                    smart_req_savedir = os.path.realpath(opt)
                except OSError:
                    smart_req_savedir = None
                savedir = False
            else:
                newopts.append(opt)
    options = newopts
    if not options:
        return -10

    rc = 0

    from entropy.client.interfaces import Client
    entropy_client = None
    acquired = False
    try:
        entropy_client = Client()
        acquired = entropy.tools.acquire_entropy_locks(entropy_client)
        if not acquired:
            print_error(darkgreen(
                _("Another Entropy is currently running.")))
            return 1

        if options[0] == "package":
            rc = smart_pkg_handler(entropy_client, options[1:])

        elif options[0] == "quickpkg":
            rc = quickpkg_handler(entropy_client,
                options[1:], savedir = smart_req_savedir)

        elif (options[0] == "inflate") or (options[0] == "deflate") or \
            (options[0] == "extract"):
            rc = common_flate(entropy_client,
                options[1:], action = options[0], savedir = smart_req_savedir)
        else:
            rc = -10
    finally:
        if acquired and (entropy_client is not None):
            entropy.tools.release_entropy_locks(entropy_client)
        if entropy_client is not None:
            entropy_client.shutdown()

    return rc


def quickpkg_handler(entropy_client, mypackages, savedir = None):

    if (not mypackages):
        mytxt = _("No packages specified")
        if not etpUi['quiet']:
            print_error(darkred(" * ")+red(mytxt+"."))
        return 1

    if savedir is None:
        savedir = etpConst['entropyunpackdir']
        const_setup_directory(savedir)
    else:
        if not os.path.isdir(savedir):
            print_error(darkred(" * ")+red("--savedir ") + \
                savedir+red(" %s." % (_("does not exist"),) ))
            return 4

    packages = []
    for opt in mypackages:
        match = entropy_client.installed_repository().atomMatch(opt)
        if match[0] != -1:
            packages.append(match)
        else:
            if not etpUi['quiet']: print_warning(darkred(" * ") + \
                red("%s: " % (_("Cannot find"),))+bold(opt))
    pkgs = []
    for pkg in packages:
        if pkg not in pkgs:
            pkgs.append(pkg)
    packages = pkgs
    if not packages:
        print_error(darkred(" * ")+red("%s." % (_("No valid packages specified"),)))
        return 2

    # print the list
    mytxt = _("This is the list of the packages that would be quickpkg'd")
    if (not etpUi['quiet']) or (etpUi['ask']): print_info(darkgreen(" * ")+red(mytxt+":"))
    pkgInfo = {}
    for pkg in packages:
        atom = entropy_client.installed_repository().retrieveAtom(pkg[0])
        pkgInfo[pkg] = {}
        pkgInfo[pkg]['atom'] = atom
        pkgInfo[pkg]['idpackage'] = pkg[0]
        print_info(brown("\t[")+red("%s:" % (_("from"),))+bold(_("installed"))+brown("]")+" - "+atom)

    if (not etpUi['quiet']) or (etpUi['ask']):
        rc = entropy_client.ask_question(">>   %s" % (_("Would you like to recompose the selected packages ?"),))
        if rc == _("No"):
            return 0

    for pkg in packages:
        if not etpUi['quiet']:
            print_info(brown(" * ")+red("%s: " % (_("Compressing"),))+darkgreen(pkgInfo[pkg]['atom']))
        pkgdata = entropy_client.installed_repository().getPackageData(pkgInfo[pkg]['idpackage'])
        resultfile = entropy_client.generate_package(pkgdata, save_directory = savedir)
        if resultfile == None:
            if not etpUi['quiet']:
                print_error(darkred(" * ") + red("%s: " % (_("Error while creating package for"),)) + \
                    bold(pkgInfo[pkg])+darkred(". %s." % (_("Cannot continue"),)))
            return 3
        if not etpUi['quiet']:
            print_info(darkgreen("  * ")+red("%s: " % (_("Saved in"),))+resultfile)

    return 0

def common_flate(entropy_client, mytbz2s, action, savedir = None):

    if (not mytbz2s):
        print_error(darkred(" * ")+red("%s." % (_("No packages specified"),)))
        return 1

    # test if portage is available
    try:
        Spm = entropy_client.Spm()
        del Spm
    except Exception as e:
        entropy.tools.print_traceback()
        mytxt = _("Source Package Manager backend not available")
        print_error(darkred(" * ")+red("%s: %s" % (mytxt, e,)))
        return 1

    if savedir:
        if not os.path.isdir(savedir):
            print_error(darkred(" * ") + bold("--savedir") + ":" \
                            + red(" %s." % (_("directory does not exist"),)))
            return 1
    else:
        savedir = etpConst['entropyunpackdir']
        const_setup_directory(savedir)

    for tbz2 in mytbz2s:

        valid_etp = True
        if action == "deflate":
            valid_etp = entropy.tools.is_entropy_package_file(tbz2)
        if not (os.path.isfile(tbz2) and \
                    tbz2.endswith(etpConst['packagesext']) and \
                    valid_etp):
                print_error(
                    darkred(" * ") + bold(tbz2) + \
                        red(" %s" % (_("is not a valid Entropy package"),)))
                return 1

    if action == "inflate":
        rc = inflate_handler(entropy_client, mytbz2s, savedir)
    elif action == "deflate":
        rc = deflate_handler(mytbz2s, savedir)
    elif action == "extract":
        rc = extract_handler(mytbz2s, savedir)
    else:
        rc = -10
    return rc


def inflate_handler(entropy_client, mytbz2s, savedir):

    branch = entropy_client.Settings()['repositories']['branch']
    print_info(brown(" %s: " % (_("Using branch"),))+bold(branch))

    Spm = entropy_client.Spm()

    # analyze files
    for tbz2 in mytbz2s:
        print_info(darkgreen(" * ")+darkred("Inflating: ")+tbz2, back = True)
        etptbz2path = savedir+os.path.sep+os.path.basename(tbz2)
        if os.path.realpath(tbz2) != os.path.realpath(etptbz2path):
            # can convert a file without copying
            shutil.copy2(tbz2, etptbz2path)
        info_package = bold(os.path.basename(etptbz2path)) + ": "
        entropy_client.output(
            red(info_package + _("Extracting package metadata") + " ..."),
            importance = 0,
            level = "info",
            header = brown(" * "),
            back = True
        )
        mydata = Spm.extract_package_metadata(etptbz2path)
        entropy_client.output(
            red(info_package + _("Package extraction complete")),
            importance = 0,
            level = "info",
            header = brown(" * "),
            back = True
        )
        # append arbitrary revision
        mydata['revision'] = etpConst['spmetprev']
        mydata['download'] = mydata['download'][:-len(etpConst['packagesext'])] + \
            "~" + str(etpConst['spmetprev']) + etpConst['packagesext']
        # migrate to the proper format
        final_tbz2path = os.path.join(os.path.dirname(etptbz2path),
                                      os.path.basename(mydata['download']))
        shutil.move(etptbz2path, final_tbz2path)
        etptbz2path = final_tbz2path

        tmp_dir = etpConst['entropyunpackdir']
        tmp_fd, tmp_path = tempfile.mkstemp(prefix="inflate.", dir=tmp_dir)
        os.close(tmp_fd)
        # create
        mydbconn = entropy_client.open_generic_repository(tmp_path)
        mydbconn.initializeRepository()
        idpackage = mydbconn.addPackage(mydata, revision = mydata['revision'])
        mydbconn.close()
        entropy.tools.aggregate_entropy_metadata(etptbz2path, tmp_path)
        os.remove(tmp_path)
        print_info(darkgreen(" * ") + \
                       darkred("%s: " % (_("Inflated package"),)) + \
                       etptbz2path)

    return 0

def deflate_handler(mytbz2s, savedir):

    # analyze files
    for tbz2 in mytbz2s:
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Deflating"),))+tbz2, back = True)
        save_path = os.path.join(savedir, os.path.basename(tbz2))
        ext_rc = entropy.tools.remove_entropy_metadata(tbz2, save_path)
        if not ext_rc:
            return 1
        tbz2name = os.path.basename(tbz2)[:-len(etpConst['packagesext'])]
        tbz2name = entropy.dep.remove_tag(tbz2name)+etpConst['packagesext']
        newtbz2 = os.path.dirname(tbz2)+os.path.sep+tbz2name
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Deflated package"),))+newtbz2)

    return 0

def extract_handler(mytbz2s, savedir):

    # analyze files
    for tbz2 in mytbz2s:
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Extracting Entropy metadata from"),))+tbz2, back = True)
        dbpath = savedir+os.path.sep+os.path.basename(tbz2)
        dbpath = dbpath[:-len(etpConst['packagesext'])]+".db"
        if os.path.isfile(dbpath):
            os.remove(dbpath)
        # extract
        dump_rc = entropy.tools.dump_entropy_metadata(tbz2, dbpath)
        if not dump_rc:
            return 1
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Extracted Entropy metadata from"),))+dbpath)

    return 0

def smart_pkg_handler(entropy_client, mypackages):

    if (not mypackages):
        print_error(darkred(" * ")+red("%s." % (_("No packages specified"),)))
        return 1

    packages = []
    for opt in mypackages:
        match = entropy_client.atom_match(opt)
        if match[0] != -1:
            packages.append(match)
        else:
            print_warning(darkred(" * ")+red("%s: " % (_("Cannot find"),))+bold(opt))
    pkgs = []
    for pkg in packages:
        if pkg not in pkgs:
            pkgs.append(pkg)
    packages = pkgs
    if not packages:
        print_error(darkred(" * ")+red("%s." % (_("No valid packages specified"),)))
        return 2

    # print the list
    print_info(darkgreen(" * ")+red("%s:" % (_("This is the list of the packages that would be merged into a single one"),)))
    pkgInfo = {}
    for pkg in packages:
        dbconn = entropy_client.open_repository(pkg[1])
        atom = dbconn.retrieveAtom(pkg[0])
        pkgInfo[pkg] = atom
        print_info(brown("\t[")+red("%s:" % (_("from"),))+pkg[1]+brown("]")+" - "+atom)

    rc = entropy_client.ask_question(">>   %s" % (_("Would you like to create the packages above ?"),))
    if rc == _("No"):
        return 0

    print_info(darkgreen(" * ")+red("%s..." % (_("Creating merged Smart Package"),)))
    rc = smartpackagegenerator(entropy_client, packages)
    if rc != 0:
        print_error(darkred(" * ")+red("%s." % (_("Cannot continue"),)))
        return rc

    return 0


def smartpackagegenerator(entropy_client, matched_pkgs):

    fetchdata = []
    matchedAtoms = {}
    for x in matched_pkgs:
        xdbconn = entropy_client.open_repository(x[1])
        matchedAtoms[x] = {}
        xatom = xdbconn.retrieveAtom(x[0])
        xdownload = xdbconn.retrieveDownloadURL(x[0])
        xrevision = xdbconn.retrieveRevision(x[0])
        matchedAtoms[x]['atom'] = xatom
        matchedAtoms[x]['download'] = xdownload
        matchedAtoms[x]['revision'] = xrevision
        fetchdata.append(x)

    from entropy.spm.plugins.interfaces.portage_plugin import xpaktools
    import text_ui
    # run install_packages with onlyfetch
    rc = text_ui.install_packages(entropy_client, atomsdata = fetchdata,
        deps = False, onlyfetch = True)
    if rc[1] != 0:
        return rc[0]

    # create unpack dir and unpack all packages
    unpackdir = etpConst['entropyunpackdir']+"/smartpackage-"+str(entropy.tools.get_random_number())
    while os.path.isdir(unpackdir):
        unpackdir = etpConst['entropyunpackdir']+"/smartpackage-"+str(entropy.tools.get_random_number())
    if os.path.isdir(unpackdir):
        shutil.rmtree(unpackdir)
    os.makedirs(unpackdir)
    os.mkdir(unpackdir+"/content")
    os.mkdir(unpackdir+"/db")
    # create master database
    dbfile = unpackdir+"/db/merged.db"
    mergeDbconn = entropy_client.open_generic_repository(dbfile, name = "client")
    mergeDbconn.initializeRepository()
    tmpdbfile = dbfile+"--readingdata"
    for package in matched_pkgs:
        print_info(darkgreen("  * ")+brown(matchedAtoms[package]['atom'])+": "+red(_("collecting Entropy metadata")))
        entropy.tools.dump_entropy_metadata(
            etpConst['entropypackagesworkdir'] + os.path.sep + \
                matchedAtoms[package]['download'], tmpdbfile)
        # read db and add data to mergeDbconn
        mydbconn = entropy_client.open_generic_repository(tmpdbfile)
        idpackages = mydbconn.listAllPackageIds()

        for myidpackage in idpackages:
            data = mydbconn.getPackageData(myidpackage)
            if len(idpackages) == 1:
                # just a plain package that would like to become smart
                xpakdata = xpaktools.read_xpak(
                    etpConst['entropypackagesworkdir'] + \
                        os.path.sep + matchedAtoms[package]['download'])
            else:
                xpakdata = mydbconn.retrieveSpmMetadata(myidpackage) # already a smart package
            # add
            idpk = mergeDbconn.handlePackage(data, forcedRevision = matchedAtoms[package]['revision']) # get the original rev
            if xpakdata is not None:
                mergeDbconn.storeSpmMetadata(idpk, xpakdata)
        mydbconn.close()
        os.remove(tmpdbfile)

    # now we have the new database
    mergeDbconn.close()

    # merge packages
    for package in matched_pkgs:
        print_info(darkgreen("  * ")+brown(matchedAtoms[package]['atom'])+": "+red("unpacking content"))
        rc = entropy.tools.uncompress_tarball(
            etpConst['entropypackagesworkdir'] + \
                os.path.sep+matchedAtoms[x]['download'],
                extract_path = os.path.join(unpackdir, "content"))
        if rc != 0:
            print_error(darkred(" * ")+red("%s." % (_("Unpack failed due to unknown reasons"),)))
            return rc

    smartpackages_dir = os.path.join(
        etpConst['entropyworkdir'], "smartpackages", etpSys['arch'])
    if not os.path.isdir(smartpackages_dir):
        os.makedirs(smartpackages_dir)
    print_info(darkgreen("  * ")+red(_("Compressing smart package")))
    atoms = []
    for x in matchedAtoms:
        atoms.append(matchedAtoms[x]['atom'].split(os.path.sep)[1])
    atoms = '+'.join(atoms)
    smart_package_path = smartpackages_dir + os.path.sep + atoms + \
        ".app"
    rc = entropy.tools.compress_tar_bz2(smart_package_path, unpackdir+"/content")
    if rc != 0:
        print_error(darkred(" * ")+red("%s." % (_("Compression failed due to unknown reasons"),)))
        return rc
    # adding entropy database
    if not os.path.isfile(smart_package_path):
        print_error(darkred(" * ")+red("%s." % (_("Compressed file does not exist"),)))
        return 1

    entropy.tools.aggregate_entropy_metadata(smart_package_path, dbfile)
    print_info("\t"+smart_package_path)
    shutil.rmtree(unpackdir, True)
    return 0