#!/usr/bin/python2.6
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
# Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.

import sys
import os
import getopt
from subprocess import Popen, PIPE


XSLT_PROC="/usr/bin/xsltproc"
XSLT_FILE="old-to-new.xslt"


def usage(exitcode=1):
    '''
        Print help page and exit script.

        Default exit code is 1, which indicates an error.  To exit
        normally, set keyword param exitcode to 0.
    '''
    this_script = os.path.basename(sys.argv[0])

    print ""
    print "%s - Convert old-style XML AI Manifests to the new schema." % this_script
    print ""
    print "For convenience, the command-line interface has similar semantics to cp(1)."
    print ""
    print "Usage:"
    print "\t%s [options] infile outfile" % this_script
    print "\t%s [options] infile... outdir" % this_script
    print "\t%s -r [options] indir... outdir" % this_script
    print "\nOptions:"
    print "\t-f        : force overwrite if output already exists"
    print "\t-r        : recursively transform .xml files in named sub-directory"
    print "\t-h --help : print this help page and exit"

    sys.exit(exitcode)


def run_cmd(cmd):
    '''
        Execute the given command in a subprocess.

        On success, returns the stdout from running the command.
        On failure, raises one of:
            OSError
            ValueError
            Exception
    '''

    try:
        cmd_popen = Popen(cmd, shell=True, stdout=PIPE)
        (cmd_stdout, cmd_stderr) = cmd_popen.communicate()
    except OSError, err:
        print "ERROR running [%s] : [%s]" % \
            (cmd, str(err))
        raise
    except ValueError, err:
        print "ERROR running [%s] : [%s]" % \
            (cmd, str(err))
        raise

    if cmd_popen.returncode != 0:
        errstr = "ERROR: command [%s] returned [%d] : [%s]" % \
            (cmd, cmd_popen.returncode, str(cmd_stderr))
        print errstr
        raise Exception, (errstr)

    if cmd_stderr is not None:
        print "WARNING: command [%s] produced stderr output: [%s]" % \
            (cmd, cmd_stderr)

    return cmd_stdout


def do_transform(xsltfile, infile, outfile, mkdirs=False, overwrite=False):
    '''
        Create the output directory, if appropriate, and run the xsltproc
        command to transform infile to oufile.

        On success, returns True.
        On failure, returns False.
    '''

    # Normalize the paths so we can check if they are really the same file
    # (doesn't always work, eg for paths beginning with "..")
    infile = os.path.normpath(infile)
    outfile = os.path.normpath(outfile)

    if infile == outfile:
        print "ERROR: source [%s] and target [%s] are the same" % \
            (infile, outfile)
        return False

    outdir = os.path.dirname(outfile)
    if (len(outdir)) and (not os.path.isdir(outdir)):
        if os.path.exists(outdir):
            print "ERROR: target dir [%s] is not a directory" % \
                outdir
            return False

        if not mkdirs:
            print "ERROR: target dir [%s] doesn't exist" % \
                outdir
            return False

        try:
            os.makedirs(outdir)
        except OSError, err:
            print "ERROR: failed to make dir [%s] : [%s]" % \
                (outdir, str(err))
            return False

    if (os.path.exists(outfile)) and (not overwrite):
        print "ERROR: target file [%s] already exists. Use -f." % \
            outfile
        return False

    # Construct command
    cmd = "%s -o %s %s %s" % (XSLT_PROC, outfile, xsltfile, infile)

    try:
        output = run_cmd(cmd)
    except:
        return False

    return True


def do_main():
    '''
        Process command line options and call do_transform() for
        each file to be processed.

        Returns: nothing.
    '''

    sources = []
    target = None
    force_overwrite = False
    recursive = False
    target_exists = False

    # Check xsltproc is installed
    if not os.access(XSLT_PROC, os.X_OK):
        print "ERROR: Cannot find %s" % XSLT_PROC
        print "You may be able to install it with:"
        print "\tpfexec pkg install pkg:/library/libxslt"
        sys.exit(1)

    # Check xsl transform file is available in same dir this
    # script was run from
    xsltdir = os.path.dirname(sys.argv[0])
    xsltfile = "%s/%s" % (xsltdir, XSLT_FILE)
    if (not os.path.exists(xsltfile)):
        print "XSLT file [%s] is missing from directory [%s]" % \
            (XSLT_FILE, xsltdir)
        sys.exit(1)

    # Fetch and process command line params and options
    try:
        optlist, args = getopt.getopt(sys.argv[1:], "frh", ["help"])
    except getopt.GetoptError:
        usage()

    for opt, arg in optlist:
        if (opt == "-f"):
            force_overwrite = True
        if (opt == "-r"):
            recursive = True
        if (opt == "-h") or (opt == "--help"):
            usage(exitcode=0)

    # There must be at least 2 params.  The last param is the
    # target; all the other params are the source(s).
    if len(args) < 2:
        usage()

    sources = args[:len(args) - 1]
    target = args[len(args) - 1]

    # note whether the target existed before we started
    if os.path.exists(target):
        target_exists = True

    # Check for invalid paramaters (pt. 1)
    if ((len(sources) > 1) and
        (not os.path.isdir(target))):
        # if there are multiple sources (files or dirs), then
        # target must be an existing directory
        print "ERROR: [%s] is not a directory" % \
            target
        sys.exit(1)

    for source in sources:
        # normalize source path
        source = os.path.normpath(source)

        # Check for invalid paramaters (pt. 2)
        if source == "/":
            print "ERROR: '/' not allowed"
            sys.exit(1)
        if not os.path.exists(source):
            print "ERROR: no such file or directory: [%s]" % \
                source
            sys.exit(1)
        if (os.path.isdir(source)) and (not recursive):
            print "ERROR: [%s] is a directory, but '-r' not specified" % \
                source
            sys.exit(1)
        if (not os.path.isdir(source)) and (recursive):
            print "ERROR: [%s] is not a directory, but '-r' was specified" % \
                source
            sys.exit(1)
        if ((os.path.isdir(source)) and
            (os.path.exists(target)) and
            (not os.path.isdir(target))):
            print "ERROR: [%s] is not a directory" % \
                target
            sys.exit(1)

        if os.path.isdir(source):
            # recursively iterate through source dir, processing each file
            for dirpath, dirnames, filenames in os.walk(source):
                # alter dirnames in-place to skip .*
                dirnames[:] = [d for d in dirnames if not d.startswith('.')]

                for name in filenames:
                    srcfile = os.path.join(dirpath, name)

                    partial_dstfile = os.path.join(dirpath, name)

                    # replicate how cp -r treats sub-dirs:
                    # 1. if source contains multiple sub-dirs, eg "a/b/c"
                    # then only create rightmost one, eg "c", under target
                    index = source.rfind("/", 1)
                    if index != -1:
                        # ensure partial_dstfile begins with source
                        if partial_dstfile.find(source) == 0:
                            partial_dstfile = partial_dstfile[index+1:]

                    # replicate how cp -r treats sub-dirs:
                    # 2. if target already existed then chop off leftmost
                    # dir of source from target
                    if not target_exists:
                        index = partial_dstfile.find("/", 1)
                        if index != -1:
                            partial_dstfile = partial_dstfile[index+1:]

                    dstfile = os.path.join(target, partial_dstfile)

                    if not do_transform(xsltfile, srcfile, dstfile,
                        mkdirs=True, overwrite=force_overwrite):
                        print "ERROR: Transform failed."
                        sys.exit(1)
        elif os.path.isdir(target):
            dstfile = os.path.join(target, os.path.basename(source))

            if not do_transform(xsltfile, source, dstfile,
                mkdirs=False, overwrite=force_overwrite):
                print "ERROR: Transform failed."
                sys.exit(1)
        else:
            # this must be a simple "single infile" -> "single outfile" job
            if not do_transform(xsltfile, source, target,
                mkdirs=False, overwrite=force_overwrite):
                print "ERROR: Transform failed."
                sys.exit(1)


if __name__ == "__main__":
    do_main()

    sys.exit(0)