#!/usr/bin/env python3

 from argparse import ArgumentParser

 import os.path

 import platform

 import collections
 import traceback
 import sys
 import json

 import copy

 from CommandUtils import CommandUtils
 from Logger import Logger
 from constants import constants

 from PackageManager import PackageManager

 from SpecData import SPECS

 from PackageInfo import PackageInfo

 def main():

     parser = ArgumentParser()

     parser.add_argument("-s", "--spec-path", dest="specPath", default="../../SPECS")
     parser.add_argument("-x", "--source-path", dest="sourcePath",
                         default="../../stage/SOURCES")
     parser.add_argument("-r", "--rpm-path", dest="rpmPath",
                         default="../../stage/RPMS")
     parser.add_argument("-i", "--install-package", dest="installPackage",
                         default=False, action="store_true")
     parser.add_argument("-p", "--publish-RPMS-path", dest="publishRPMSPath",
                         default="../../stage/PUBLISHRPMS")
     parser.add_argument("-e", "--publish-XRPMS-path", dest="publishXRPMSPath",
                         default="../../stage/PUBLISHXRPMS")
     parser.add_argument("-l", "--log-path", dest="logPath", default="../../stage/LOGS")

     parser.add_argument("-y", "--log-level", dest="logLevel", default="error")

     parser.add_argument("-z", "--top-dir-path", dest="topDirPath", default="/usr/src/photon")
     parser.add_argument("-b", "--build-root-path", dest="buildRootPath", default="/mnt")
     parser.add_argument("-t", "--threads", dest="buildThreads",
                         default=1, type=int, help="Number of working threads")
     parser.add_argument("-m", "--tool-chain-stage", dest="toolChainStage", default="None")
     parser.add_argument("-c", "--pullsources-config", dest="pullsourcesConfig",
                         default="pullsources.conf")

     parser.add_argument("-d", "--dist-tag", dest="dist", default="")

     parser.add_argument("-k", "--input-RPMS-path", dest="inputRPMSPath", default=None)
     parser.add_argument("-n", "--build-number", dest="buildNumber", default="0000000")
     parser.add_argument("-v", "--release-version", dest="releaseVersion", default="NNNnNNN")
     parser.add_argument("-u", "--enable-rpmcheck", dest="rpmCheck",
                         default=False, action="store_true")
     parser.add_argument("-a", "--source-rpm-path", dest="sourceRpmPath",
                         default="../../stage/SRPMS")
     parser.add_argument("-w", "--pkginfo-file", dest="pkgInfoFile",
                         default="../../stage/pkg_info.json")
     parser.add_argument("-g", "--pkg-build-option-file", dest="pkgBuildOptionFile",
                         default="../../common/data/pkg_build_options.json")
     parser.add_argument("-q", "--rpmcheck-stop-on-error", dest="rpmCheckStopOnError",
                         default=False, action="store_true")
     parser.add_argument("-bd", "--publish-build-dependencies", dest="publishBuildDependencies",
                         default=False)

     parser.add_argument("-pw", "--package-weights-path", dest="packageWeightsPath", default=None)

     parser.add_argument("-bt", "--build-type", dest="pkgBuildType", choices=['chroot', 'container'], default="chroot")

     parser.add_argument("-F", "--kat-build", dest="katBuild", default=None)

     parser.add_argument("-pj", "--packages-json-input", dest="pkgJsonInput", default=None)

     parser.add_argument("PackageName", nargs='?')
     options = parser.parse_args()

     cmdUtils = CommandUtils()

     if not os.path.isdir(options.logPath):

         cmdUtils.runCommandInShell("mkdir -p " + options.logPath)

     logger = Logger.getLogger("Main", options.logPath, options.logLevel)

     errorFlag = False

     package = None

     pkgInfoJsonFile = options.pkgInfoFile

     if not os.path.isdir(options.sourcePath):

         logger.error("Given Sources Path is not a directory:" + options.sourcePath)

         errorFlag = True
     if not os.path.isdir(options.specPath):

         logger.error("Given Specs Path is not a directory:" + options.specPath)

         errorFlag = True
     if not os.path.isdir(options.publishRPMSPath):

         logger.error("Given RPMS Path is not a directory:" + options.publishRPMSPath)

         errorFlag = True

     if not os.path.isdir(options.publishXRPMSPath):

         logger.error("Given X RPMS Path is not a directory:" + options.publishXRPMSPath)

         errorFlag = True

     if not os.path.isdir(options.publishRPMSPath + "/" + platform.machine()):
         logger.error("Given RPMS Path is missing " + platform.machine()+
                      " sub-directory:"+options.publishRPMSPath)

         errorFlag = True

     if not os.path.isdir(options.publishXRPMSPath+"/" + platform.machine()):

         logger.error("Given X RPMS Path is missing "+platform.machine()+
                      " sub-directory:"+options.publishXRPMSPath)

         errorFlag = True

     if not os.path.isdir(options.publishRPMSPath+"/noarch"):

         logger.error("Given RPMS Path is missing noarch sub-directory:"+
                      options.publishRPMSPath)

         errorFlag = True

     if not os.path.isdir(options.publishXRPMSPath+"/noarch"):

         logger.error("Given X RPMS Path is missing noarch sub-directory:"+
                      options.publishXRPMSPath)

         errorFlag = True

     if options.inputRPMSPath is not None and not os.path.isdir(options.inputRPMSPath):

         logger.error("Given input RPMS Path is not a directory:"+options.inputRPMSPath)

         errorFlag = True

     if options.packageWeightsPath is not None and not os.path.isfile(options.packageWeightsPath):
         logger.error("Given input Weights file is not a file:"+options.packageWeightsPath)
         errorFlag = True
 

     if options.pkgJsonInput is not None and not os.path.isfile(options.pkgJsonInput):
         logger.error("Given input packages file is not a file:"+options.pkgJsonInput)
         errorFlag = True
 

     if options.installPackage:

         if not options.PackageName:

             logger.error("Please provide package name")
             errorFlag = True
         else:

             package = options.PackageName

     if errorFlag:
         logger.error("Found some errors. Please fix input options and re-run it.")
         return False

     if not os.path.isdir(options.rpmPath):

         cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/"+platform.machine())

         cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/noarch")

 
     if not os.path.isdir(options.sourceRpmPath):
         cmdUtils.runCommandInShell("mkdir -p "+options.sourceRpmPath)

     if not os.path.isdir(options.buildRootPath):

         cmdUtils.runCommandInShell("mkdir -p " + options.buildRootPath)

     logger.debug("Source Path :"+options.sourcePath)
     logger.debug("Spec Path :" + options.specPath)
     logger.debug("Rpm Path :" + options.rpmPath)
     logger.debug("Log Path :" + options.logPath)
     logger.debug("Log Level :" + options.logLevel)
     logger.debug("Top Dir Path :" + options.topDirPath)
     logger.debug("Publish RPMS Path :" + options.publishRPMSPath)
     logger.debug("Publish X RPMS Path :" + options.publishXRPMSPath)

     if options.installPackage:

         logger.debug("Package to build:" + package)

     get_packages_with_build_options(options.pkgBuildOptionFile)

     try:

 
         constants.setSpecPath(options.specPath)
         constants.setSourcePath(options.sourcePath)
         constants.setRpmPath(options.rpmPath)
         constants.setSourceRpmPath(options.sourceRpmPath)
         constants.setTopDirPath(options.topDirPath)
         constants.setLogPath(options.logPath)

         constants.setLogLevel(options.logLevel)

         constants.setDist(options.dist)
         constants.setBuildNumber(options.buildNumber)
         constants.setReleaseVersion(options.releaseVersion)
         constants.setPrevPublishRPMRepo(options.publishRPMSPath)
         constants.setPrevPublishXRPMRepo(options.publishXRPMSPath)
         constants.setBuildRootPath(options.buildRootPath)

         constants.setPullSourcesURL(get_baseurl(options.pullsourcesConfig))

         constants.setInputRPMSPath(options.inputRPMSPath)
         constants.setRPMCheck(options.rpmCheck)
         constants.setRpmCheckStopOnError(options.rpmCheckStopOnError)
         constants.setPublishBuildDependencies(options.publishBuildDependencies)
         constants.setPackageWeightsPath(options.packageWeightsPath)
         constants.setKatBuild(options.katBuild)
 
         constants.initialize()

         # parse SPECS folder

         SPECS()

         if options.toolChainStage == "stage1":

             pkgManager = PackageManager()
             pkgManager.buildToolChain()
         elif options.toolChainStage == "stage2":
             pkgManager = PackageManager()

             pkgManager.buildToolChainPackages(options.buildThreads)

         elif options.installPackage:

             buildSpecifiedPackages([package], options.buildThreads, options.pkgBuildType)

         elif options.pkgJsonInput:

             buildPackagesInJson(options.pkgJsonInput, options.buildThreads,
                                 options.pkgBuildType, pkgInfoJsonFile, logger)

         else:

             buildPackagesForAllSpecs(options.buildThreads, options.pkgBuildType,
                                      pkgInfoJsonFile, logger)

     except Exception as e:
         logger.error("Caught an exception")
         logger.error(str(e))

         # print stacktrace
         traceback.print_exc()

         sys.exit(1)
     sys.exit(0)

 def buildSpecifiedPackages(listPackages, buildThreads, pkgBuildType, pkgInfoJsonFile=None, logger=None):

     if constants.rpmCheck:

         constants.setTestForceRPMS(copy.copy(listPackages))

     pkgManager = PackageManager(pkgBuildType=pkgBuildType)
     pkgManager.buildPackages(listPackages, buildThreads)
 
     if pkgInfoJsonFile is not None:
         # Generating package info file which is required by installer
         if logger is not None:
             logger.debug("Writing Package info to the file:" + pkgInfoJsonFile)
         pkgInfo = PackageInfo()
         pkgInfo.loadPackagesData()
         pkgInfo.writePkgListToFile(pkgInfoJsonFile)

 
 def buildPackagesInJson(pkgJsonInput, buildThreads, pkgBuildType, pkgInfoJsonFile, logger):

     listPackages = []
     with open(pkgJsonInput) as jsonData:
         pkg_list_json = json.load(jsonData)
         listPackages = pkg_list_json["packages"]

     buildSpecifiedPackages(listPackages, buildThreads, pkgBuildType, pkgInfoJsonFile, logger)

 def buildPackagesForAllSpecs(buildThreads, pkgBuildType, pkgInfoJsonFile, logger):

     listPackages = SPECS.getData().getListPackages()

     buildSpecifiedPackages(listPackages, buildThreads, pkgBuildType, pkgInfoJsonFile, logger)

 def get_packages_with_build_options(pkg_build_options_file):
     if os.path.exists(pkg_build_options_file):

         with open(pkg_build_options_file) as jsonData:
             pkg_build_option_json = json.load(jsonData, object_pairs_hook=collections.OrderedDict)

             constants.setBuildOptions(pkg_build_option_json)

 def get_baseurl(conf_file):
     with open(conf_file) as jsonFile:
         config = json.load(jsonFile)
     return config['baseurl']
 

 def get_all_package_names(build_install_option):
     base_path = os.path.dirname(build_install_option)
     packages = []
 

     with open(build_install_option) as jsonData:
         option_list_json = json.load(jsonData, object_pairs_hook=collections.OrderedDict)
         options_sorted = option_list_json.items()
 
         for install_option in options_sorted:
             filename = os.path.join(base_path, install_option[1]["file"])
             with open(filename) as pkgJsonData:
                 package_list_json = json.load(pkgJsonData)
             packages = packages + package_list_json["packages"]

 
     return packages
 

 if __name__ == "__main__":

     main()