#!/usr/bin/python
# Copyright (c) 2012, Red Hat, Inc
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the
#    distribution.
# 3. Neither the name of Red Hat nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors:
#   Stanislav Ochotnicky <sochotnicky@redhat.com>
#

import os
import sys
import signal
import traceback
from javapackages import Depmap

class TagBuilder:
    def __init__ (self, filelist=None):
        if filelist == None:
            filelist = sys.stdin
        paths = map (lambda x: x.rstrip (), filelist.readlines ())
        self.provided_artifacts = []
        self.skipped_artifacts = []
        if paths:
            # let's first read all fragment files for provided artifacts
            fragment_dir = os.path.dirname(paths[0])
            for dirname, dirnames, filenames in os.walk(fragment_dir):
                for filename in filenames:
                    if filename.endswith(".pom"):
                        continue
                    depmap = Depmap(os.path.join(dirname, filename))
                    self.provided_artifacts.extend(depmap.get_provided_mappings())
                    self.skipped_artifacts.extend(depmap.get_skipped_artifacts())
        for path in paths:
            if path.endswith(".pom"):
                continue
            self.print_mvn_requires(path)

    def __process_jvm_req(self, name, version):
        if not version:
            return
        try:
            jsplit = version.split('.')
            if len(jsplit) != 2:
                # if we don't have major.minor format, just ignore version
                raise ValueError("Required Java version not in major.minor format")
            major = int(jsplit[0])
            minor = int(jsplit[1])
            if major > 1 or minor > 5:
                print("{name} >= 1:{major}.{minor}".format(name=name,
                                                           major=major,
                                                           minor=minor))
            else:
                print("{name} >= {major}.{minor}".format(name=name,
                                                         major=major,
                                                         minor=minor))
        except ValueError:
            # what? not a numbered major/minor java release?
            print(name)


    def print_mvn_requires(self, path):
        depmap = Depmap(path)
        skipped_but_required = []
        base_package_requires=set()

        for provided in depmap.get_provided_artifacts():
            if provided.namespace:
                base_package_requires.add("{ns}-runtime".format(ns=provided.namespace))
            else:
                base_package_requires.add("jpackage-utils")
        for basereq in base_package_requires:
            print basereq

        unknown_deps = []
        for dependency in depmap.get_required_artifacts():
            if dependency.version == "UNKNOWN":
                unknown_deps.append(dependency)
                continue
            for skipped in self.skipped_artifacts:
                if (skipped.groupId == dependency.groupId and
                    skipped.artifactId == dependency.artifactId and
                    skipped.classifier == dependency.classifier and
                    skipped.extension == dependency.extension):
                    skipped_but_required.append(skipped)
            for m_provided, l_provided in self.provided_artifacts:
                if (m_provided.groupId == dependency.groupId and
                    m_provided.artifactId == dependency.artifactId and
                    m_provided.classifier == dependency.classifier and
                    m_provided.extension == dependency.extension and
                    m_provided.namespace == dependency.namespace):

                    # if dependency is versioned but another subpackage provides
                    # non-versioned artifact, it's coming from a different package
                    if (dependency.version and
                        dependency.version != l_provided.version):
                        continue

                    # if dependency is not versioned but provides is versioned
                    # the dependency is coming from a different package
                    if not dependency.version and l_provided.version:
                        continue

                    # requires on subpackages are always versioned
                    print("{rpmstr} = {version}".format(
                        rpmstr=dependency.get_rpm_str(dependency.version),
                        version=m_provided.version))
                    break
            else:
                # TODO: remove when not needed
                # do not generate requires like "a:b:pom:" yet
                if dependency.extension == "pom":
                    dependency.extension = ""
                print(dependency.get_rpm_str(dependency.version))

        if unknown_deps:
            unknown_msg = "Following dependencies were not resolved and " \
                          "requires cannot be generated. Either remove the " \
                          "dependency from pom.xml or add proper packages to " \
                          "BuildRequires:\n"
            for unknown in unknown_deps:
                unknown_msg = unknown_msg + \
                            "{art}\n".format(art=unknown)
            raise Exception(unknown_msg)

        if skipped_but_required:
            skipped_msg = "Following artifacts were built " \
                          "but are not being installed however other " \
                          "artifacts require them. Either package these " \
                          "artifacts or do not build them. To package " \
                          "call %mvn_package in %prep:\n"
            for skipped in skipped_but_required:
                skipped_msg = skipped_msg + \
                            "%mvn_package {art} <package_name>\n".format(art=skipped)
            raise Exception(skipped_msg)

        reqs = {'java': depmap.get_java_requires(),
                'java-devel': depmap.get_java_devel_requires()}
        for name, version in reqs.iteritems():
            self.__process_jvm_req(name, version)


if __name__ == "__main__":
    try:
        builder = TagBuilder ()
    except Exception, e:
        traceback.print_exc(file=sys.stderr)
        sys.stderr.write(str(e))
        # rpmbuild ignores non-zero exit codes but this that is bad. Make sure
        # the build fails and doesn't silently ignore problems
        os.kill(os.getppid(), signal.SIGTERM)