# vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:

import os, sys

class SDK(object):

  def __init__(self, sdk, ext, aDef, name, platform, dir):

    if dir == 'ep1':

      folder = 'hl2sdk'

    else:

      folder = 'hl2sdk-' + dir

    self.envvar = sdk

    self.ext = ext

    self.code = aDef

    self.define = name

    self.platform = platform

    self.folder = folder # Default folder name.

    self.name = dir

    self.path = None # Actual path

WinOnly = ['windows']

WinLinux = ['windows', 'linux']

WinLinuxMac = ['windows', 'linux', 'mac']

PossibleSDKs = {

  'ep1':  SDK('HL2SDK', '1.ep1', '1', 'EPISODEONE', WinLinux, 'ep1'),

  'ep2':  SDK('HL2SDKOB', '2.ep2', '3', 'ORANGEBOX', WinLinux, 'ob'),

  'css':  SDK('HL2SDKCSS', '2.css', '6', 'CSS', WinLinuxMac, 'css'),

  'hl2dm':  SDK('HL2SDKHL2DM', '2.hl2dm', '7', 'HL2DM', WinLinuxMac, 'hl2dm'),

  'dods': SDK('HL2SDKDODS', '2.dods', '8', 'DODS', WinLinuxMac, 'dods'),

  'sdk2013': SDK('HL2SDK2013', '2.sdk2013', '9', 'SDK2013', WinLinuxMac, '2013'),

  'tf2':  SDK('HL2SDKTF2', '2.tf2', '10', 'TF2', WinLinuxMac, 'tf2'),

  'l4d':  SDK('HL2SDKL4D', '2.l4d', '11', 'LEFT4DEAD', WinLinuxMac, 'l4d'),

  'nd': SDK('HL2SDKND', '2.nd', '12', 'NUCLEARDAWN', WinLinuxMac, 'nd'),

  'l4d2': SDK('HL2SDKL4D2', '2.l4d2', '13', 'LEFT4DEAD2', WinLinuxMac, 'l4d2'),

  'darkm':  SDK('HL2SDK-DARKM', '2.darkm', '2', 'DARKMESSIAH', WinOnly, 'darkm'),

  'swarm':  SDK('HL2SDK-SWARM', '2.swarm', '14', 'ALIENSWARM', WinOnly, 'swarm'),

  'bgt':  SDK('HL2SDK-BGT', '2.bgt', '4', 'BLOODYGOODTIME', WinOnly, 'bgt'),

  'eye':  SDK('HL2SDK-EYE', '2.eye', '5', 'EYE', WinOnly, 'eye'),

  'csgo': SDK('HL2SDKCSGO', '2.csgo', '18', 'CSGO', WinLinuxMac, 'csgo'),

  'dota': SDK('HL2SDKDOTA', '2.dota', '19', 'DOTA', WinOnly, 'dota'),

  'portal2':  SDK('HL2SDKPORTAL2', '2.portal2', '15', 'PORTAL2', [], 'portal2'),

  'blade':  SDK('HL2SDKBLADE', '2.blade', '16', 'BLADE', WinLinux, 'blade'),

  'insurgency':  SDK('HL2SDKINSURGENCY', '2.insurgency', '17', 'INSURGENCY', WinLinuxMac, 'insurgency'),

}

def ResolveEnvPath(env, folder):

  if env in os.environ:

    path = os.environ[env]

    if os.path.isdir(path):

      return path

  else:

    head = os.getcwd()

    oldhead = None

    while head != None and head != oldhead:

      path = os.path.join(head, folder)

      if os.path.isdir(path):

        return path

      oldhead = head

      head, tail = os.path.split(head)

  return None

class SMConfig(object):

  def __init__(self):

    self.sdks = {}

    self.binaries = []

    self.extensions = []

    self.generated_headers = None

    self.mms_root = None

    self.mysql_root = None

    self.spcomp = None

    self.smx_files = {}

    self.versionlib = None

  def detectProductVersion(self):

    builder.AddConfigureFile('product.version')

    # For OS X dylib versioning

    import re

    with open(os.path.join(builder.sourcePath, 'product.version'), 'r') as fp:

      productContents = fp.read()

    m = re.match('(\d+)\.(\d+)\.(\d+).*', productContents)

    if m == None:

      self.productVersion = '1.0.0'

    else:

      major, minor, release = m.groups()

      self.productVersion = '{0}.{1}.{2}'.format(major, minor, release)

  def detectSDKs(self):

    sdk_list = builder.options.sdks.split(',')

    use_all = sdk_list[0] == 'all'

    use_present = sdk_list[0] == 'present'

    for sdk_name in PossibleSDKs:

      sdk = PossibleSDKs[sdk_name]

      if builder.target_platform in sdk.platform:

        sdk_path = ResolveEnvPath(sdk.envvar, sdk.folder)

        if sdk_path is None:

          if use_all or sdk_name in sdk_list:

            raise Exception('Could not find a valid path for {0}'.format(sdk.envvar))

          continue

        if use_all or use_present or sdk_name in sdk_list:

          sdk.path = sdk_path

          self.sdks[sdk_name] = sdk

    if len(self.sdks) < 1:

      raise Exception('At least one SDK must be available.')

    self.mms_root = ResolveEnvPath('MMSOURCE110', 'mmsource-1.10')

    if not self.mms_root:

      self.mms_root = ResolveEnvPath('MMSOURCE_DEV', 'mmsource-central')

      if not self.mms_root:

        raise Exception('Could not find a source copy of Metamod:Source')

    if builder.options.hasMySql:

      for i in range(7):

        self.mysql_root = ResolveEnvPath('MYSQL5', 'mysql-5.' + str(i))

        if self.mysql_root:

          break

      if not self.mysql_root:

        raise Exception('Could not find a path to MySQL!')

  def configure(self):

    builder.AddConfigureFile('pushbuild.txt')

    cfg = builder.DetectCompilers()

    cxx = cfg.cxx

    if cxx.behavior is 'gcc':

      cfg.defines += [

        'stricmp=strcasecmp',

        '_stricmp=strcasecmp',

        '_snprintf=snprintf',

        '_vsnprintf=vsnprintf',

        'HAVE_STDINT_H',

        'GNUC',

      ]

      cfg.cflags += [

        '-pipe',

        '-fno-strict-aliasing',

        '-Wall',

        '-Werror',

        '-Wno-uninitialized',

        '-Wno-unused',

        '-Wno-switch',

        '-msse',

        '-m32',

      ]

      have_gcc = cxx.name is 'gcc'

      have_clang = cxx.name is 'clang'

      if have_clang or (have_gcc and cxx.majorVersion >= 4):

        cfg.cflags += ['-fvisibility=hidden']

        cfg.cxxflags += ['-fvisibility-inlines-hidden']

        if have_clang or (have_gcc and cxx.minorVersion >= 6):

          cfg.cflags += ['-Wno-narrowing']

        if (have_gcc and cxx.minorVersion >= 7) or (have_clang and cxx.majorVersion >= 4):

          cfg.cxxflags += ['-Wno-delete-non-virtual-dtor']

      cfg.linkflags += ['-m32']

      cfg.cxxflags += [

        '-fno-exceptions',

        '-fno-threadsafe-statics',

        '-Wno-non-virtual-dtor',

        '-Wno-overloaded-virtual',

      ]

      if have_gcc:

        cfg.cflags += ['-mfpmath=sse']

    elif cxx.name == 'msvc':

      if builder.options.debug == '1':

        cfg.cflags += ['/MTd']

        cfg.linkflags += ['/NODEFAULTLIB:libcmt']

      else:

        cfg.cflags += ['/MT']

      cfg.defines += [

        '_CRT_SECURE_NO_DEPRECATE',

        '_CRT_SECURE_NO_WARNINGS',

        '_CRT_NONSTDC_NO_DEPRECATE',

        '_ITERATOR_DEBUG_LEVEL=0',

      ]

      cfg.cflags += [

        '/W3',

      ]

      cfg.cxxflags += [

        '/EHsc',

        '/GR-',

        '/TP',

      ]

      cfg.linkflags += [

        '/MACHINE:X86',

        '/SUBSYSTEM:WINDOWS',

        'kernel32.lib',

        'user32.lib',

        'gdi32.lib',

        'winspool.lib',

        'comdlg32.lib',

        'advapi32.lib',

        'shell32.lib',

        'ole32.lib',

        'oleaut32.lib',

        'uuid.lib',

        'odbc32.lib',

        'odbccp32.lib',

      ] 

    # Optimization

    if builder.options.opt == '1':

      cfg.defines += ['NDEBUG']

      if cxx.behavior == 'gcc':

        cfg.cflags += ['-O3']

      elif cxx.behavior == 'msvc':

        cfg.cflags += ['/Ox']

        cfg.linkflags += ['/OPT:ICF', '/OPT:REF']

    # Debugging

    if builder.options.debug == '1':

      cfg.defines += ['DEBUG', '_DEBUG']

      if cxx.behavior == 'msvc':

        cfg.cflags += ['/Od', '/RTC1']

    # This needs to be after our optimization flags which could otherwise disable it.

    if cxx.name == 'msvc':

      # Don't omit the frame pointer.

      cfg.cflags += ['/Oy-']

    # Platform-specifics

    if builder.target_platform == 'linux':

      cfg.defines += ['_LINUX', 'POSIX']

      if cxx.name == 'gcc':

        cfg.linkflags += ['-static-libgcc']

      elif cxx.name == 'clang':

        cfg.linkflags += ['-lgcc_eh']

    elif builder.target_platform == 'mac':

      cfg.defines += ['OSX', '_OSX', 'POSIX']

      cfg.linkflags += [

        '-mmacosx-version-min=10.5',

        '-arch', 'i386',

        '-lstdc++',

        '-stdlib=libstdc++',

      ]

      cfg.cxxflags += ['-stdlib=libstdc++']

    elif builder.target_platform == 'windows':

      cfg.defines += ['WIN32', '_WINDOWS']

    # Finish up.

    cfg.defines += [

      'SOURCEMOD_BUILD',

      'SM_GENERATED_BUILD',

      'SM_USE_VERSIONLIB',

    ]

    cfg.includes += [os.path.join(builder.buildPath, 'includes')]

    cfg.includes += [os.path.join(builder.sourcePath, 'versionlib')]

  def LibraryBuilder(self, compiler, name):

    binary = compiler.Library(name)

    if builder.target_platform == 'windows':

      binary.sources += ['version.rc']

      binary.compiler.rcdefines += [

        'BINARY_NAME="{0}"'.format(binary.outputFile),

        'SM_GENERATED_BUILD',

        'RC_COMPILE',

      ]

    elif builder.target_platform == 'mac':

      binary.compiler.postlink += [

        '-compatibility_version', '1.0.0',

        '-current_version', self.productVersion

      ]

    binary.compiler.linkflags += [self.versionlib]

    binary.compiler.sourcedeps += SM.generated_headers

    return binary

  def ProgramBuilder(self, compiler, name):

    binary = compiler.Program(name)

    if builder.target_platform == 'windows':

      binary.sources += ['version.rc']

      binary.compiler.rcdefines += [

        'BINARY_NAME="{0}"'.format(binary.outputFile),

        'SM_GENERATED_BUILD',

        'RC_COMPILE',

      ]

    binary.compiler.linkflags += [self.versionlib]

    binary.compiler.sourcedeps += SM.generated_headers

    return binary

  def Library(self, context, name):

    compiler = context.compiler.clone()

    return self.LibraryBuilder(compiler, name)

  def Program(self, context, name):

    compiler = context.compiler.clone()

    return self.ProgramBuilder(compiler, name)

  def ExtCompiler(self, context):

    compiler = context.compiler.clone()

    compiler.cxxincludes += [

      os.path.join(context.currentSourcePath),

      os.path.join(context.currentSourcePath, 'sdk'),

      os.path.join(builder.sourcePath, 'public'),

      os.path.join(builder.sourcePath, 'public', 'extensions'),

      os.path.join(builder.sourcePath, 'public', 'sourcepawn'),

      os.path.join(builder.sourcePath, 'public', 'amtl'),

    ]

    return compiler

  def HL2Compiler(self, context, sdk):

    compiler = self.ExtCompiler(context)

    if sdk.name == 'ep1':

      mms_path = os.path.join(self.mms_root, 'core-legacy')

    else:

      mms_path = os.path.join(self.mms_root, 'core')

    compiler.cxxincludes += [

      os.path.join(mms_path),

      os.path.join(mms_path, 'sourcehook'),

    ]

    defines = ['SE_' + PossibleSDKs[i].define + '=' + PossibleSDKs[i].code for i in PossibleSDKs]

    compiler.defines += defines

    paths = [

      ['public'],

      ['public', 'engine'],

      ['public', 'mathlib'],

      ['public', 'vstdlib'],

      ['public', 'tier0'],

      ['public', 'tier1']

    ]

    if sdk.name == 'ep1' or sdk.name == 'darkm':

      paths.append(['public', 'dlls'])

      paths.append(['game_shared'])

    else:

      paths.append(['public', 'game', 'server'])

      paths.append(['public', 'toolframework'])

      paths.append(['game', 'shared'])

      paths.append(['common'])

    compiler.defines += ['SOURCE_ENGINE=' + sdk.code]

    if sdk.name == '2013' and compiler.cxx.behavior == 'gcc':

      # The 2013 SDK already has these in public/tier0/basetypes.h

      compiler.defines.remove('stricmp=strcasecmp')

      compiler.defines.remove('_stricmp=strcasecmp')

      compiler.defines.remove('_snprintf=snprintf')

      compiler.defines.remove('_vsnprintf=vsnprintf')

    if sdk.name in ['swarm', 'blade', 'insurgency', 'csgo', 'dota']:

      if compiler.cc.behavior == 'msvc':

        compiler.defines += ['COMPILER_MSVC', 'COMPILER_MSVC32']

      else:

        compiler.defines += ['COMPILER_GCC']

    if sdk.name in ['css', 'hl2dm', 'dods', '2013', 'tf2', 'l4d2']:

      if builder.target_platform in ['linux', 'mac']:

        compiler.defines += ['NO_MALLOC_OVERRIDE']

    for path in paths:

      compiler.cxxincludes += [os.path.join(sdk.path, *path)]

    return compiler

  def ExtLibrary(self, context, name):

    compiler = self.ExtCompiler(context)

    return self.LibraryBuilder(compiler, name)

  def HL2Library(self, context, name, sdk):

    compiler = self.HL2Compiler(context, sdk)

    if builder.target_platform is 'linux':

      if sdk.name is 'ep1':

        lib_folder = os.path.join(sdk.path, 'linux_sdk')

      elif sdk.name is '2013':

        lib_folder = os.path.join(sdk.path, 'lib', 'public', 'linux32')

      else:

        lib_folder = os.path.join(sdk.path, 'lib', 'linux')

    elif builder.target_platform == 'mac':

      if sdk.name is '2013':

        lib_folder = os.path.join(sdk.path, 'lib', 'public', 'osx32')

      else:

        lib_folder = os.path.join(sdk.path, 'lib', 'mac')

    if builder.target_platform in ['linux', 'mac']:

      if sdk.name is '2013':

        compiler.postlink += [

          compiler.Dep(os.path.join(lib_folder, 'tier1.a')),

          compiler.Dep(os.path.join(lib_folder, 'mathlib.a'))

        ]

      else:

        compiler.postlink += [

          compiler.Dep(os.path.join(lib_folder, 'tier1_i486.a')),

          compiler.Dep(os.path.join(lib_folder, 'mathlib_i486.a'))

        ]

      if sdk.name in ['blade', 'insurgency', 'csgo', 'dota']:

        compiler.postlink += [compiler.Dep(os.path.join(lib_folder, 'interfaces_i486.a'))]

    binary = self.LibraryBuilder(compiler, name)

    dynamic_libs = []

    if builder.target_platform == 'linux':

      compiler.linkflags[0:0] = ['-lm']

      if sdk.name in ['css', 'hl2dm', 'dods', 'tf2', '2013', 'l4d2']:

        dynamic_libs = ['libtier0_srv.so', 'libvstdlib_srv.so']

      elif sdk.name in ['l4d', 'nd', 'blade', 'insurgency', 'csgo']:

        dynamic_libs = ['libtier0.so', 'libvstdlib.so']

      else:

        dynamic_libs = ['tier0_i486.so', 'vstdlib_i486.so']

    elif builder.target_platform == 'mac':

      binary.compiler.linkflags.append('-liconv')

      dynamic_libs = ['libtier0.dylib', 'libvstdlib.dylib']

    elif builder.target_platform == 'windows':

      libs = ['tier0', 'tier1', 'vstdlib', 'mathlib']

      if sdk.name in ['swarm', 'blade', 'insurgency', 'csgo', 'dota']:

        libs.append('interfaces')

      for lib in libs:

        lib_path = os.path.join(sdk.path, 'lib', 'public', lib) + '.lib'

        binary.compiler.linkflags.append(binary.Dep(lib_path))

    for library in dynamic_libs:

      source_path = os.path.join(lib_folder, library)

      output_path = os.path.join(binary.localFolder, library)

      def make_linker(source_path, output_path):

        def link(context, binary):

          cmd_node, (output,) = context.AddSymlink(source_path, output_path)

          return output

        return link

      linker = make_linker(source_path, output_path)

      binary.compiler.linkflags[0:0] = [binary.Dep(library, linker)]

    return binary

SM = SMConfig()

SM.detectProductVersion()

SM.detectSDKs()

SM.configure()

SM.generated_headers = builder.RunScript(

  'tools/buildbot/Versioning',

  { 'SM': SM }

)

SM.versionlib = builder.RunScript(

  'versionlib/AMBuilder',

  { 'SM': SM }

)

builder.RunBuildScripts(

  [

    'loader/AMBuilder',

    'core/AMBuilder',

    'core/logic/AMBuilder',

    'extensions/bintools/AMBuilder',

    'extensions/clientprefs/AMBuilder',

    'extensions/curl/AMBuilder',

    'extensions/cstrike/AMBuilder',

    'extensions/geoip/AMBuilder',

    'extensions/mysql/AMBuilder',

    'extensions/regex/AMBuilder',

    'extensions/sdkhooks/AMBuilder',

    'extensions/sdktools/AMBuilder',

    'extensions/sqlite/AMBuilder',

    'extensions/tf2/AMBuilder',

    'extensions/topmenus/AMBuilder',

    'extensions/updater/AMBuilder',

    'sourcepawn/compiler/AMBuilder',

    'sourcepawn/jit/AMBuilder',

    'plugins/AMBuilder',

    'tools/buildbot/PackageScript',

  ],

  {

    'SM': SM

  }

)

if builder.options.breakpad_dump:

  builder.RunScript('tools/buildbot/BreakpadSymbols', { 'SM': SM })