#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# $Id: make_rpmSVOnly.py 1382 2023-10-09 04:11:49Z fritsche_h $
# $HeadURL: svn://slssvn/admin/rpmbuild/make_rpmSVOnly.py $
# $Author: fritsche_h $
# Created by Christian Ehrlicher, SLSE, 20013-02-19
#

import datetime
import getopt
import os
import shutil
import subprocess
import sys
import time
import ConfigParser
import fnmatch

# helper functions
loc = os.path.dirname( sys.argv[0] )
loc = os.path.abspath( loc )
exec(compile(open('helpers.py').read(), 'helpers.py', 'exec'))

class build(object):
  def __init__( self ):
    self.project_name = 'ctc'
    self.base_dir = os.getcwd()
    self.cmake_build_flags = None 
    self.output_dir = "/shd/CTC/TOOLS/TDS-rpmbuild/"
    self.version_maj = 1
    self.version_min = 1
    self.version_rev = 0
    self.cmake_version_prefix = "TDS"
    self.source_dir_rel = "legatus"
        #self.svn_fullpath = None
    self.build_hla_rpm = "false"
    self.build_sv_rpm = "true"
    self.build_lic_rpm = "false"
    self.build_ws_rpm = "false"
    self.build_bld_rpm = "false"
    self.build_aar_rpm = "false"
    

    self.buildtype = os.getenv( "CMAKE_BUILD_TYPE" )
    if self.buildtype == None or self.buildtype == "":
      self.buildtype = 'RelWithDebInfo'

    self.cmake_generator = 'Unix Makefiles'

  def init( self ):
    self.extfw_dir = "%s/EXTFW-inst/opt/EXTFW" % self.base_dir
    if not os.path.exists( self.extfw_dir ):
      self.extfw_dir = '/opt/EXTFW'
    os.environ["EXTFW"]             = self.extfw_dir
    os.environ["CMAKE_PREFIX_PATH"] = self.extfw_dir

  def printOptions( self ):
    print("Config options")
    print("**************")
    print(" Using base dir:                     %s" % self.base_dir)
    print(" Using extfw dir:                    %s" % self.extfw_dir)
    print(" Using buildtype:                    %s" % self.buildtype)
    print(" Project name:                       %s" % self.project_name)
    print(" Build HLA RPM:                      %s" % self.build_hla_rpm)
    print(" Build SV RPM:                       %s" % self.build_sv_rpm)
    print(" Build Licence RPM:                  %s" % self.build_lic_rpm)
    print(" Build WS RPM:                       %s" % self.build_ws_rpm)
    print(" Build Building RPM:                 %s" % self.build_bld_rpm)
    print(" Build AAR RPM:                      %s" % self.build_aar_rpm)
   # print(" SVN Path:                           %s" % self.svn_fullpath)
    print(" Version:                            %s.%s-%s" % ( self.version_maj, self.version_min, self.version_rev ))
    print(" Jenkins build number:               %s" % os.getenv( "BUILD_NUMBER" ))
    print(" Date:                               %s" % self.version_date)
    print("")
    time.sleep(2)

  # does a svn export, returns True when it's a checkout or False when it's an update
  def svn_export( self, svn_path, dest_dir, svn_revision = "HEAD", svn_user = None, svn_passwd = None ):

    removeDirectory( dest_dir )

    info( "--------------------------------" )
    info( "Exporting %s to %s" % ( svn_path, dest_dir ) )
    info( "--------------------------------" )

    command = "svn export -r %s %s %s" % ( svn_revision, svn_path, dest_dir )
    if svn_user:
      command += "--username %s " % svn_user
    if svn_passwd:
      command += "--password %s " % svn_passwd
    os.system( command ) and die( "while svn export. cmd: %s" % command )

  def version_str( self ):
    return "%s.%s" % ( self.version_maj, self.version_min )

  def xzfilename( self ):
    return self.project_name + '_' + self.repository + '_' + getOS_Name() + '-' + self.version_str() + '.tar.xz'

  def specname( self, specdir ):
    specname = 'ctc_%s_%s.spec' % ( self.repository, self.project_name )
    debug( "specname: %s" % os.path.join( specdir, specname ) )
    if os.path.exists( os.path.join( specdir, specname ) ):
      return specname
    specname = 'ctc_%s.spec' % ( self.repository )
    debug( "specname: %s" % os.path.join( specdir, specname ) )
    if os.path.exists( os.path.join( specdir, specname ) ):
      return specname
    specname = 'ltsHLAOnly.spec'
    debug( "specname: %s" % os.path.join( specdir, specname ) )
    if os.path.exists( os.path.join( specdir, specname ) ):
      return specname
    specname = 'ltsSVOnly.spec'
    debug( "specname: %s" % os.path.join( specdir, specname ) )
    if os.path.exists( os.path.join( specdir, specname ) ):
      return specname
    specname = 'ctc.spec'
    debug( "specname: %s" % os.path.join( specdir, specname ) )
    if os.path.exists( os.path.join( specdir, specname ) ):
      return specname
    specname = '%s.spec' % self.project_name
    debug( "specname: %s" % os.path.join( specdir, specname ) )
    if os.path.exists( os.path.join( specdir, specname ) ):
      return specname
    die( 'Unable to find a valid spec file in %s' % specdir )

  def copy_spec( self, dest_dir, spec_fullpath ):
    # copy spec to build
    f = open( spec_fullpath, 'r' )
    content = f.read()
    f.close()

    # Jenkins Build Tag (wird von Jenkins gesetzt wenn darüber gebaut wird)
    jenkins_build_tag = os.getenv( "BUILD_TAG" )
    if jenkins_build_tag == None or len(jenkins_build_tag) == 0:
      jenkins_build_tag = 'Not build with jenkins job'

    # Versionsinformationen übergeben
    cmake_flags  = ""
    cmake_flags += '-D%s_VERSION_MAJOR:STRING="%s" ' % (self.cmake_version_prefix, self.version_maj)
    cmake_flags += '-D%s_VERSION_MINOR:STRING="%s" ' % (self.cmake_version_prefix, self.version_min)
    cmake_flags += '-D%s_VERSION_REV:STRING="%s" '   % (self.cmake_version_prefix, self.version_rev)
    cmake_flags += '-D%s_VERSION_PATCH:STRING="%s" ' % (self.cmake_version_prefix, self.version_rev)
    cmake_flags += '-D%s_VERSION_DATE:STRING="%s" '  % (self.cmake_version_prefix, self.version_date)
    cmake_flags += '-D_pname:STRING="%s" '           % (self.project_name)

    jenkins_build_number = os.getenv( "BUILD_NUMBER" )
    if jenkins_build_number != None:
      cmake_flags += '-DJENKINS_BUILD_NUMBER:STRING="%s" '% (jenkins_build_number)
    
    if self.cmake_build_flags:
      cmake_flags += ' %s ' % self.cmake_build_flags

    # und den Buildtype
    cmake_flags += '-DCMAKE_BUILD_TYPE="%s" ' % self.buildtype

    filename = 'project.%s.cfg' % self.project_name
    cmake_flags += '-DTDS_PROJECT_CONFIG_FILE=%s ' % filename
   
   ## auto add BuildFlags depending on the modules
    if self.build_sv_rpm == "true":
	   cmake_flags += '-DBUILD_SV=ON ' 
    if self.build_ws_rpm == "true":
	   cmake_flags += '-DBUILD_SV=WS ' 
    if self.build_hla_rpm == "true":
	   cmake_flags += '-DBUILD_HLA=ON -DBUILD_SVC_HLA=ON '
    if self.build_aar_rpm == "true":
	   cmake_flags += '-DBUILD_AAR=ON '	    
    
    content = content.replace( "@PROJECT@", self.project_name )
    content = content.replace( "@OS_SYSTEM@", getOS_Name() )
    content = content.replace( "@PACKAGER@", getpass.getuser() )
    content = content.replace( "@VERSION@", self.version_str() )
    content = content.replace( "@RELEASE@", self.version_rev )
    content = content.replace( "@SOURCE_DIR_REL@", self.source_dir_rel )
    content = content.replace( "@SOURCES@", self.xzfilename() )
    content = content.replace( "@APPLICATION@", self.repository )
    content = content.replace( "@CMAKE_FLAGS@ ", cmake_flags )
    content = content.replace( "@JENKINS_BUILD_TAG@", jenkins_build_tag )
    content = content.replace( "@BUILDSVNRPM@", self.build_sv_rpm )
    content = content.replace( "@BUILDRPMHLA@", self.build_hla_rpm )
    content = content.replace( "@BUILDRPMLIC@", self.build_lic_rpm )
 #   content = content.replace( "@BUILDRPMWS@", self.build_ws_rpm )
 #   content = content.replace( "@BUILDRPMBLD@", self.build_bld_rpm )
 #   content = content.replace( "@BUILDRPMAAR@", self.build_aar_rpm )

  
    if not os.path.exists( dest_dir ):
      os.makedirs( dest_dir )
    f = open( os.path.join( dest_dir, os.path.split( spec_fullpath )[1] ), 'w' )
    f.write( content )
    f.close()

  def clean_lts_cc_conf(self, folder):
    config_files = []
    for root, dirs, files in os.walk(folder):
      for name in files:
        if fnmatch.fnmatch(name, 'lts-cc*conf'):
          config_files.append(os.path.join(root, name))

    for config_file in config_files:
      config = ConfigParser.RawConfigParser()
      config.optionxform = str
      config.read(config_file)

      for section in config.sections():
        if len(config.items(section)) == 0:
          config.remove_section(section)
            
      with open(config_file, 'w') as file:
        config.write(file)

  def pack_sources( self, src_dir, dest_dir ):
    xzfilename = self.xzfilename()
    xzfilename = os.path.join( dest_dir, xzfilename )

    info( "--------------------------------" )
    info( "Packing sources in %s to %s" % ( src_dir, xzfilename ) )
    info( "--------------------------------" )

    removeDirectory( xzfilename )       # falls es ein directory ist
    if os.path.exists( xzfilename ):    # falls es eine datei ist
      os.remove( xzfilename )
    if not os.path.exists( dest_dir ):
      os.makedirs( dest_dir )

    os.chdir( os.path.split( src_dir )[0] )
    cmd = "tar cJf %s %s" % ( xzfilename, os.path.split( src_dir )[1] )
    system( cmd, sys.stdout ) and die( "while packing. cmd: %s" % command )

# svn export ${svn} ${base}

# fixup_rde_header ${base} "c"
# fixup_rde_header ${base} "h"
# fixup_rde_header ${base} "cpp"
# fixup_rde_header ${base} "hpp"
# fixup_rde_header ${base} "txt"
# fixup_rde_header ${base} "py"

# cp ${base}/specs/ctc.spec /usr/src/packages/SPECS/


def usage():
  print >> sys.stdout, "Usage: %s [-b <base_dir> ] -f <filelist> -o <output_dir> -r <repository> -v <version> -s <svn_path>" % sys.argv[0]

def main():
  b = build()

  try:
    opts, args = getopt.getopt(sys.argv[1:], "a:b:w:d:w:t:l:c:h:f:o:p:r:v:s:",
                              ["base_dir=", "build_aar_rpm=", "build_hla_rpm=", "build_ws_rpm=", "build_sv_rpm=", "build_lic_rpm=", "build_bld_rpm=",  "cmake_build_flags=", "cmake_version_prefix=", "filelist=", "output_dir=", "project_name=","build_only_hla=", "repository", "version=", "svn_path="])
  except getopt.GetoptError as err:
    print >> sys.stderr, err
    usage()
    sys.exit(2)

  rpm_filelist = None
  svn_path = "trunk"
  b.repository = "TDS"
  for o, a in opts:
    if o == "--cmake_build_flags":
      b.cmake_build_flags = a
      print("build flags: ", b.cmake_build_flags)
    if o in ("-b", "--base_dir"):
      b.base_dir = a
    if o in ("-f", "--filelist"):
      rpm_filelist = a
    if o in ("-o", "--output_dir"):
      b.output_dir = a
    if o in ("-c", "--cmake_version_prefix"):
      b.cmake_version_prefix = a
    if o in ("-p", "--project_name"):
      b.project_name = a
    if o in ("-h", "--build_hla_rpm"):
      b.build_hla_rpm = a
    if o in ("-w", "--build_ws_rpm"):
      b.build_ws_rpm = a
    if o in ("-t", "--build_sv_rpm"):
      b.build_sv_rpm = a
    if o in ("-l", "--build_lic_rpm"):
      b.build_lic_rpm = a
    if o in ("-d", "--build_bld_rpm"):
      b.build_bld_rpm = a      
    if o in ("-a", "--build_aar_rpm"):
      b.build_aar_rpm = a      
    if o in ("-r", "--repository"):
      b.repository = a
    if o in ("-v", "--version"):
      version = a.split('.')
      try:
        b.version_maj = version[0]
        b.version_min = version[1]
      except:
        die( "Invalid version format (maj.min): %s" % a )
    if o in ("-s", "--svn_path"):
      svn_path = a

 
#  b.check_rpm("ctc_EXTFW_%s" % os_str)

  #b.version_rev = getSvn_Release( b.svn_fullpath )
  b.version_rev = os.getenv( "BUILD_NUMBER" )
 # b.version_date = getSvn_Date( b.svn_fullpath )
  b.version_date = os.getenv( "VERSION_DATE" )
  b.init()
  b.printOptions()

 # rpmbase_dir = os.path.join( os.getenv( "HOME" ), 'rpmbuild' )


  rpmbase_dir = '/shd/CTC/TOOLS/rpmbuild'
 # project_base_dir = '/builds/projects-domain-live/tds'
 # project_base_dir = os.getenv( "PROJECT_BASE_DIR" )
  project_base_dir = os.getenv( "WORKSPACE" )
  
  specdir = os.path.join( rpmbase_dir, "SPECS" )


  #specdir = os.path.join( rpmbase_dir, "SPECS" )
  if not os.path.exists(specdir):
    os.makedirs(specdir)

  b.clean_lts_cc_conf(os.path.join(project_base_dir, 'legatus', 'Lts', 'Projects'))
  specname = b.specname(os.path.join(project_base_dir,'legatus', 'specs'))
  b.copy_spec( specdir, os.path.join(project_base_dir, 'legatus', "specs", specname ))
  

  full_version = "%s.%s-%s" % ( b.version_maj, b.version_min, b.version_rev )
  b.printOptions()

  b.pack_sources( os.path.join(project_base_dir, 'legatus'), os.path.join( rpmbase_dir, "SOURCES" ) )
  exec_rpmbuild( specdir, specname )

  # move rpms to FOO-1.2-345
  dstdir = os.path.join( b.output_dir, "%s-%s-%s" % ( b.project_name, b.repository, full_version ) )
  filter = re.compile( "^.*%s\..*\.rpm$" % full_version )
  moved_files = moveFilesToDir( rpmbase_dir,
                                dstdir,
                                filter,
                                True
                                )

  if rpm_filelist != None:
    try:
      f = open( rpm_filelist, 'w' )
      for m in moved_files:
        f.write( '%s\n' % m )
      f.close()
    except:
     die( 'Error creating fileslist %s' % rpm_filelist )

if __name__ == "__main__":
  main()