import os, sys, os.path
import glob
from optparse import OptionParser
import subprocess
from shutil import copy, copytree,  Error

# fsw_version (required argument)
# Keyword arguments:
# File describing packages to process, defaults to 
#   <fsw_version>_package_list.txt
#
#  lines of form
#      <mjr_pkg>  <minor_pkg> <version>  [lib] [inc]  [src] [lib=LIBNAME]*    
#  If "lib" is present, libraries will be copied to install lib directory
#  If instead lib=LIBNAME (one or more such) is present, that specific library
#    will be copied 
#  if "inc" is present, includes will be recursively copied
#  "src" indicates private includes in src dir should be copied to
#  src subdirectory of install include
#   e.g.,
#      APP LSE     V1-3-6  lib inc
#      CDM XFC_DB  V3-1-1  lib inc
#      CDM CPG_DB  V0-1-0  inc
# input binary tag (defaults to linux-gcc)
# output root (defaults to $GLAST_EXT/obf)
# input root (defaults to 
#     /afs/slac.stanford.edu/g/glast/flight/ltx_root_<fsw_version>)
# overwrite (defaults to False)
# compiler   NO DEFAULT

# Local utilities

# If directory doesn't already exist, attempt to make it
def insureDir(dirpath):
    if not os.access(dirpath, os.F_OK):  # make the directory
        try:
            os.mkdir(dirpath, 0775)
        except:
            print "Failed to create directory", dirpath
            exit(1)


usage = "usage: %prog [options] fsw_version"
parser = OptionParser(usage=usage)
parser.add_option("-p", "--package_list", dest="pkgList",
                  help="file containing list of fsw packages (<mjr> <mnr>) and what to do with them.  Default: <fsw_version>_package_list.txt",
                  default="")

if sys.platform == 'win32':
    inputBinaryDefault = 'VC8debug'
else:
    inputBinaryDefault = 'linux-gcc'
parser.add_option("--input_binary", dest="inputBinary",
                  default=inputBinaryDefault,
                  help="input binary tag [default: %default]")
parser.add_option("-c", "--compiler", dest="compiler", default="",
                  help="compiler")
parser.add_option("--input_root", dest="inputRoot", default="",
                  help="Input fsw build root")
parser.add_option("--output_parent", dest="output", default="",
                  help="Output root parent [default: $GLAST_EXT/obf]")

parser.add_option("--overwrite", dest="overwrite", default=False,
                  help="Overwrite existing installation if any [default: False]")

(options, args) = parser.parse_args()
for a in args:
    print a


if len(args) < 1:
    print "Missing required fsw version"
    exit(1)

fswVersion=args[0]

print "Was invoked for fsw version", fswVersion
print "Option values before processing are: "
print "Package list: ", options.pkgList
print "Input binary tag: ", options.inputBinary
#print "Output binary tag: ", options.outputBinary
print "Compiler: ", options.compiler
print "Input fsw build root: ", options.inputRoot
print "Parent output root: ", options.output
print "Value of overwrite: ", options.overwrite

if options.inputRoot == "":
    #options.inputRoot = "/afs/slac.stanford.edu/g/glast/flight/ltx_root_" + fswVersion
    #print "after processing input fsw build root is:", options.inputRoot
    print "No value found for required option --input_root"
    exit(1)
if options.pkgList == "":
    options.pkgList = fswVersion + "_package_list.txt"
    print "after processing package list is:", options.pkgList

if options.output == "":
    options.output = os.path.join(os.environ['GLAST_EXT'], "obf")
    print "after processing output parent root is:", options.output


if not os.access(options.output, os.W_OK):
    print "No write access to ", options.output
    exit(1)

if options.compiler == "":
    print "No value found for required option --compiler"
    exit(1)
    
options.output = os.path.join(options.output, fswVersion)
if not options.overwrite:
    if os.access(options.output, os.F_OK):
        print "Will not overwrite existing output path ", options.output
        exit(1)
        
insureDir(options.output)  # make the directory if necessary
options.output = os.path.join(options.output, options.compiler)
insureDir(options.output)

libdir = os.path.join(options.output, "lib")
insureDir(libdir)
print "libdir is", libdir
includedir = os.path.join(options.output, "include")
insureDir(includedir)

srcincludedir = os.path.join(includedir, "src")
insureDir(srcincludedir)

if not os.access(options.pkgList, os.R_OK):
    print "Cannot read package list ", options.pkgList
    exit(1)

# copy the package list file to doc directory
docdir = os.path.join(options.output, "doc")
insureDir(docdir)

#cmdargs = ["cp", os.path.basename(options.pkgList), docdir]
#try:
#    subprocess.check_call(cmdargs)
#except subprocess.CalledProcessError:
#    print "check_call failure with args: ", cmdargs
#    exit(1)
copy(str(os.path.basename(options.pkgList)), str(docdir))


pkgListFile = open(options.pkgList)

libfileprefix = ""
if sys.platform != "win32":
    libfileprefix = "lib"
    libfilesuffixes = ['.so']
#libfilesuffix = ".so"     # OS dependent
else:
    libfilesuffixes = ['.lib', '.dll', '.def']
for line in pkgListFile:
    # parse into major package, minor package, other stuff
    if line[0] is "#": continue
    toks = line.split(None)
    if len(toks) == 0: continue
    if toks[0] == "": continue
    if len(toks) <  3:
        print "Bad input line ", line
        exit(1)

    maj = toks[0]
    min = toks[1]
    ver = toks[2]
    print "line is: ", line
    if "lib" in toks[3:]:
        print "Found lib in toks[3:]"
        for suffix in libfilesuffixes:
            print "suffix is: ", suffix
            libpattern = os.path.join(options.inputRoot, maj, "binary", min, ver,
                                        options.inputBinary, "*", "*" + suffix)

            print "libpattern is: ", libpattern
            for libfile in glob.glob(libpattern):
                copy(str(libfile), str(libdir))
                #cmdargs = ["cp", libfile, libdir]
                #print cmdargs
                #try:
                #    subprocess.check_call(cmdargs)
                #except subprocess.CalledProcessError:
                #    print "check_call failure with args: ", cmdargs
                #    exit(1)
    else:
        for t in toks[3:]:
            #print t
            #print t[:4]
            if t[:4] == "lib=":
                print "found lib="
                for suffix in libfilesuffixes:
                
                    libfilename = libfileprefix + t[4:] + suffix
                    print "libfilename is: ", libfilename
                    libpattern = os.path.join(options.inputRoot, maj, "binary",
                                              min, ver, options.inputBinary,
                                              "*", libfilename)
                    print "libpattern is: ", libpattern
                    for libfile in glob.glob(libpattern):
                        print "found libfile ", libfile
                        copy(str(libfile), str(libdir))
                        #cmdargs = ["cp", libfile, libdir]
                        #print cmdargs
                        #try:
                        #    subprocess.check_call(cmdargs)
                        #except subprocess.CalledProcessError:
                        #    print "check_call failure with args: ", cmdargs
                        #    exit(1)
                
    if "inc" in toks[3:]:
        incpattern = os.path.join(options.inputRoot, maj, "source", min,
                                  ver, min)
    
        for srcincdir in glob.glob(incpattern):   # should be at most one
            destincdir = os.path.join(includedir, min)
            #print "srcincdir is: ", srcincdir
            #print "destincdir is: ", destincdir
            #cmdargs = ["cp", "-r", srcincdir, destincdir]
            #try:
            #    subprocess.check_call(cmdargs)
            #except subprocess.CalledProcessError:
            #    print "check_call failure with args: ", cmdargs
            #    exit(1)
            try:
                copytree(str(srcincdir), str(destincdir))

            except Error, err:
                print "Recursive copy failed with error ",err

                
    if "src" in toks[3:]:
        incpattern = os.path.join(options.inputRoot, maj, "source", min,
                                  ver, "src", "*.h")
        for srcincludefile in glob.glob(incpattern):
            print "copying srcinclude file ", srcincludefile, "to ", srcincludedir
            #cmdargs = ["copy", srcincludefile, srcincludedir]
            #try:
            #    subprocess.check_call(cmdargs)
            #except subprocess.CalledProcessError:
            #    print "check_call failure with args: ", cmdargs
            #    exit(1)
            copy(str(srcincludefile), str(srcincludedir))