package dotty.tools
package dotc
package core
package unpickleScala2

import Flags._

/** Variable length byte arrays, with methods for basic pickling and unpickling.
 *
 *  @param data The initial buffer
 *  @param from The first index where defined data are found
 *  @param to   The first index where new data can be written
 */
class PickleBuffer(data: Array[Byte], from: Int, to: Int) {

  var bytes = data
  var readIndex = from
  var writeIndex = to

  /** Double bytes array */
  private def dble(): Unit = {
    val bytes1 = new Array[Byte](bytes.length * 2)
    Array.copy(bytes, 0, bytes1, 0, writeIndex)
    bytes = bytes1
  }

  def ensureCapacity(capacity: Int) =
    while (bytes.length < writeIndex + capacity) dble()

  // -- Basic output routines --------------------------------------------

  /** Write a byte of data */
  def writeByte(b: Int): Unit = {
    if (writeIndex == bytes.length) dble()
    bytes(writeIndex) = b.toByte
    writeIndex += 1
  }

  /** Write a natural number in big endian format, base 128.
   *  All but the last digits have bit 0x80 set.
   */
  def writeNat(x: Int): Unit =
    writeLongNat(x.toLong & 0x00000000FFFFFFFFL)

  /**
   * Like writeNat, but for longs. This is not the same as
   * writeLong, which writes in base 256. Note that the
   * binary representation of LongNat is identical to Nat
   * if the long value is in the range Int.MIN_VALUE to
   * Int.MAX_VALUE.
   */
  def writeLongNat(x: Long): Unit = {
    def writeNatPrefix(x: Long): Unit = {
      val y = x >>> 7
      if (y != 0L) writeNatPrefix(y)
      writeByte(((x & 0x7f) | 0x80).toInt)
    }
    val y = x >>> 7
    if (y != 0L) writeNatPrefix(y)
    writeByte((x & 0x7f).toInt)
  }

  /** Write a natural number <code>x</code> at position <code>pos</code>.
   *  If number is more than one byte, shift rest of array to make space.
   *
   *  @param pos ...
   *  @param x   ...
   */
  def patchNat(pos: Int, x: Int): Unit = {
    def patchNatPrefix(x: Int): Unit = {
      writeByte(0)
      Array.copy(bytes, pos, bytes, pos + 1, writeIndex - (pos + 1))
      bytes(pos) = ((x & 0x7f) | 0x80).toByte
      val y = x >>> 7
      if (y != 0) patchNatPrefix(y)
    }
    bytes(pos) = (x & 0x7f).toByte
    val y = x >>> 7
    if (y != 0) patchNatPrefix(y)
  }

  /** Write a long number <code>x</code> in signed big endian format, base 256.
   *
   *  @param x The long number to be written.
   */
  def writeLong(x: Long): Unit = {
    val y = x >> 8
    val z = x & 0xff
    if (-y != (z >> 7)) writeLong(y)
    writeByte(z.toInt)
  }

  // -- Basic input routines --------------------------------------------

  /** Peek at the current byte without moving the read index */
  def peekByte(): Int = bytes(readIndex)

  /** Read a byte */
  def readByte(): Int = {
    val x = bytes(readIndex); readIndex += 1; x
  }

  /** Read a natural number in big endian format, base 128.
   *  All but the last digits have bit 0x80 set.*/
  def readNat(): Int = readLongNat().toInt

  def readLongNat(): Long = {
    var b = 0L
    var x = 0L
    do {
      b = readByte()
      x = (x << 7) + (b & 0x7f)
    } while ((b & 0x80) != 0L)
    x
  }

  /** Read a long number in signed big endian format, base 256. */
  def readLong(len: Int): Long = {
    var x = 0L
    var i = 0
    while (i < len) {
      x = (x << 8) + (readByte() & 0xff)
      i += 1
    }
    val leading = 64 - (len << 3)
    x << leading >> leading
  }

  /** Returns the buffer as a sequence of (Int, Array[Byte]) representing
   *  (tag, data) of the individual entries.  Saves and restores buffer state.
   */

  def toIndexedSeq: IndexedSeq[(Int, Array[Byte])] = {
    val saved = readIndex
    readIndex = 0
    readNat() ; readNat()     // discarding version
    val result = new Array[(Int, Array[Byte])](readNat())

    result.indices foreach { index =>
      val tag = readNat()
      val len = readNat()
      val bytes = data.slice(readIndex, len + readIndex)
      readIndex += len

      result(index) = tag -> bytes
    }

    readIndex = saved
    result.toIndexedSeq
  }

  /** Perform operation <code>op</code> until the condition
   *  <code>readIndex == end</code> is satisfied.
   *  Concatenate results into a list.
   *
   *  @param end ...
   *  @param op  ...
   *  @return    ...
   */
  def until[T](end: Int, op: () => T): List[T] =
    if (readIndex == end) List() else op() :: until(end, op)

  /** Perform operation <code>op</code> the number of
   *  times specified.  Concatenate the results into a list.
   */
  def times[T](n: Int, op: ()=>T): List[T] =
    if (n == 0) List() else op() :: times(n-1, op)

  /** Pickle = majorVersion_Nat minorVersion_Nat nbEntries_Nat {Entry}
   *  Entry  = type_Nat length_Nat [actual entries]
   *
   *  Assumes that the ..Version_Nat are already consumed.
   *
   *  @return an array mapping entry numbers to locations in
   *  the byte array where the entries start.
   */
  def createIndex: Array[Int] = {
    val index = new Array[Int](readNat()) // nbEntries_Nat
    for (i <- 0 until index.length) {
      index(i) = readIndex
      readByte() // skip type_Nat
      readIndex = readNat() + readIndex // read length_Nat, jump to next entry
    }
    index
  }
}

object PickleBuffer {

  private final val ScalaFlagEnd = 48
  private final val ChunkBits = 8
  private final val ChunkSize = 1 << ChunkBits
  private type FlagMap = Array[Array[Long]]

  private val (scalaTermFlagMap, scalaTypeFlagMap) = {
    import Scala2Flags._

    val corr = Map(
      PROTECTED_PKL -> Protected,
      OVERRIDE_PKL -> Override,
      PRIVATE_PKL -> Private,
      ABSTRACT_PKL -> Abstract,
      DEFERRED_PKL -> Deferred,
      FINAL_PKL -> Final,
      METHOD_PKL -> Method,
      INTERFACE_PKL -> NoInitsInterface,
      MODULE_PKL -> (Module | Lazy, Module),
      IMPLICIT_PKL -> Implicit,
      SEALED_PKL -> Sealed,
      CASE_PKL -> Case,
      MUTABLE -> Mutable,
      PARAM -> Param,
      PACKAGE -> Package,
      MACRO -> Macro,
      BYNAMEPARAM -> (Method, Covariant),
      LABEL -> (Label, Contravariant),
      ABSOVERRIDE -> AbsOverride,
      LOCAL -> Local,
      JAVA -> JavaDefined,
      SYNTHETIC -> Synthetic,
      STABLE -> Stable,
      STATIC -> JavaStatic,
      CASEACCESSOR -> CaseAccessor,
      DEFAULTPARAM -> (DefaultParameterized, Trait),
      BRIDGE -> Bridge,
      ACCESSOR -> Accessor,
      SUPERACCESSOR -> Scala2SuperAccessor,
      PARAMACCESSOR -> ParamAccessor,
      MODULEVAR -> Scala2ModuleVar,
      LAZY -> Lazy,
      MIXEDIN -> (MixedIn, Scala2Existential),
      EXPANDEDNAME -> Scala2ExpandedName,
      IMPLCLASS -> (Scala2PreSuper, ImplClass),
      SPECIALIZED -> Specialized,
      VBRIDGE -> VBridge,
      VARARGS -> JavaVarargs,
      ENUM -> Enum)

    // generate initial maps from Scala flags to Dotty flags
    val termMap, typeMap = new Array[Long](64)
    for (idx <- 0 until ScalaFlagEnd)
      corr get (1L << idx) match {
        case Some((termFlag: FlagSet, typeFlag: FlagSet)) =>
          termMap(idx) |= termFlag.bits
          typeMap(idx) |= typeFlag.bits
        case Some(commonFlag: FlagSet) =>
          termMap(idx) |= commonFlag.toTermFlags.bits
          typeMap(idx) |= commonFlag.toTypeFlags.bits
        case _ =>
      }

    // Convert map so that it maps chunks of ChunkBits size at once
    // instead of single bits.
    def chunkMap(xs: Array[Long]): FlagMap = {
      val chunked = Array.ofDim[Long](
        (xs.length + ChunkBits - 1) / ChunkBits, ChunkSize)
      for (i <- 0 until chunked.length)
        for (j <- 0 until ChunkSize)
          for (k <- 0 until ChunkBits)
            if ((j & (1 << k)) != 0)
              chunked(i)(j) |= xs(i * ChunkBits + k)
      chunked
    }

    (chunkMap(termMap), chunkMap(typeMap))
  }

  def unpickleScalaFlags(sflags: Long, isType: Boolean): FlagSet = {
    val map: FlagMap = if (isType) scalaTypeFlagMap else scalaTermFlagMap
    val shift = ChunkBits
    val mask = ChunkSize - 1
    assert(6 * ChunkBits == ScalaFlagEnd)
    FlagSet(
      map(0)((sflags >>> (shift * 0)).toInt & mask) |
      map(1)((sflags >>> (shift * 1)).toInt & mask) |
      map(2)((sflags >>> (shift * 2)).toInt & mask) |
      map(3)((sflags >>> (shift * 3)).toInt & mask) |
      map(4)((sflags >>> (shift * 4)).toInt & mask) |
      map(5)((sflags >>> (shift * 5)).toInt & mask)
    )
  }
}