#!/usr/bin/env python

"""Ninja toolchain abstraction for Android platform"""

import os
import subprocess

import toolchain

def make_target(toolchain, host, target):
  return Android(toolchain, host, target)

class Android(object):
  def __init__(self, toolchain, host, target):
    self.host = host

    if host.is_windows():
      self.exe_suffix = '.exe'
    else:
      self.exe_suffix = ''

    self.javaccmd = toolchain.mkdircmd('$outpath') + ' && $javac -d $outpath -classpath $outpath -sourcepath $sourcepath -target 1.5 -bootclasspath $androidjar -g -source 1.5 -Xlint:-options $in'
    self.dexcmd = '$dex --dex --output $out $in'
    self.aaptcmd = toolchain.cdcmd('$apkbuildpath') + ' && $aapt p -f -m -M AndroidManifest.xml -F $apk -I $androidjar -S res --debug-mode --no-crunch -J gen $aaptflags'
    self.aaptdeploycmd = toolchain.cdcmd('$apkbuildpath') + ' && $aapt c -S res -C bin/res && $aapt p -f -m -M AndroidManifest.xml -F $apk -I $androidjar -S bin/res -S res -J gen $aaptflags'
    self.aaptaddcmd = toolchain.cdcmd('$apkbuildpath') + ' && ' + toolchain.copycmd('$apksource', '$apk' ) + ' && $aapt a $apk $apkaddfiles'
    self.zipcmd = '$zip -r -9 $out $in $implicitin'
    self.zipaligncmd = '$zipalign -f 4 $in $out'
    self.codesigncmd = 'build/ninja/codesign.py --target $target --prefs codesign.json --zipfile $in --config $config --jarsigner $jarsigner $out'

    if host.is_windows():
      self.codesigncmd = 'python ' + self.codesigncmd

  def initialize_toolchain(self):
    self.ndkpath = os.getenv('NDK_HOME', '')
    self.sdkpath = os.getenv('ANDROID_HOME', '')
    self.sysroot = ''
    self.platformversion = '21'
    self.gcc_toolchainversion = '4.9'
    self.javasdk = ''

    self.archname = dict()
    self.archname['x86'] = 'x86'
    self.archname['x86-64'] = 'x86_64'
    self.archname['arm6'] = 'arm'
    self.archname['arm7'] = 'arm'
    self.archname['arm64'] = 'arm64'
    self.archname['mips'] = 'mips'
    self.archname['mips64'] = 'mips64'

    self.archpath = dict()
    self.archpath['x86'] = 'x86'
    self.archpath['x86-64'] = 'x86-64'
    self.archpath['arm6'] = 'armeabi'
    self.archpath['arm7'] = 'armeabi-v7a'
    self.archpath['arm64'] = 'arm64-v8a'
    self.archpath['mips'] = 'mips'
    self.archpath['mips64'] = 'mips64'

    self.gcc_toolchainname = dict()
    self.gcc_toolchainname['x86'] = 'x86-' + self.gcc_toolchainversion
    self.gcc_toolchainname['x86-64'] = 'x86_64-' + self.gcc_toolchainversion
    self.gcc_toolchainname['arm6'] = 'arm-linux-androideabi-' + self.gcc_toolchainversion
    self.gcc_toolchainname['arm7'] = 'arm-linux-androideabi-' + self.gcc_toolchainversion
    self.gcc_toolchainname['arm64'] = 'aarch64-linux-android-' + self.gcc_toolchainversion
    self.gcc_toolchainname['mips'] = 'mipsel-linux-android-' + self.gcc_toolchainversion
    self.gcc_toolchainname['mips64'] = 'mips64el-linux-android-' + self.gcc_toolchainversion

    self.gcc_toolchainprefix = dict()
    self.gcc_toolchainprefix['x86'] = 'i686-linux-android-'
    self.gcc_toolchainprefix['x86-64'] = 'x86_64-linux-android-'
    self.gcc_toolchainprefix['arm6'] = 'arm-linux-androideabi-'
    self.gcc_toolchainprefix['arm7'] = 'arm-linux-androideabi-'
    self.gcc_toolchainprefix['arm64'] = 'aarch64-linux-android-'
    self.gcc_toolchainprefix['mips'] = 'mipsel-linux-android-'
    self.gcc_toolchainprefix['mips64'] = 'mips64el-linux-android-'

    if self.host.is_windows():
      if os.getenv('PROCESSOR_ARCHITECTURE', 'AMD64').find('64') != -1:
        self.hostarchname = 'windows-x86_64'
      else:
        self.hostarchname = 'windows-x86'
    elif self.host.is_linux():
        localarch = toolchain.check_output(['uname', '-m'])
        if localarch == 'x86_64':
          self.hostarchname = 'linux-x86_64'
        else:
          self.hostarchname = 'linux-x86'
    elif self.host.is_macos():
      self.hostarchname = 'darwin-x86_64'

  def build_toolchain(self):
    buildtools_path = os.path.join(self.sdkpath, 'build-tools')
    buildtools_list = [item for item in os.listdir(buildtools_path) if os.path.isdir(os.path.join(buildtools_path, item))]
    buildtools_list.sort(key = lambda s: map(int, s.split('-')[0].split('.')))

    self.buildtools_path = os.path.join(self.sdkpath, 'build-tools', buildtools_list[-1])
    self.android_jar = os.path.join(self.sdkpath, 'platforms', 'android-' + self.platformversion, 'android.jar')

    self.javac = 'javac'
    self.jarsigner = 'jarsigner'
    if self.javasdk != '':
      self.javac = os.path.join(self.javasdk, 'bin', self.javac)
      self.jarsigner = os.path.join(self.javasdk, 'bin', self.jarsigner)
    if self.host.is_windows():
      self.dex = os.path.join(self.buildtools_path, 'dx.bat')
    else:
      self.dex = os.path.join(self.buildtools_path, 'dx' + self.exe_suffix)
    if not os.path.isfile(self.dex):
      self.dex = os.path.join(self.sdkpath, 'tools', 'dx' + self.exe_suffix)
    self.aapt = os.path.join(self.buildtools_path, 'aapt' + self.exe_suffix)
    self.zipalign = os.path.join(self.buildtools_path, 'zipalign' + self.exe_suffix)
    if not os.path.isfile( self.zipalign ):
      self.zipalign = os.path.join(self.sdkpath, 'tools', 'zipalign' + self.exe_suffix)

  def parse_prefs(self, prefs):
    if 'android' in prefs:
      androidprefs = prefs['android']
      if 'ndkpath' in androidprefs:
        self.ndkpath = os.path.expanduser(androidprefs['ndkpath'])
      if 'sdkpath' in androidprefs:
        self.sdkpath = os.path.expanduser(androidprefs['sdkpath'])
      if 'platformversion' in androidprefs:
        self.platformversion = androidprefs['platformversion']
      if 'gccversion' in androidprefs:
        self.gcc_toolchainversion = androidprefs['gccversion']
      if 'javasdk' in androidprefs:
        self.javasdk = androidprefs['javasdk']

  def write_variables(self, writer):
    writer.variable('ndk', self.ndkpath)
    writer.variable('sdk', self.sdkpath)
    writer.variable('sysroot', self.sysroot)
    writer.variable('androidjar', self.android_jar )
    writer.variable('apkbuildpath', '')
    writer.variable('apk', '')
    writer.variable('apksource', '')
    writer.variable('apkaddfiles', '')
    writer.variable('javac', self.javac)
    writer.variable('dex', self.dex)
    writer.variable('aapt', self.aapt)
    writer.variable('zipalign', self.zipalign)
    writer.variable('jarsigner', self.jarsigner)
    writer.variable('aaptflags', '')

  def write_rules(self, writer):
    writer.rule('aapt', command = self.aaptcmd, description = 'AAPT $out')
    writer.rule('aaptdeploy', command = self.aaptdeploycmd, description = 'AAPT $out')
    writer.rule('aaptadd', command = self.aaptaddcmd, description = 'AAPT $out')
    writer.rule('javac', command = self.javaccmd, description = 'JAVAC $in')
    writer.rule('dex', command = self.dexcmd, description = 'DEX $out')
    writer.rule('zip', command = self.zipcmd, description = 'ZIP $out')
    writer.rule('zipalign', command = self.zipaligncmd, description = 'ZIPALIGN $out')
    writer.rule('codesign', command = self.codesigncmd, description = 'CODESIGN $out')

  def make_sysroot_path(self, arch):
    return os.path.join(self.ndkpath, 'platforms', 'android-' + self.platformversion, 'arch-' + self.archname[arch])

  def make_gcc_toolchain_path(self, arch):
    return os.path.join(self.ndkpath, 'toolchains', self.gcc_toolchainname[arch], 'prebuilt', self.hostarchname)

  def make_gcc_bin_path(self, arch):
    return os.path.join(self.make_gcc_toolchain_path(arch), 'bin', self.gcc_toolchainprefix[arch])

  def archname(self):
    return self.archname

  def archpath(self):
    return self.archpath

  def hostarchname(self):
    return self.hostarchname

  def apk(self, toolchain, writer, module, archbins, javasources, outpath, binname, basepath, config, implicit_deps, resources):
    buildpath = os.path.join('$buildpath', config, 'apk', binname)
    baseapkname = binname + ".base.apk"
    unsignedapkname = binname + ".unsigned.apk"
    unalignedapkname = binname + ".unaligned.apk"
    apkname = binname + ".apk"
    apkfiles = []
    libfiles = []
    locallibs = []
    resfiles = []
    manifestfile = []

    writer.comment('Make APK')
    for _, value in archbins.iteritems():
      for archbin in value:
        archpair = os.path.split(archbin)
        libname = archpair[1]
        arch = os.path.split(archpair[0])[1]
        locallibpath = os.path.join('lib', self.archpath[arch], libname)
        archpath = os.path.join(buildpath, locallibpath)
        locallibs += [locallibpath + ' ']
        libfiles += toolchain.copy(writer, archbin, archpath)
    for resource in resources:
      filename = os.path.split(resource)[1]
      if filename == 'AndroidManifest.xml':
        manifestfile = toolchain.copy(writer, os.path.join(basepath, module, resource), os.path.join(buildpath, 'AndroidManifest.xml'))
      else:
        restype = os.path.split(os.path.split(resource)[0])[1]
        if restype == 'asset':
          pass #todo: implement
        else:
          resfiles += toolchain.copy(writer, os.path.join(basepath, module, resource), os.path.join(buildpath, 'res', restype, filename))

    #Make directories
    gendir = toolchain.mkdir(writer, os.path.join(buildpath, 'gen'))
    bindir = toolchain.mkdir(writer, os.path.join(buildpath, 'bin'))
    binresdir = toolchain.mkdir(writer, os.path.join(buildpath, 'bin', 'res'), order_only = bindir)
    alldirs = gendir + bindir + binresdir

    aaptvars = [('apkbuildpath', buildpath), ('apk', baseapkname)]
    aaptout = os.path.join(buildpath, baseapkname)
    if config == 'deploy':
      baseapkfile = writer.build(aaptout, 'aaptdeploy', manifestfile, variables = aaptvars, implicit = manifestfile + resfiles, order_only = alldirs)
    else:
      baseapkfile = writer.build(aaptout, 'aapt', manifestfile, variables = aaptvars, implicit = manifestfile + resfiles, order_only = alldirs)

    #Compile java code
    javafiles = []
    localjava = []
    if javasources != []:
      #self.javaccmd = '$javac -d $outpath -classpath $outpath -sourcepath $sourcepath -target 1.5 -bootclasspath $androidjar -g -source 1.5 -Xlint:-options $in'
      #self.dexcmd = '$dex --dex --output $out $in'
      javasourcepath = '.'
      if self.host.is_windows():
        javasourcepath += ';'
      else:
        javasourcepath += ':'
      javasourcepath += os.path.join(buildpath, 'gen')
      classpath = os.path.join(buildpath, 'classes')
      javavars = [('outpath', classpath), ('sourcepath', javasourcepath)]
      javaclasses = writer.build(classpath, 'javac', javasources, variables = javavars, implicit = baseapkfile)
      localjava += ['classes.dex']
      javafiles += writer.build(os.path.join(buildpath, 'classes.dex'), 'dex', classpath)

    #Add native libraries and java classes to apk
    aaptvars = [('apkbuildpath', buildpath), ('apk', unsignedapkname), ('apksource', baseapkname), ('apkaddfiles', toolchain.paths_forward_slash(locallibs + localjava))]
    unsignedapkfile = writer.build(os.path.join(buildpath, unsignedapkname), 'aaptadd', baseapkfile, variables = aaptvars, implicit = libfiles + javafiles, order_only = alldirs)

    #Sign the APK
    codesignvars = [('config', config)]
    unalignedapkfile = writer.build(os.path.join(buildpath, unalignedapkname), 'codesign', unsignedapkfile, variables = codesignvars)

    #Run zipalign
    outfile = writer.build(os.path.join(outpath, config, apkname), 'zipalign', unalignedapkfile)
    return outfile