#!/usr/bin/env python

"""Ninja toolchain abstraction for Microsoft compiler suite"""

import os
import subprocess

import toolchain
import vslocate

class MSVCToolchain(toolchain.Toolchain):

  def initialize(self, project, archs, configs, includepaths, dependlibs, libpaths, variables, subninja):
    #Local variable defaults
    self.sdkpath = ''
    self.toolchain = ''
    self.includepaths = []
    self.libpaths = libpaths
    self.ccompiler = 'cl'
    self.cxxcompiler = 'cl'
    self.archiver = 'lib'
    self.linker = 'link'
    self.dller = 'dll'

    #Command definitions (to generate assembly, add "/FAs /Fa$out.asm")
    self.cccmd = '$toolchain$cc /showIncludes /I. $includepaths $moreincludepaths $cflags $carchflags $cconfigflags $cmoreflags /c $in /Fo$out /Fd$pdbpath /FS /nologo'
    self.cxxcmd = '$toolchain$cxx /showIncludes /I. $includepaths $moreincludepaths $cxxflags $carchflags $cconfigflags $cmoreflags /c $in /Fo$out /Fd$pdbpath /FS /nologo'
    self.ccdepfile = None
    self.ccdeps = 'msvc'
    self.arcmd = '$toolchain$ar $arflags $ararchflags $arconfigflags /NOLOGO /OUT:$out $in'
    self.linkcmd = '$toolchain$link $libpaths $configlibpaths $linkflags $linkarchflags $linkconfigflags /DEBUG /NOLOGO /SUBSYSTEM:CONSOLE /DYNAMICBASE /NXCOMPAT /MANIFEST /MANIFESTUAC:\"level=\'asInvoker\' uiAccess=\'false\'\" /TLBID:1 /PDB:$pdbpath /OUT:$out $in $libs $archlibs $oslibs'
    self.dllcmd = self.linkcmd + ' /DLL'

    self.cflags = ['/D', '"' + project.upper() + '_COMPILE=1"', '/D', '"_UNICODE"',  '/D', '"UNICODE"', '/std:c17', '/Zi', '/Oi', '/Oy-', '/GS-', '/Gy-', '/Qpar-', '/fp:fast', '/fp:except-', '/Zc:forScope', '/Zc:wchar_t', '/GR-', '/openmp-']
    self.cwarnflags = ['/W4', '/WX', '/wd4201'] #Ignore nameless union/struct which is allowed in C11
    self.cmoreflags = []
    self.arflags = ['/ignore:4221'] #Ignore empty object file warning]
    self.linkflags = ['/DEBUG']
    self.oslibs = ['kernel32', 'user32', 'shell32', 'advapi32']

    self.initialize_subninja(subninja)
    self.initialize_archs(archs)
    self.initialize_configs(configs)
    self.initialize_project(project)
    self.initialize_toolchain()
    self.initialize_depends(dependlibs)

    self.parse_default_variables(variables)
    self.read_build_prefs()

    self.includepaths = self.prefix_includepaths((includepaths or []) + ['.'])

    if self.is_monolithic():
      self.cflags += ['/D', '"BUILD_MONOLITHIC=1"']

    if not 'nowarning' in variables or not variables['nowarning']:
      self.cflags += self.cwarnflags
    self.cxxflags = list(self.cflags)

    #Overrides
    self.objext = '.obj'

    #Builders
    self.builders['c'] = self.builder_cc
    self.builders['cc'] = self.builder_cxx
    self.builders['cpp'] = self.builder_cxx
    self.builders['lib'] = self.builder_lib
    self.builders['multilib'] = self.builder_multicopy
    self.builders['sharedlib'] = self.builder_sharedlib
    self.builders['multisharedlib'] = self.builder_multicopy
    self.builders['bin'] = self.builder_bin
    self.builders['multibin'] = self.builder_multicopy

    #Setup toolchain
    self.build_toolchain()

  def name(self):
    return 'msvc'

  def parse_prefs(self, prefs):
    super(MSVCToolchain, self).parse_prefs(prefs)
    if 'msvc' in prefs:
      msvcprefs = prefs['msvc']
      if 'sdkpath' in msvcprefs:
        self.sdkpath = msvcprefs['sdkpath']
      if 'toolchain' in msvcprefs:
        self.toolchain = msvcprefs['toolchain']
      if 'toolchain_version' in msvcprefs:
        self.toolchain_version = msvcprefs['toolchain_version']

  def write_variables(self, writer):
    super(MSVCToolchain, self).write_variables(writer)
    writer.variable('cc', self.ccompiler)
    writer.variable('cxx', self.cxxcompiler)
    writer.variable('ar', self.archiver)
    writer.variable('link', self.linker)
    writer.variable('dll', self.dller)
    writer.variable('toolchain', self.toolchain)
    writer.variable('includepaths', self.make_includepaths(self.includepaths))
    writer.variable('moreincludepaths', '')
    writer.variable('pdbpath', 'ninja.pdb')
    writer.variable('cflags', self.cflags)
    writer.variable('carchflags', '')
    writer.variable('cconfigflags', '')
    writer.variable('cxxflags', self.cxxflags)
    writer.variable('cmoreflags', self.cmoreflags)
    writer.variable('arflags', self.arflags)
    writer.variable('ararchflags', '')
    writer.variable('arconfigflags', '')
    writer.variable('linkflags', self.linkflags)
    writer.variable('linkarchflags', '')
    writer.variable('linkconfigflags', '')
    writer.variable('libs', '')
    writer.variable('libpaths', self.make_libpaths(self.libpaths))
    writer.variable('configlibpaths', '')
    writer.variable('archlibs', '')
    writer.variable('oslibs', self.make_libs(self.oslibs))
    writer.newline()

  def write_rules(self, writer):
    super(MSVCToolchain, self).write_rules(writer)
    writer.rule('cc', command = self.cccmd, depfile = self.ccdepfile, deps = self.ccdeps, description = 'CC $in')
    writer.rule('cxx', command = self.cxxcmd, depfile = self.ccdepfile, deps = self.ccdeps, description = 'CXX $in')
    writer.rule('ar', command = self.arcmd, description = 'LIB $out')
    writer.rule('link', command = self.linkcmd, description = 'LINK $out')
    writer.rule('dll', command = self.dllcmd, description = 'DLL $out')
    writer.newline()

  def build_toolchain(self):
    if self.toolchain == '':
      installed_versions = vslocate.get_vs_installations()
      for versionstr, installpath in installed_versions:
        major_version = versionstr.split('.')[0]
        if int(major_version) >= 15:
          tools_basepath = os.path.join(installpath, 'VC', 'Tools', 'MSVC')
          tools_list = [item for item in os.listdir(tools_basepath) if os.path.isdir(os.path.join(tools_basepath, item))]
          from distutils.version import StrictVersion
          tools_list.sort(key=StrictVersion)
          self.toolchain = os.path.join(tools_basepath, tools_list[-1])
          self.toolchain_version = major_version + ".0"
          break

      if self.toolchain == '':
        toolchain = ''
        versions = ['17.0', '16.0', '15.0']
        keys = [
          'HKLM\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VC7',
          'HKCU\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VC7',
          'HKLM\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7',
          'HKCU\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7',
          'HKLM\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VC7',
          'HKCU\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VC7',
          'HKLM\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VS7',
          'HKCU\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VS7'
        ]
        for version in versions:
          for key in keys:
            try:
              query = subprocess.check_output(['reg', 'query', key, '/v', version ], stderr = subprocess.STDOUT).strip().splitlines()
              if len(query) == 2:
                toolchain = str(query[1]).split('REG_SZ')[-1].strip(" '\"\n\r\t")
            except:
              continue
            if not toolchain == '':
              tools_basepath = os.path.join(toolchain, 'VC', 'Tools', 'MSVC')
              tools_list = [item for item in os.listdir(tools_basepath) if os.path.isdir(os.path.join(tools_basepath, item))]
              from distutils.version import StrictVersion
              tools_list.sort(key=StrictVersion)
              toolchain = os.path.join(tools_basepath, tools_list[-1])
              self.toolchain = toolchain
              self.toolchain_version = version
              break
          if not self.toolchain == '':
            break
    if self.toolchain == '':
      raise Exception("Unable to locate any installed Visual Studio toolchain")
    self.includepaths += [os.path.join(self.toolchain, 'include')]
    if self.sdkpath == '':
      versions = ['v10.0', 'v8.1']
      keys = [
        'HKLM\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows',
        'HKCU\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows',
        'HKLM\\SOFTWARE\\Wow6432Node\\Microsoft\\Microsoft SDKs\\Windows',
        'HKCU\\SOFTWARE\\Wow6432Node\\Microsoft\\Microsoft SDKs\\Windows'
      ]
      include_path = 'include'
      for version in versions:
        for key in keys:
          sdkpath = ''
          try:
            query = subprocess.check_output(['reg', 'query', key + '\\' + version, '/v', 'InstallationFolder'], stderr = subprocess.STDOUT).strip().splitlines()
            if len(query) == 2:
              sdkpath = str(query[1]).split('REG_SZ')[-1].strip(" '\"\n\r\t")
              if not sdkpath == '' and version == 'v10.0':
                base_path = sdkpath
                sdkpath = ''
                query = subprocess.check_output(['reg', 'query', key + '\\' + version, '/v', 'ProductVersion'], stderr = subprocess.STDOUT).strip().splitlines()
                if len(query) == 2:
                  version_path = str(query[1]).split('REG_SZ')[-1].strip(" '\"\n\r\t")
                  if not version_path == '':
                    sdkpath = base_path
                    self.sdkversionpath = version_path
                    versioned_include_path = os.path.join(include_path, self.sdkversionpath)
                    if not os.path.exists(os.path.join(sdkpath, versioned_include_path)) and os.path.exists(os.path.join(sdkpath, versioned_include_path + '.0')):
                      self.sdkversionpath = self.sdkversionpath + '.0'
                      versioned_include_path = os.path.join(include_path, self.sdkversionpath)
                    include_path = versioned_include_path
          except subprocess.CalledProcessError as e:
            continue
          if not sdkpath == '':
            self.includepaths += [
              os.path.join(sdkpath, include_path, 'shared'),
              os.path.join(sdkpath, include_path, 'um'),
              os.path.join(sdkpath, include_path, 'winrt')
            ]
            if version == 'v10.0':
              self.includepaths += [
                os.path.join(sdkpath, include_path, 'ucrt')
              ]
            self.sdkpath = sdkpath
            self.sdkversion = version
            break
        if not sdkpath == '':
          break
    if self.toolchain != '' and not self.toolchain.endswith('/') and not self.toolchain.endswith('\\'):
      self.toolchain += os.sep

  def make_includepaths(self, includepaths):
    if not includepaths is None:
      return ['/I' + self.path_escape(path) for path in list(includepaths)]
    return []

  def make_libpath(self, path):
    return self.path_escape(path)

  def make_libpaths(self, libpaths):
    if not libpaths is None:
      return ['/LIBPATH:' + self.make_libpath(path) for path in libpaths]
    return []

  def make_arch_toolchain_path(self, arch):
    if arch == 'x86-64':
      return os.path.join(self.toolchain, 'bin', 'HostX64', 'x64\\')
    elif arch == 'x86':
      return os.path.join(self.toolchain, 'bin', 'HostX64', 'x86\\')
    return os.path.join(self.toolchain, 'bin\\')

  def make_carchflags(self, arch, targettype):
    flags = []
    if targettype == 'sharedlib':
      flags += ['/MD', '/D', '"BUILD_DYNAMIC_LINK=1"']
    else:
      flags += ['/MT']
    if arch == 'x86':
      flags += ['/arch:SSE2']
    elif arch == 'x86-64':
      pass
    return flags

  def make_cconfigflags(self, config, targettype):
    flags = ['/Gm-']
    if config == 'debug':
      flags += ['/Od', '/D', '"BUILD_DEBUG=1"', '/GF-']
    else:
      flags += ['/Ob2', '/Ot', '/GT', '/GL', '/GF']
      if config == 'release':
        flags += ['/O2', '/D' '"BUILD_RELEASE=1"']
      elif config == 'profile':
        flags += ['/Ox', '/D', '"BUILD_PROFILE=1"']
      elif config == 'deploy':
        flags += ['/Ox', '/D', '"BUILD_DEPLOY=1"']
    return flags

  def make_ararchflags(self, arch, targettype):
    flags = []
    if arch == 'x86':
      flags += ['/MACHINE:X86']
    elif arch == 'x86-64':
      flags += ['/MACHINE:X64']
    return flags

  def make_arconfigflags(self, config, targettype):
    flags = []
    if config != 'debug':
      flags += ['/LTCG']
    return flags

  def make_linkarchflags(self, arch, targettype):
    flags = []
    if arch == 'x86':
      flags += ['/MACHINE:X86']
    elif arch == 'x86-64':
      flags += ['/MACHINE:X64']
    return flags

  def make_linkconfigflags(self, config, targettype):
    flags = []
    if config == 'debug':
      flags += ['/INCREMENTAL']
    else:
      flags += ['/LTCG', '/INCREMENTAL:NO', '/OPT:REF', '/OPT:ICF']
    return flags

  def make_libs(self, libs):
    if libs != None:
      return [lib + '.lib' for lib in libs]
    return []

  def make_configlibpaths(self, config, arch, extralibpaths):
    libpaths = [
      self.libpath,
      os.path.join(self.libpath, arch),
      os.path.join(self.libpath, config),
      os.path.join(self.libpath, config, arch)
      ]
    if extralibpaths != None:
      libpaths += [os.path.join(libpath, self.libpath) for libpath in extralibpaths]
      libpaths += [os.path.join(libpath, self.libpath, arch) for libpath in extralibpaths]
      libpaths += [os.path.join(libpath, self.libpath, config) for libpath in extralibpaths]
      libpaths += [os.path.join(libpath, self.libpath, config, arch) for libpath in extralibpaths]
    if self.sdkpath != '':
      if arch == 'x86':
        libpaths += [os.path.join(self.toolchain, 'lib', 'x86')]
        if self.sdkversion == 'v8.1':
          libpaths += [os.path.join( self.sdkpath, 'lib', 'winv6.3', 'um', 'x86')]
        if self.sdkversion == 'v10.0':
          libpaths += [os.path.join(self.sdkpath, 'lib', self.sdkversionpath, 'um', 'x86')]
          libpaths += [os.path.join(self.sdkpath, 'lib', self.sdkversionpath, 'ucrt', 'x86')]
      else:
        libpaths += [os.path.join( self.toolchain, 'lib', 'x64')]
        if self.sdkversion == 'v8.1':
          libpaths += [os.path.join( self.sdkpath, 'lib', 'winv6.3', 'um', 'x64')]
        if self.sdkversion == 'v10.0':
          libpaths += [os.path.join( self.sdkpath, 'lib', self.sdkversionpath, 'um', 'x64')]
          libpaths += [os.path.join( self.sdkpath, 'lib', self.sdkversionpath, 'ucrt', 'x64')]
    return self.make_libpaths(libpaths)

  def cc_variables(self, config, arch, targettype, variables):
    localvariables = [('toolchain', self.make_arch_toolchain_path(arch))]
    if 'includepaths' in variables:
      moreincludepaths = self.make_includepaths(variables['includepaths'])
      if not moreincludepaths == []:
        localvariables += [('moreincludepaths', moreincludepaths)]
    if 'modulepath' in variables:
      localvariables += [('pdbpath', os.path.join(variables['modulepath'], 'ninja.pdb'))]
    carchflags = self.make_carchflags(arch, targettype)
    if carchflags != []:
      localvariables += [('carchflags', carchflags)]
    cconfigflags = self.make_cconfigflags(config, targettype)
    if cconfigflags != []:
      localvariables += [('cconfigflags', cconfigflags)]
    if 'defines' in variables:
      definelist = []
      for define in variables['defines']:
        definelist += ['/D', '"' + define + '"']
      localvariables += [('cmoreflags', definelist)]
    return localvariables

  def ar_variables(self, config, arch, targettype, variables):
    localvariables = [('toolchain', self.make_arch_toolchain_path(arch))]
    ararchflags = self.make_ararchflags(arch, targettype)
    if ararchflags != []:
      localvariables += [('ararchflags', ararchflags)]
    arconfigflags = self.make_arconfigflags(config, targettype)
    if arconfigflags != []:
      localvariables += [('arconfigflags', arconfigflags)]
    return localvariables

  def link_variables(self, config, arch, targettype, variables):
    localvariables = [('toolchain', self.make_arch_toolchain_path(arch))]
    linkarchflags = self.make_linkarchflags(arch, targettype)
    if linkarchflags != []:
      localvariables += [('linkarchflags', linkarchflags)]
    linkconfigflags = self.make_linkconfigflags(config, targettype)
    if linkconfigflags != []:
      localvariables += [('linkconfigflags', linkconfigflags)]
    if 'modulepath' in variables:
      localvariables += [('pdbpath', os.path.join(variables['modulepath'], 'ninja.pdb'))]
    if 'libs' in variables:
      libvar = self.make_libs(variables['libs'])
      if libvar != []:
        localvariables += [('libs', libvar)]
    libpaths = []
    if 'libpaths' in variables:
      libpaths = variables['libpaths']
    localvariables += [('configlibpaths', self.make_configlibpaths(config, arch, libpaths))]
    return localvariables

  def builder_cc(self, writer, config, arch, targettype, infile, outfile, variables):
    return writer.build(outfile, 'cc', infile, implicit = self.implicit_deps(config, variables), variables = self.cc_variables(config, arch, targettype, variables))

  def builder_cxx(self, writer, config, arch, targettype, infile, outfile, variables):
    return writer.build(outfile, 'cxx', infile, implicit = self.implicit_deps(config, variables), variables = self.cc_variables(config, arch, targettype, variables))

  def builder_lib(self, writer, config, arch, targettype, infiles, outfile, variables):
    return writer.build(outfile, 'ar', infiles, implicit = self.implicit_deps(config, variables), variables = self.ar_variables(config, arch, targettype, variables))

  def builder_sharedlib(self, writer, config, arch, targettype, infiles, outfile, variables):
    return writer.build(outfile, 'dll', infiles, implicit = self.implicit_deps(config, variables), variables = self.link_variables(config, arch, targettype, variables))

  def builder_bin(self, writer, config, arch, targettype, infiles, outfile, variables):
    return writer.build(outfile, 'link', infiles, implicit = self.implicit_deps(config, variables), variables = self.link_variables(config, arch, targettype, variables))

def create(host, target, toolchain):
  return MSVCToolchain(host, target, toolchain)
