#!/usr/bin/python
# -*- coding: utf-8 -*-
 
                                                             
                                                                 
                       
                                                   
 

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

                  
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 = "TDS-Source"
    self.svn_fullpath = None

    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(" 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)

                                                                                     
  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 = 'lts15.2.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, svn_fullpath, dest_dir, spec_fullpath ):
                        
    f = open( spec_fullpath, 'r' )
    content = f.read()
    f.close()

                                                                           
    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'

                                     
    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)
    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

                       
    cmake_flags += '-DCMAKE_BUILD_TYPE="%s" ' % self.buildtype

    filename = 'project.%s.cfg' % self.project_name
    cmake_flags += '-DTDS_PROJECT_CONFIG_FILE=%s ' % filename
    
    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 )
    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 )                                   
    if os.path.exists( xzfilename ):                             
      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 )

                           

                              
                              
                                
                                
                                
                               

                                                    


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:], "b:c:f:o:p:r:v:s:",
                              ["base_dir=", "cmake_build_flags=", "cmake_version_prefix=", "filelist=", "output_dir=", "project_name=", "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 ("-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.source_dir_rel = b.repository + "-source"

  svn_destdir = os.path.join( "/tmp", b.source_dir_rel )

  svn_server = "slssvn"
  if svn_path.startswith('svn://'):
    b.svn_fullpath = svn_path
  else:
    b.svn_fullpath = "svn://%s/%s/%s/" % ( svn_server, b.repository, svn_path )

                                       

  b.version_rev = getSvn_Release( b.svn_fullpath )
  b.version_date = getSvn_Date( b.svn_fullpath )
  b.init()
  b.printOptions()

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

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

  b.svn_export( b.svn_fullpath, svn_destdir )
  b.clean_lts_cc_conf(svn_destdir + '/Lts/Projects')
  specname = b.specname( os.path.join( svn_destdir, "specs" ) )
  b.copy_spec( b.svn_fullpath,
               specdir,
               os.path.join( svn_destdir, "specs", specname ) )

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

  b.pack_sources( svn_destdir, os.path.join( rpmbase_dir, "SOURCES" ) )
  removeDirectory( svn_destdir )
  exec_rpmbuild( specdir, specname )

                            
  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()