/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.tools.analytics

import com.google.common.annotations.VisibleForTesting
import com.google.common.base.Strings
import com.google.wireless.android.sdk.stats.*
import com.google.wireless.android.sdk.stats.DeviceInfo.ApplicationBinaryInterface
import java.io.File
import java.util.*
import java.util.regex.Pattern

/** Calculates common pieces of metrics data, used in various Android DevTools.  */
object CommonMetricsData {

  const val VM_OPTION_XMS = "-Xms"
  const val VM_OPTION_XMX = "-Xmx"
  const val VM_OPTION_MAX_PERM_SIZE = "-XX:MaxPermSize="
  const val VM_OPTION_RESERVED_CODE_CACHE_SIZE = "-XX:ReservedCodeCacheSize="
  const val VM_OPTION_SOFT_REF_LRU_POLICY_MS_PER_MB = "-XX:SoftRefLRUPolicyMSPerMB="
  const val KILOBYTE = 1024L
  const val MEGABYTE = KILOBYTE * 1024
  const val GIGABYTE = MEGABYTE * 1024
  const val TERABYTE = GIGABYTE * 1024
  const val NO_DIGITS = -1
  const val INVALID_POSTFIX = -2
  const val INVALID_NUMBER = -3
  const val EMPTY_SIZE = -4

  @VisibleForTesting
  @JvmStatic
  val garbageCollectionStatsCache: HashMap<String, GarbageCollectionStatsDiffs> = HashMap()

  /**
   * Detects and returns the OS architecture: x86, x86_64, ppc. This may differ or be equal to the
   * JVM architecture in the sense that a 64-bit OS can run a 32-bit JVM.
   */
  @JvmStatic
  val osArchitecture: ProductDetails.CpuArchitecture
    get() {
      val jvmArchitecture = jvmArchitecture
      if (jvmArchitecture == ProductDetails.CpuArchitecture.X86) {

        val os = System.getProperty("os.name").toLowerCase()
        if (os.startsWith("win")) {
          val w6432 = Environment.instance.getVariable("PROCESSOR_ARCHITEW6432")
          // This is the misleading case: the JVM is 32-bit but the OS
          // might be either 32 or 64. We can't tell just from this
          // property.
          // Macs are always on 64-bit, so we just need to figure it
          // out for Windows and Linux.
          // When WOW64 emulates a 32-bit environment under a 64-bit OS,
          // it sets PROCESSOR_ARCHITEW6432 to AMD64 or IA64 accordingly.
          // Ref: http://msdn.microsoft.com/en-us/library/aa384274(v=vs.85).aspx
          // Let's try the obvious. This works in Ubuntu and Debian
          if (w6432 != null && w6432.contains("64")) {
            return ProductDetails.CpuArchitecture.X86_64
          }
        }
        else if (os.startsWith("linux")) {
          val s = Environment.instance.getVariable("HOSTTYPE")
          return cpuArchitectureFromString(s)
        }
      }
      return jvmArchitecture
    }

  /**
   * Gets the JVM Architecture, NOTE this might not be the same as OS architecture. See [ ][.getOsArchitecture] if OS architecture is needed.
   */
  @JvmStatic
  val jvmArchitecture: ProductDetails.CpuArchitecture
    get() {
      val arch = System.getProperty("os.arch")
      return cpuArchitectureFromString(arch)
    }

  /** Gets a normalized version of the os name that this code is running on.  */
  // Unknown -- send it verbatim so we can see it
  // but protect against arbitrarily long values
  @JvmStatic
  val osName: String
    get() {
      var os: String? = System.getProperty("os.name")

      if (os == null || os.isEmpty()) {
        return "unknown"
      }

      val osLower = os.toLowerCase(Locale.US)

      when {
        osLower.startsWith("mac") -> os = "macosx"
        osLower.startsWith("win") -> os = "windows"
        osLower.startsWith("linux") -> {
          if (File("/dev/.cros_milestone").exists()) {
           os = "chromium"
          } else {
            os = "linux"
          }
        }
        os.length > 32 -> os = os.substring(0, 32)
      }
      return os
    }

  /**
   * Extracts the major os version that this code is running on in the form of '[0-9]+\.[0-9]+'
   */
  @JvmStatic
  val majorOsVersion: String?
    get() {
      if (osName == "chromium") {
        return File("/dev/.cros_milestone").readText(Charsets.UTF_8)
      }

      val p = Pattern.compile("(\\d+)\\.(\\d+).*")
      val osVers = System.getProperty("os.version")
      if (osVers != null && osVers.isNotEmpty()) {
        val m = p.matcher(osVers)
        if (m.matches()) {
          return "${m.group(1)}${'.'}${m.group(2)}"
        }
      }
      return null
    }

  /** Gets information about the jvm this code is running in.  */
  @JvmStatic
  val jvmDetails: JvmDetails
    get() {
      val runtime = HostData.runtimeBean!!

      val builder = JvmDetails.newBuilder()
        .setName(Strings.nullToEmpty(runtime.vmName))
        .setVendor(Strings.nullToEmpty(runtime.vmVendor))
        .setVersion(Strings.nullToEmpty(runtime.vmVersion))

      for (vmOption in runtime.inputArguments) {
        parseVmOption(vmOption, builder)
      }

      return builder.build()
    }

  /** Gets stats about the current process java runtime.  */
  @JvmStatic
  val javaProcessStats: JavaProcessStats
    get() {
      val memoryBean = HostData.memoryBean!!
      val classLoadingBean = HostData.classLoadingBean!!

      return JavaProcessStats.newBuilder()
        .setHeapMemoryUsage(memoryBean.heapMemoryUsage.used)
        .setNonHeapMemoryUsage(memoryBean.nonHeapMemoryUsage.used)
        .setLoadedClassCount(classLoadingBean.loadedClassCount)
        .addAllGarbageCollectionStats(garbageCollectionStats)
        .setThreadCount(HostData.threadBean!!.threadCount)
        .build()
    }

  /**
   * Gets stats about the current process' Garbage Collectors. Instead of returning cumulative
   * data since process was started, it reports stats since the last call to this method.
   */
  @JvmStatic
  @VisibleForTesting
  val garbageCollectionStats: List<GarbageCollectionStats>
    get() {
      val stats = ArrayList<GarbageCollectionStats>()
      for (gc in HostData.garbageCollectorBeans!!) {
        val name = gc.name
        var previous: GarbageCollectionStatsDiffs? = garbageCollectionStatsCache[name]
        if (previous == null) {
          previous = GarbageCollectionStatsDiffs()
        }
        val current = GarbageCollectionStatsDiffs()
        current.collections = gc.collectionCount
        val collectionsDiff = current.collections - previous.collections

        current.time = gc.collectionTime
        val timeDiff = current.time - previous.time
        garbageCollectionStatsCache[name] = current

        stats.add(
          GarbageCollectionStats.newBuilder()
            .setName(gc.name)
            .setGcCollections(collectionsDiff)
            .setGcTime(timeDiff)
            .build())
      }
      return stats
    }

  /** Used to calculate diffs between different reports of Garbage Collection stats.  */
  @VisibleForTesting
  class GarbageCollectionStatsDiffs {
    @Volatile
    var collections: Long = 0
    @Volatile
    var time: Long = 0
  }

  /**
   * Builds a [ProductDetails.CpuArchitecture] instance based on the provided string (e.g.
   * "x86_64").
   */
  @JvmStatic
  fun cpuArchitectureFromString(cpuArchitecture: String?): ProductDetails.CpuArchitecture {
    if (cpuArchitecture == null || cpuArchitecture.isEmpty()) {
      return ProductDetails.CpuArchitecture.UNKNOWN_CPU_ARCHITECTURE
    }

    if (cpuArchitecture.equals("x86_64", ignoreCase = true)
        || cpuArchitecture.equals("ia64", ignoreCase = true)
        || cpuArchitecture.equals("amd64", ignoreCase = true)) {
      return ProductDetails.CpuArchitecture.X86_64
    }

    if (cpuArchitecture.equals("x86", ignoreCase = true)) {
      return ProductDetails.CpuArchitecture.X86
    }

    return if (cpuArchitecture.length == 4
               && cpuArchitecture[0] == 'i'
               && cpuArchitecture.indexOf("86") == 2) {
      // Any variation of iX86 counts as x86 (i386, i486, i686).
      ProductDetails.CpuArchitecture.X86
    }
    else ProductDetails.CpuArchitecture.UNKNOWN_CPU_ARCHITECTURE
  }

  @JvmStatic
  fun applicationBinaryInterfaceFromString(value: String?): ApplicationBinaryInterface {
    if (value == null) {
      return ApplicationBinaryInterface.UNKNOWN_ABI
    }
    return when (value) {
      "armeabi-v6j" -> ApplicationBinaryInterface.ARME_ABI_V6J
      "armeabi-v6l" -> ApplicationBinaryInterface.ARME_ABI_V6L
      "armeabi-v7a" -> ApplicationBinaryInterface.ARME_ABI_V7A
      "armeabi" -> ApplicationBinaryInterface.ARME_ABI
      "arm64-v8a" -> ApplicationBinaryInterface.ARM64_V8A_ABI
      "mips" -> ApplicationBinaryInterface.MIPS_ABI
      "mips-r2" -> ApplicationBinaryInterface.MIPS_R2_ABI
      "x86" -> ApplicationBinaryInterface.X86_ABI
      "x86_64" -> ApplicationBinaryInterface.X86_64_ABI
      else -> ApplicationBinaryInterface.UNKNOWN_ABI
    }
  }

  /** Parses known VM options into a [JvmDetails.Builder]  */
  @JvmStatic
  private fun parseVmOption(
    vmOption: String, builder: JvmDetails.Builder) {
    when {
      vmOption.startsWith(VM_OPTION_XMS) -> builder.minimumHeapSize = parseVmOptionSize(vmOption.substring(VM_OPTION_XMS.length))
      vmOption.startsWith(VM_OPTION_XMX) -> builder.maximumHeapSize = parseVmOptionSize(vmOption.substring(VM_OPTION_XMX.length))
      vmOption.startsWith(VM_OPTION_MAX_PERM_SIZE) -> builder.maximumPermanentSpaceSize = parseVmOptionSize(
        vmOption.substring(VM_OPTION_MAX_PERM_SIZE.length))
      vmOption.startsWith(VM_OPTION_RESERVED_CODE_CACHE_SIZE) -> builder.maximumCodeCacheSize = parseVmOptionSize(
        vmOption.substring(VM_OPTION_RESERVED_CODE_CACHE_SIZE.length))
      vmOption.startsWith(VM_OPTION_SOFT_REF_LRU_POLICY_MS_PER_MB) -> builder.softReferenceLruPolicy = parseVmOptionSize(
        vmOption.substring(VM_OPTION_SOFT_REF_LRU_POLICY_MS_PER_MB.length))
    }

    when (vmOption) {
      "-XX:+UseConcMarkSweepGC" -> builder.garbageCollector = JvmDetails.GarbageCollector.CONCURRENT_MARK_SWEEP_GC
      "-XX:+UseParallelGC" -> builder.garbageCollector = JvmDetails.GarbageCollector.PARALLEL_GC
      "-XX:+UseParallelOldGC" -> builder.garbageCollector = JvmDetails.GarbageCollector.PARALLEL_OLD_GC
      "-XX:+UseSerialGC" -> builder.garbageCollector = JvmDetails.GarbageCollector.SERIAL_GC
      "-XX:+UseG1GC" -> builder.garbageCollector = JvmDetails.GarbageCollector.SERIAL_GC
    }
  }

  /** Parses VM options size formatted as "[0-9]+[GgMmKk]?" into a long.  */
  @VisibleForTesting
  @JvmStatic
  fun parseVmOptionSize(vmOptionSize: String): Long {
    if (Strings.isNullOrEmpty(vmOptionSize)) {
      return EMPTY_SIZE.toLong()
    }
    try {
      for (i in 0 until vmOptionSize.length) {
        val c = vmOptionSize[i]
        if (!Character.isDigit(c)) {
          if (i == 0) {
            return NO_DIGITS.toLong()
          }
          val digits = vmOptionSize.substring(0, i)
          val value = java.lang.Long.parseLong(digits)
          return when (c) {
            't', 'T' -> value * TERABYTE
            'g', 'G' -> value * GIGABYTE
            'm', 'M' -> value * MEGABYTE
            'k', 'K' -> value * KILOBYTE
            else -> INVALID_POSTFIX.toLong()
          }
        }
      }
      return java.lang.Long.parseLong(vmOptionSize)
    }
    catch (e: NumberFormatException) {
      return INVALID_NUMBER.toLong()
    }
  }
}