#!/usr/bin/env python

# Copyright 2013, 2014 Red Hat, Inc., and William C. Benton
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import xml.etree.ElementTree as ET
import argparse
import StringIO
import re
import subprocess
import logging

from os.path import exists as pathexists
from os.path import realpath
from os.path import join as pathjoin
from os import makedirs
from os import symlink
from os import remove as rmfile
from shutil import copyfile

class Artifact(object):
    def __init__(self, a, g, v):
        self.artifact = a
        self.group = g
        self.version = v
    
    @classmethod
    def fromCoords(k, coords):
        g,a,v = coords.split(":")
        return k(a, g, v)
    
    @classmethod
    def fromSubtree(k, t, ns):
        a = t.find("./%sartifactId" % ns).text
        g = t.find("./%sgroupId" % ns).text
        v = t.find("./%sversion" % ns).text
        return k(a, g, v)
    
    def contains(self, substrings):
        for s in substrings:
            if s in self.artifact or s in self.group:
                cn_debug("ignoring %r because it contains %s" % (self, s))
                return True
        if len(substrings) > 0:
            cn_debug("not ignoring %r; looked for %r" % (self, substrings))
        return False
    
    def __repr__(self):
        return "%s:%s:%s" % (self.group, self.artifact, self.version)

class DummyPOM(object):
    def __init__(self, groupID=None, artifactID=None, version=None):
        self.groupID = groupID
        self.artifactID = artifactID
        self.version = version
        self.deps = []

def interestingDep(dt, namespace):
    if len(dt.findall("./%soptional" % namespace)) != 0:
        cn_debug("ignoring optional dep %r" % Artifact.fromSubtree(dt, namespace))
        return False
    if [e for e in dt.findall("./%sscope" % namespace) if e.text == "test"] != []:
        cn_debug("ignoring test dep %r" % Artifact.fromSubtree(dt, namespace))
        return False
    return True

class POM(object):
    def __init__(self, filename, suppliedGroupID=None, suppliedArtifactID=None, ignored_deps=[], override=None, extra_deps=[]):
        self.filename = filename
        self.sGroupID = suppliedGroupID
        self.sArtifactID = suppliedArtifactID
        self.logger = logging.getLogger("com.freevariable.climbing-nemesis")
        self.deps = []
        self.ignored_deps = ignored_deps
        self.extra_deps = extra_deps
        cn_debug("POM:  extra_deps is %r" % extra_deps)
        self._parsePom()
        self.claimedGroup, self.claimedArtifact  = override is not None and override or (self.groupID, self.artifactID)
    
    def _parsePom(self):
        tree = ET.parse(self.filename)
        project = tree.getroot()
        self.logger.info("parsing POM %s", self.filename)
        self.logger.debug("project tag is '%s'", project.tag)
        tagmatch = re.match("[{](.*)[}].*", project.tag)
        namespace = tagmatch and "{%s}" % tagmatch.groups()[0] or ""
        self.logger.debug("looking for '%s'", ("./%sgroupId" % namespace))
        groupIDtag = project.find("./%sgroupId" % namespace) 
        if groupIDtag is None:
            groupIDtag = project.find("./%sparent/%sgroupId" % (namespace,namespace))
        
        versiontag = project.find("./%sversion" % namespace)
        if versiontag is None:
            versiontag = project.find("./%sparent/%sversion" % (namespace,namespace))
        self.logger.debug("group ID tag is '%s'", groupIDtag)
        self.groupID = groupIDtag.text
        self.artifactID = project.find("./%sartifactId" % namespace).text
        self.version = versiontag.text
        depTrees = project.findall(".//%sdependencies/%sdependency" % (namespace, namespace))
        alldeps = [Artifact.fromSubtree(depTree, namespace) for depTree in depTrees if interestingDep(depTree, namespace)]
        alldeps = [dep for dep in alldeps if not (dep.group == self.groupID and dep.artifact == self.artifactID)]
        self.deps = [dep for dep in alldeps if not dep.contains(self.ignored_deps)] + [Artifact.fromCoords(xtra) for xtra in self.extra_deps]
        jarmatch = re.match(".*JPP-(.*).pom", self.filename)
        self.jarname = (jarmatch and jarmatch.groups()[0] or None)

def cn_debug(*args):
    logging.getLogger("com.freevariable.climbing-nemesis").debug(*args)

def cn_info(*args):
    logging.getLogger("com.freevariable.climbing-nemesis").info(*args)

def resolveArtifact(group, artifact, pomfile=None, kind="jar", ignored_deps=[], override=None, extra_deps=[]):
    # XXX: some error checking would be the responsible thing to do here
    cn_debug("rA:  extra_deps is %r" % extra_deps)
    if pomfile is None:
        try:
            if getFedoraRelease() > 19:
                [pom] = subprocess.check_output(["xmvn-resolve", "%s:%s:pom:%s" % (group, artifact, kind)]).split()
            else:
                [pom] = subprocess.check_output(["xmvn-resolve", "%s:%s:%s" % (group, artifact, kind)]).split()
            return POM(pom, ignored_deps=ignored_deps, override=override, extra_deps=extra_deps)
        except:
            return DummyPOM(group, artifact)
    else:
        return POM(pomfile, ignored_deps=ignored_deps, override=override, extra_deps=extra_deps)

def resolveArtifacts(identifiers):
    coords = ["%s:%s:jar" % (group, artifact) for (group, artifact) in identifiers]
    poms =  subprocess.check_output(["xmvn-resolve"] + coords).split()
    return [POM(pom) for pom in poms]

def resolveJar(group, artifact):
    [jar] = subprocess.check_output(["xmvn-resolve", "%s:%s:jar:jar" % (group, artifact)]).split()
    return jar

def makeIvyXmlTree(org, module, revision, status="release", meta={}, deps=[]):
    ivy_module = ET.Element("ivy-module", {"version":"1.0", "xmlns:e":"http://ant.apache.org/ivy/extra"})
    info = ET.SubElement(ivy_module, "info", dict({"organisation":org, "module":module, "revision":revision, "status":status}.items() + meta.items()))
    info.text = " " # ensure a close tag
    confs = ET.SubElement(ivy_module, "configurations")
    for conf in ["default", "provided", "test"]:
        ET.SubElement(confs, "conf", {"name":conf})
    pubs = ET.SubElement(ivy_module, "publications")
    ET.SubElement(pubs, "artifact", {"name":module, "type":"jar"})
    if len(deps) > 0:
        deptree = ET.SubElement(ivy_module, "dependencies")
        for dep in deps:
            ET.SubElement(deptree, "dependency", {"org":dep.group, "name":dep.artifact, "rev":dep.version})
    return ET.ElementTree(ivy_module)

def writeIvyXml(org, module, revision, status="release", fileobj=None, meta={}, deps=[]):
    # XXX: handle deps!
    if fileobj is None:
        fileobj = StringIO.StringIO()
    tree = makeIvyXmlTree(org, module, revision, status, meta=meta, deps=deps)
    tree.write(fileobj, xml_declaration=True)
    return fileobj

def ivyXmlAsString(org, module, revision, status, meta={}, deps=[]):
    return writeIvyXml(org, module, revision, status, meta=meta, deps=deps).getvalue()

def placeArtifact(artifact_file, repo_dirname, org, module, revision, status="release", meta={}, deps=[], supplied_ivy_file=None, scala=None, override=None, override_dir_only=False):
    if scala is not None:
        module = module + "_%s" % scala
    jarmodule = module
    if override is not None:
        org, module = override
        if not override_dir_only:
            jarmodule = module
    repo_dir = realpath(repo_dirname)
    artifact_dir = pathjoin(*[repo_dir] + [org] + [module, revision])
    ivyxml_path = pathjoin(artifact_dir, "ivy.xml")
    artifact_repo_path = pathjoin(artifact_dir, "%s-%s.jar" % (jarmodule, revision))
    
    if not pathexists(artifact_dir):
        makedirs(artifact_dir)
    
    ivyxml_file = open(ivyxml_path, "w")
    if supplied_ivy_file is None:
        writeIvyXml(org, module, revision, status, ivyxml_file, meta=meta, deps=deps)
    else:
        copyfile(supplied_ivy_file, ivyxml_path)
    
    if pathexists(artifact_repo_path):
        rmfile(artifact_repo_path)
    
    symlink(artifact_file, artifact_repo_path)

def getFedoraRelease():
    cmd = "rpm -q --qf %{version} fedora-release"
    return int(subprocess.check_output(cmd.split()))

def main():
    parser = argparse.ArgumentParser(description="Place a locally-installed artifact in a custom local Ivy repository; get metadata from Maven")
    parser.add_argument("group", metavar="GROUP", type=str, help="name of group")
    parser.add_argument("artifact", metavar="ARTIFACT", type=str, help="name of artifact")
    parser.add_argument("repodir", metavar="REPO", type=str, help="location for local repo")
    parser.add_argument("--version", metavar="VERSION", type=str, help="version to advertise this artifact as, overriding Maven metadata")
    parser.add_argument("--meta", metavar="K=V", type=str, help="extra metadata to store in ivy.xml", action='append')
    parser.add_argument("--jarfile", metavar="JAR", type=str, help="local jar file (use instead of POM metadata")
    parser.add_argument("--pomfile", metavar="POM", type=str, help="local pom file (use instead of xmvn-resolved one")
    parser.add_argument("--log", metavar="LEVEL", type=str, help="logging level")
    parser.add_argument("--ivyfile", metavar="IVY", type=str, help="supplied Ivy file (use instead of POM metadata)")
    parser.add_argument("--scala", metavar="VERSION", type=str, help="encode given scala version in artifact name")
    parser.add_argument("--ignore", metavar="STR", type=str, help="ignore dependencies whose artifact or group contains str", action='append')
    parser.add_argument("--override", metavar="ORG:NAME", type=str, help="override organization and/or artifact name")
    parser.add_argument("--override-dir-only", action='store_true', help="override organization and/or artifact name")
    parser.add_argument("--extra-dep", metavar="ORG:NAME:VERSION", action='append', help="add the given dependencya")
    args = parser.parse_args()
    
    if args.log is not None:
        logging.basicConfig(level=getattr(logging, args.log.upper()))
    
    override = args.override and args.override.split(":") or None
    cn_debug("cl: args.extra_dep is %r" % args.extra_dep)
    extra_deps = args.extra_dep is not None and args.extra_dep or []
    
    pom = resolveArtifact(args.group, args.artifact, args.pomfile, "jar", ignored_deps=(args.ignore or []), override=((not args.override_dir_only) and override or None), extra_deps=extra_deps)
    
    if args.jarfile is None:
        jarfile = resolveJar(pom.groupID or args.group, pom.artifactID or args.artifact)
    else:
        jarfile = args.jarfile
    
    version = (args.version or pom.version)
    
    meta = dict([kv.split("=") for kv in (args.meta or [])])
    cn_debug("meta is %r" % meta)
    
    placeArtifact(jarfile, args.repodir, pom.groupID, pom.artifactID, version, meta=meta, deps=pom.deps, supplied_ivy_file=args.ivyfile, scala=args.scala, override=override, override_dir_only=args.override_dir_only)

if __name__ == "__main__":
    main()