#!/usr/bin/python
'''
    # DESCRIPTION:
    # Entropy smart functionalities library

    Copyright (C) 2007-2008 Fabio Erculiani

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
'''
import shutil
from entropy.const import *
from entropy.output import *
from entropy.i18n import _
from entropy.client.interfaces import Client
Equo = Client()

def smart(options):

    # check if I am root
    if (not Equo.entropyTools.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
    smartRequestSavedir = 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:
                    smartRequestSavedir = os.path.realpath(opt)
                except OSError:
                    smartRequestSavedir = None
                savedir = False
            else:
                newopts.append(opt)
    options = newopts

    rc = 0
    if (options[0] == "application"):
        rc = smartappsHandler(options[1:])
    elif (options[0] == "package"):
        rc = smartPackagesHandler(options[1:])
    elif (options[0] == "quickpkg"):
        rc = QuickpkgHandler(options[1:], savedir = smartRequestSavedir)
    elif (options[0] == "inflate") or (options[0] == "deflate") or (options[0] == "extract"):
        rc = CommonFlate(options[1:], action = options[0], savedir = smartRequestSavedir)
    else:
        rc = -10

    return rc


def QuickpkgHandler(mypackages, savedir = None):

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

    if savedir == None:
        savedir = etpConst['packagestmpdir']
        if not os.path.isdir(etpConst['packagestmpdir']):
            os.makedirs(etpConst['packagestmpdir'])
    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 = Equo.clientDbconn.atomMatch(opt)
        if match[0] != -1:
            packages.append(match)
        else:
            if not etpUi['quiet']: print_warning(darkred(" * ")+red("%s: " % (_("Cannot find"),))+bold(opt))
    packages = Equo.entropyTools.filter_duplicated_entries(packages)
    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 = Equo.clientDbconn.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 = Equo.askQuestion(">>   %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 = Equo.clientDbconn.getPackageData(pkgInfo[pkg]['idpackage'])
        resultfile = Equo.quickpkg_handler(pkgdata = pkgdata, dirpath = 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 CommonFlate(mytbz2s, action, savedir = None):

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

    # test if portage is available
    try:
        Spm = Equo.Spm()
        del Spm
    except Exception, e:
        Equo.entropyTools.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['packagestmpdir']

    for tbz2 in mytbz2s:

        valid_etp = True
        if action == "deflate":
            valid_etp = Equo.entropyTools.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 = InflateHandler(mytbz2s, savedir)
    elif action == "deflate":
        rc = DeflateHandler(mytbz2s, savedir)
    elif action == "extract":
        rc = ExtractHandler(mytbz2s,savedir)
    else:
        rc = -10
    return rc


def InflateHandler(mytbz2s, savedir):

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

    Spm = Equo.Spm()
    Qa = Equo.QA()

    # analyze files
    for tbz2 in mytbz2s:
        print_info(darkgreen(" * ")+darkred("Inflating: ")+tbz2, back = True)
        etptbz2path = savedir+"/"+os.path.basename(tbz2)
        if os.path.realpath(tbz2) != os.path.realpath(etptbz2path): # can convert a file without copying
            shutil.copy2(tbz2,etptbz2path)
        mydata = Spm.extract_pkg_metadata(etptbz2path)
        # append arbitrary revision
        mydata['revision'] = 9999
        mydata['download'] = mydata['download'][:-5]+"~9999.tbz2"
        # 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
        # create temp database
        dbpath = etpConst['packagestmpdir']+"/"+str(Equo.entropyTools.get_random_number())
        while os.path.isfile(dbpath):
            dbpath = etpConst['packagestmpdir']+"/"+str(Equo.entropyTools.get_random_number())
        # create
        mydbconn = Equo.open_generic_database(dbpath)
        mydbconn.initializeDatabase()
        idpackage, yyy, xxx = mydbconn.addPackage(mydata, revision = mydata['revision'])
        del yyy, xxx
        Qa.test_missing_dependencies([idpackage], mydbconn)
        mydbconn.closeDB()
        Equo.entropyTools.aggregate_edb(tbz2file = etptbz2path, dbfile = dbpath)
        os.remove(dbpath)
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Inflated package"),))+etptbz2path)

    return 0

def DeflateHandler(mytbz2s, savedir):

    # analyze files
    for tbz2 in mytbz2s:
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Deflating"),))+tbz2, back = True)
        mytbz2 = Equo.entropyTools.remove_edb(tbz2,savedir)
        tbz2name = os.path.basename(mytbz2)[:-5] # remove .tbz2
        tbz2name = Equo.entropyTools.remove_tag(tbz2name)+etpConst['packagesext']
        newtbz2 = os.path.dirname(mytbz2)+"/"+tbz2name
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Deflated package"),))+newtbz2)

    return 0

def ExtractHandler(mytbz2s, savedir):

    # analyze files
    for tbz2 in mytbz2s:
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Extracting Entropy metadata from"),))+tbz2, back = True)
        dbpath = savedir+"/"+os.path.basename(tbz2)[:-4]+"db"
        if os.path.isfile(dbpath):
            os.remove(dbpath)
        # extract
        out = Equo.entropyTools.extract_edb(tbz2,dbpath = dbpath)
        print_info(darkgreen(" * ")+darkred("%s: " % (_("Extracted Entropy metadata from"),))+out)

    return 0

def smartPackagesHandler(mypackages):

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

    packages = []
    for opt in mypackages:
        match = Equo.atom_match(opt)
        if match[0] != -1:
            packages.append(match)
        else:
            print_warning(darkred(" * ")+red("%s: " % (_("Cannot find"),))+bold(opt))
    packages = Equo.entropyTools.filter_duplicated_entries(packages)
    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 = Equo.open_repository(pkg[1])
        atom = dbconn.retrieveAtom(pkg[0])
        pkgInfo[pkg] = atom
        print_info(brown("\t[")+red("%s:" % (_("from"),))+pkg[1]+brown("]")+" - "+atom)

    rc = Equo.askQuestion(">>   %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(packages)
    if rc != 0:
        print_error(darkred(" * ")+red("%s." % (_("Cannot continue"),)))
        return rc

    return 0


def smartpackagegenerator(matchedPackages):

    fetchdata = []
    matchedAtoms = {}
    for x in matchedPackages:
        xdbconn = Equo.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)
    import text_ui
    # run installPackages with onlyfetch
    rc = text_ui.installPackages(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(Equo.entropyTools.get_random_number())
    while os.path.isdir(unpackdir):
        unpackdir = etpConst['entropyunpackdir']+"/smartpackage-"+str(Equo.entropyTools.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 = Equo.open_generic_database(dbfile, dbname = "client")
    mergeDbconn.initializeDatabase()
    tmpdbfile = dbfile+"--readingdata"
    for package in matchedPackages:
        print_info(darkgreen("  * ")+brown(matchedAtoms[package]['atom'])+": "+red(_("collecting Entropy metadata")))
        Equo.entropyTools.extract_edb(etpConst['entropyworkdir']+"/"+matchedAtoms[package]['download'],tmpdbfile)
        # read db and add data to mergeDbconn
        mydbconn = Equo.open_generic_database(tmpdbfile)
        idpackages = mydbconn.listAllIdpackages()

        for myidpackage in idpackages:
            data = mydbconn.getPackageData(myidpackage)
            if len(idpackages) == 1:
                # just a plain package that would like to become smart
                xpakdata = Equo.entropyTools.read_xpak(etpConst['entropyworkdir']+"/"+matchedAtoms[package]['download'])
            else:
                xpakdata = mydbconn.retrieveXpakMetadata(myidpackage) # already a smart package
            # add
            idpk, rev, y = mergeDbconn.handlePackage(data, forcedRevision = matchedAtoms[package]['revision']) # get the original rev
            del y
            mergeDbconn.storeXpakMetadata(idpk, xpakdata)
        mydbconn.closeDB()
        os.remove(tmpdbfile)

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

    # merge packages
    for package in matchedPackages:
        print_info(darkgreen("  * ")+brown(matchedAtoms[package]['atom'])+": "+red("unpacking content"))
        rc = Equo.entropyTools.uncompress_tar_bz2(etpConst['entropyworkdir']+"/"+matchedAtoms[x]['download'], extractPath = unpackdir+"/content")
        if rc != 0:
            print_error(darkred(" * ")+red("%s." % (_("Unpack failed due to unknown reasons"),)))
            return rc

    if not os.path.isdir(etpConst['smartpackagesdir']):
        os.makedirs(etpConst['smartpackagesdir'])
    print_info(darkgreen("  * ")+red(_("Compressing smart package")))
    atoms = []
    for x in matchedAtoms:
        atoms.append(matchedAtoms[x]['atom'].split("/")[1])
    atoms = '+'.join(atoms)
    smart_package_path = etpConst['smartpackagesdir'] + "/" + atoms + \
        etpConst['smartappsext']
    rc = Equo.entropyTools.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

    Equo.entropyTools.aggregate_edb(smart_package_path,dbfile)
    print_info("\t"+smart_package_path)
    shutil.rmtree(unpackdir,True)
    return 0


def smartappsHandler(mypackages):

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

    gplusplus = os.system("which g++ &> /dev/null")
    if gplusplus != 0:
        print_error(darkred(" * ")+red("%s." % (_("Cannot find G++ compiler"),)))
        return gplusplus

    packages = []
    for opt in mypackages:
        if opt in packages:
            continue
        match = Equo.atom_match(opt)
        if match[0] != -1:
            packages.append(match)
        else:
            print_warning(darkred(" * ") + red("%s: " %(_("Cannot find"),)) + \
                bold(opt))

    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 worked out"),)))

    for pkg in packages:
        dbconn = Equo.open_repository(pkg[1])
        atom = dbconn.retrieveAtom(pkg[0])
        print_info(brown("\t[") + red("%s:" % (_("from"),)) + pkg[1] + \
            red("|SMART") + brown("]") + " - " + atom)

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

    rc = smartgenerator(packages)
    if rc != 0:
        print_error(darkred(" * ")+red("%s." % (_("Cannot continue"),)))
    return rc

# tool that generates .tar.bz2 packages with all the binary dependencies included
def smartgenerator(matched_atoms):

    import entropy.tools as entropyTools

    master_atom = matched_atoms[0]
    dbconn = Equo.open_repository(master_atom[1])
    idpackage = master_atom[0]
    atom = dbconn.retrieveAtom(idpackage)
    pkgfilepath = dbconn.retrieveDownloadURL(idpackage)
    pkgcontent = dbconn.retrieveContent(idpackage)
    pkgbranch = dbconn.retrieveBranch(idpackage)
    pkgfilename = os.path.basename(pkgfilepath)
    pkgname = pkgfilename.split(etpConst['packagesext'])[0].replace(":","_").replace("~","_")

    fetchdata = matched_atoms
    # run installPackages with onlyfetch
    import text_ui
    rc = text_ui.installPackages(atomsdata = fetchdata, deps = False, onlyfetch = True)
    if rc[1] != 0:
        return rc[0]


    # create the working directory
    pkgtmpdir = os.path.join(etpConst['entropyunpackdir'], pkgname)
    pkg_data_dir = os.path.join(pkgtmpdir, pkgname)
    if os.path.isdir(pkg_data_dir):
        shutil.rmtree(pkg_data_dir)
    os.makedirs(pkg_data_dir)
    main_bin_path = os.path.join(etpConst['packagesbindir'], pkgbranch,
        pkgfilename)
    print_info(darkgreen(" * ") + \
        red("%s " % (_("Unpacking the main package"),)) + \
        bold(str(pkgfilename)))
    entropyTools.uncompress_tar_bz2(main_bin_path, pkg_data_dir) # first unpack

    binary_execs = []
    for item in pkgcontent:
        filepath = pkg_data_dir + item
        import commands
        if os.access(filepath,os.X_OK):
            if commands.getoutput("file %s" % (filepath,)).find("LSB executable") != -1:
                binary_execs.append(item)

    # now uncompress all the rest
    for dep_idpackage, dep_repo in matched_atoms[1:]:
        mydbconn = Equo.open_repository(dep_repo)
        download = os.path.basename(mydbconn.retrieveDownloadURL(dep_idpackage))
        depbranch = mydbconn.retrieveBranch(dep_idpackage)
        depatom = mydbconn.retrieveAtom(dep_idpackage)
        print_info(darkgreen(" * ") + \
            red("%s " % (_("Unpacking dependency package"),)) + bold(depatom))
        deppath = os.path.join(etpConst['packagesbindir'], depbranch, download)
        entropyTools.uncompress_tar_bz2(deppath, pkg_data_dir) # first unpack

    # now create the bash script for each binary_execs
    os.makedirs(pkg_data_dir+"/wrp")
    wrapper_file = os.path.join(etpConst['installdir'],"services/smartapp_wrapper")
    if not os.path.isfile(wrapper_file):
        wrapper_file = "../services/smartapp_wrapper"

    wrapper_path = pkg_data_dir+"/wrp/wrapper"
    shutil.copy2(wrapper_file, wrapper_path)
    # chmod
    os.chmod(wrapper_path,0755)

    cc_content = """
#include <cstdlib>
#include <cstdio>
#include <stdio.h>
int main() {
    int rc = system("pid=$(pidof --item--.exe);"
                    "listpid=$(ps x | grep $pid);"
                "filename=$(echo $listpid | cut -d' ' -f 5);"
                "currdir=$(dirname $filename);"
                "/bin/sh $currdir/wrp/wrapper $currdir --item--" );
    return rc;
}
"""

    for item in binary_execs:
        item = item.split("/")[-1]
        item_content = cc_content.replace("--item--",item)
        item_cc = "%s/%s.cc" % (pkg_data_dir,item,)
        f = open(item_cc,"w")
        f.write(item_content)
        f.flush()
        f.close()
        # now compile
        os.system("cd %s/; g++ -Wall %s.cc -o %s.exe" % (pkg_data_dir,item,item,))
        os.remove(item_cc)

    smartpath = "%s/%s-%s%s" % (etpConst['smartappsdir'],pkgname,etpConst['currentarch'],etpConst['smartappsext'],)
    print_info(darkgreen(" * ")+red("%s: " % (_("Compressing smart application"),))+bold(atom))
    print_info("\t%s" % (smartpath,))
    Equo.entropyTools.compress_tar_bz2(smartpath, pkgtmpdir)
    shutil.rmtree(pkgtmpdir,True)

    return 0