//设置package包名称以及导入依赖的类
package com.init6.coders.binary

import java.nio.ByteOrder

import akka.util.ByteString


trait BinaryPacket {

  implicit val byteOrder = ByteOrder.LITTLE_ENDIAN

  val PACKET_HEADER: Byte = 0xFF.toByte
  val PACKET_HEADER_LENGTH: Short = 4

  val PACKET_ID: Byte

  implicit def stringToNTBytes(string: String): Array[Byte] = {
    Array.newBuilder[Byte]
      .++=(string.map(_.toByte))
      .+=(0)
      .result()
  }

  def build(data: ByteString) = {
    ByteString.newBuilder
      .putByte(PACKET_HEADER)
      .putByte(PACKET_ID)
      .putShort(data.length + PACKET_HEADER_LENGTH)
      .append(data)
      .result()
  }
} 

//设置package包名称以及导入依赖的类
package edu.uw.at.iroberts.wirefugue.protocol.overlay

import java.nio.ByteOrder

import edu.uw.at.iroberts.wirefugue.pcap.ByteSeqOps._


trait UDPHeader {
  def sport: Short
  def dport: Short
  def length: Int
  def checksum: Short
}

case class UDPDatagram(bytes: IndexedSeq[Byte]) extends UDPHeader {
  implicit val byteOrder = ByteOrder.BIG_ENDIAN
  def sport: Short = bytes.slice(0, 2).getInt16
  def dport: Short = bytes.slice(2, 4).getInt16
  def length: Int = bytes.slice(4, 6).getUInt16
  def checksum: Short = bytes.slice(6, 8).getInt16
} 

//设置package包名称以及导入依赖的类
package com.spooky.inbound.step

import com.spooky.inbound.OutStep
import com.spooky.inbound.InStep
import com.spooky.inbound.Base
import com.spooky.inbound.Reply
import spooky.util.ByteString
import com.spooky.inbound.OutStep
import com.spooky.cipher.RC4ReadCipher
import com.spooky.cipher.RC4WriteCipher
import java.nio.ByteBuffer
import java.nio.ByteOrder
import akka.util.FakeBStrings
import com.spooky.inbound.CryptoProvider
import com.spooky.cipher.WriteCipher
import com.spooky.cipher.ReadCipher
import com.spooky.inbound.RC4
import com.spooky.inbound.Plain
import com.spooky.cipher.WritePlain
import com.spooky.cipher.ReadPlain
import com.spooky.cipher.MSEKeyPair

class ConfirmStep(readCipher: RC4ReadCipher, writeCipher: RC4WriteCipher, cryptoProvider: CryptoProvider, data: Option[ByteString]) extends Base with OutStep {

  def step(reply: Reply): InStep = {

    val padding = randomPadding()
    val writeBuffer = ByteBuffer.allocate(VC.length + 4 + 2 + padding.length).order(ByteOrder.BIG_ENDIAN);

    writeBuffer.put(writeCipher.update(VC));
    writeBuffer.put(writeCipher.update(Array[Byte](0, 0, 0, CRYPTO_RC4)))
    writeBuffer.put(writeCipher.update(Array[Byte]((padding.length >> 8).asInstanceOf[Byte], padding.length.asInstanceOf[Byte])))
    if (writeBuffer.remaining() != padding.length) {
      throw new RuntimeException("not correct");
    }
    writeBuffer.put(writeCipher.update(padding));

    writeBuffer.flip();

    reply.reply(FakeBStrings(writeBuffer))

    val (chosenWriteCipher, chosenReadCipher) = choose(cryptoProvider, writeCipher, readCipher)
    new DoneStep(MSEKeyPair(chosenWriteCipher, chosenReadCipher), data)
  }

  private def choose(cryptoProvider: CryptoProvider, writeCipher: RC4WriteCipher, readCipher: RC4ReadCipher): Tuple2[WriteCipher, ReadCipher] = cryptoProvider match {
    case RC4   => (writeCipher, readCipher)
    case Plain => (WritePlain, ReadPlain)
    case c     => throw new RuntimeException(s"Unknown crypto select: $c")
  }

} 

//设置package包名称以及导入依赖的类
package com.spooky.inbound.step

import com.spooky.inbound.Base
import com.spooky.inbound.InStep
import com.spooky.inbound.OutStep
import com.spooky.inbound.Reply
import spooky.util.ByteString
import com.spooky.bittorrent.InfoHash
import com.spooky.inbound.LocalPublicKey
import com.spooky.inbound.RemotePublicKey
import com.spooky.inbound.SecretKey
import java.nio.ByteOrder
import java.nio.ByteBuffer
import akka.util.FakeBStrings

class SendPublicKeyStep(infoHashes: List[InfoHash], publicKey: LocalPublicKey, remotePublicKey: RemotePublicKey, secretKey: SecretKey) extends Base with OutStep {
  def step(reply: Reply): ReceiveInfoStep = {
    val padding = randomPadding()
    val rawPublicKey = publicKey.raw

    println(rawPublicKey.length)
//    assert(rawPublicKey.length == 96)

    val buffer = ByteBuffer.allocate(rawPublicKey.length + padding.length).order(ByteOrder.BIG_ENDIAN)
    buffer.put(rawPublicKey)
    buffer.put(padding)

    assert(!buffer.hasRemaining)

    reply.reply(FakeBStrings(buffer.flip().asInstanceOf[ByteBuffer]))

    new ReceiveInfoStep(infoHashes, publicKey, remotePublicKey, secretKey)
  }

} 

//设置package包名称以及导入依赖的类
package knot.data.buffers

import java.nio.ByteOrder


object CommonBuffer {
  def allocate(size: Int, byteOrder: ByteOrder): UnsafeArrayBuffer = {
    require(size >= 0, s"size must be >= 0 (size=$size)")
    create(Array.ofDim[Byte](size), 0, size, byteOrder)
  }

  def wrap(bytes: Array[Byte], byteOrder: ByteOrder): UnsafeArrayBuffer = {
    require(bytes ne null, "bytes must be not null")
    create(bytes, 0, bytes.length, byteOrder)
  }

  private def create(buffer: Array[Byte], offset: Int, length: Int, byteOrder: ByteOrder): UnsafeArrayBuffer = {
    byteOrder match {
      case ByteOrder.LITTLE_ENDIAN =>
        new UnsafeArrayBuffer(buffer, offset, length)
      case _ =>
        throw new IllegalArgumentException()
    }
  }
} 

//设置package包名称以及导入依赖的类
package knot.msgpack

import java.nio.ByteOrder
import java.util.concurrent.TimeUnit

import knot.data.buffers.CommonBuffer
import org.msgpack.core.buffer.MessageBuffer
import org.openjdk.jmh.annotations._

@State(Scope.Benchmark)
@Measurement(timeUnit = TimeUnit.MILLISECONDS)
class MsgPackBufferBench {

  val org = MessageBuffer.allocate(8192)
  val knot = CommonBuffer.allocate(8192, ByteOrder.nativeOrder())

  @Benchmark
  def knot_1_1000() = {
    for (i <- (0 until 1000)) {
      knot.putInt(i, i)
    }
  }

  @Benchmark
  def org_1000() = {
    for (i <- (0 until 1000)) {
      org.putInt(i, i)
    }
  }

} 

//设置package包名称以及导入依赖的类
package handlers.packets

import java.nio.{ByteBuffer, ByteOrder}


class PacketReader(val data: Array[Byte]) extends Packets {

  var cursor: Int = 0

  def skip(a: Int): Unit = {
    cursor += a
  }

  def readByte(): Byte = {
    val res: Byte = data(cursor)
    cursor += byteSize
    res
  }

  def readShort(endian: ByteOrder = ByteOrder.BIG_ENDIAN): Short = {
    val res: Short = ByteBuffer.wrap(data.slice(cursor, cursor+shortSize)).order(endian).getShort
    cursor += shortSize
    res
  }

  def readInt(endian: ByteOrder = ByteOrder.BIG_ENDIAN): Int = {
    val res: Int = ByteBuffer.wrap(data.slice(cursor, cursor+intSize)).order(endian).getInt
    cursor += intSize
    res
  }

  def readString(size: Int): String = {
    val res: String = PacketsUtils.printableString(new String(data.slice(cursor, cursor+size)))
    cursor += size
    res
  }

} 

//设置package包名称以及导入依赖的类
package handlers.server

import java.nio.ByteOrder

import handlers.packets.PacketWriter

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future


class UpdatePoints {
  def process(): Future[Array[Byte]] = {
    val realmPoints = 0x00 //TODO
    val levelPermill = 0x00 //TODO
    val skillSpecialityPoints = 0x00 //TODO
    val bountyPoints = 0x00 //TODO
    val realmSpecialityPoints = 0x00 //TODO
    val championLevelPermill = 0x00 //TODO
    val experience = 0x00 //TODO
    val experienceForNextLevel = 0x32 //TODO
    val champExperience = 0x00
    val champExperienceForNextLevel = 0x00

    val writer = new PacketWriter(0x91)
    writer.writeInt(realmPoints.toInt)
    writer.writeShort(levelPermill.toShort)
    writer.writeShort(skillSpecialityPoints.toShort)
    writer.writeInt(bountyPoints.toInt)
    writer.writeShort(realmSpecialityPoints.toShort)
    writer.writeShort(championLevelPermill.toShort)
    writer.writeLong(experience.toLong, ByteOrder.LITTLE_ENDIAN)
    writer.writeLong(experienceForNextLevel.toLong, ByteOrder.LITTLE_ENDIAN)
    writer.writeLong(champExperience.toLong, ByteOrder.LITTLE_ENDIAN)
    writer.writeLong(champExperienceForNextLevel.toLong, ByteOrder.LITTLE_ENDIAN)
    Future {
      writer.getFinalPacket()
    }
  }
} 

//设置package包名称以及导入依赖的类
package cassandra.decoder

import akka.util.ByteIterator

import java.nio.ByteOrder

import cassandra.BigEndian
import cassandra.protocol._

trait DefaultDecoders {
  def scalar[A](bytesSize: Int)(extract: ByteIterator => A)(implicit byteOrder: ByteOrder) = Decoder[A] { bs =>
    if(bs.length >= bytesSize) {
      val (payload, remaining) = bs.splitAt(bytesSize)
      Consumed(extract(payload.iterator), remaining)
    }
    else NotEnough
  }

  def double(implicit byteOrder: ByteOrder) = scalar[Double](8)(_.getDouble)
  def float(implicit byteOrder: ByteOrder) = scalar[Float](4)(_.getFloat)
  def long(implicit byteOrder: ByteOrder) = scalar[Long](8)(_.getLong)
  def int(implicit byteOrder: ByteOrder) = scalar[Int](4)(_.getInt)
  def short(implicit byteOrder: ByteOrder) = scalar[Short](2)(_.getShort)
  def byte(implicit byteOrder: ByteOrder) = scalar[Byte](1)(_.getByte)

  def list[A](size: Int)(A: Decoder[A]) = Decoder[List[A]] { bytes =>
    val decodedAS = (0 until size).foldLeft(DecoderResult.consumed(List.empty[A], bytes)) { (prev, _) =>
      prev match {
        case NotEnough => NotEnough
        case Consumed(as, bytes) =>
          A.decode(bytes) match {
            case Consumed(a, remaining) => Consumed(a :: as, remaining)
            case NotEnough => NotEnough
          }
      }
    }

    decodedAS match {
      case Consumed(as, remaining) => Consumed(as.reverse, remaining)
      case NotEnough => NotEnough
    }
  }

  def tuple[A, B](A: Decoder[A], B: Decoder[B]): Decoder[(A, B)] = for {
    a <- A
    b <- B
  } yield (a, b)

  def tuple[A, B, C](A: Decoder[A], B: Decoder[B], C: Decoder[C]): Decoder[(A, B, C)] = for {
    a <- A
    b <- B
    c <- C
  } yield (a, b, c)
} 

//设置package包名称以及导入依赖的类
package zeroformatter

import java.nio.{ByteBuffer, ByteOrder}

private[zeroformatter] object BinaryUtil {

  def wrapByteArray(bytes: Array[Byte]): ByteBuffer =
    ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)

  def allocate(capacity: Int): ByteBuffer =
    ByteBuffer.allocate(capacity).order(ByteOrder.LITTLE_ENDIAN)

  def resize(array: Array[Byte], newSize: Int): Array[Byte] = {
    if(array.length != newSize) {
      val array2 = new Array[Byte](newSize)
      val l = array.length
      array.copyToArray(array2, 0, if(l > newSize) newSize else l)
      array2
    }
    else array
  }

  def ensureCapacity(bytes: Array[Byte], offset: Int, appendLength: Int): Array[Byte] = {
    val newLength = offset + appendLength

    val current = bytes.length
    if(newLength > current) {
      val num =
        if(newLength < 256) 256
        else if(newLength < current * 2) current * 2
        else newLength
      resize(bytes, num)
    }
    else bytes
  }
} 

//设置package包名称以及导入依赖的类
package com.esri.gdb

import java.nio.{ByteBuffer, ByteOrder}

import org.apache.hadoop.fs.FSDataInputStream


class DataBuffer(dataInput: FSDataInputStream) extends Serializable {

  private var bytes = new Array[Byte](1024)
  private var byteBuffer = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)

  def readBytes(length: Int) = {
    if (length > bytes.length) {
      bytes = new Array[Byte](length)
      byteBuffer = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)
    }
    else {
      byteBuffer.clear
    }
    dataInput.readFully(bytes, 0, length)
    byteBuffer
  }

  def seek(position: Long) = {
    dataInput.seek(position)
    this
  }

  def close() {
    dataInput.close()
  }
}

object DataBuffer {
  def apply(dataInput: FSDataInputStream) = {
    new DataBuffer(dataInput)
  }
} 

//设置package包名称以及导入依赖的类
package com.dafttech.jasper.render

import java.nio.{ByteBuffer, ByteOrder}

import com.dafttech.jasper.scene.{Entity, RenderingEntity, RenderingGroup}
import com.dafttech.jasper.util.Vertex
import org.lwjgl.opengl.GL11._
import org.lwjgl.opengl.GL12
import org.lwjgl.opengl.GL12._
import org.lwjgl.opengl.GL15._

object ObjectRenderer {
  val objMatBuffer = ByteBuffer.allocateDirect(16 * 4).order(ByteOrder.nativeOrder()).asFloatBuffer()
  val groupMatBuffer = ByteBuffer.allocateDirect(16 * 4).order(ByteOrder.nativeOrder()).asFloatBuffer()

  val Triangles = new ObjectRenderer[RenderingEntity] {
    override def render(input: RenderingEntity): Unit = {
      groupMatBuffer.rewind()
      objMatBuffer.rewind()
      glLoadMatrixf(groupMatBuffer)
      glMultMatrixf(input.transformation.get(objMatBuffer))

      glDrawElements(GL_TRIANGLES, input.getTesselator.getIdxCount(input), GL_UNSIGNED_INT, input.vbLoc.indexPosition * 4)
    }
  }

  val RenderingGroup = new ObjectRenderer[RenderingGroup] {
    override def render(input: RenderingGroup): Unit = {
      input.transformation.get(groupMatBuffer)

      for (e <- input.childs) {
        e.getRenderer.render(e)
      }
    }
  }
}

abstract class ObjectRenderer[T <: Entity] {
  def render(input: T): Unit
} 

//设置package包名称以及导入依赖的类
package io.cosmicteapot


import java.nio.ByteOrder



object Colour {
  type ColourI = Int

  def r(c:ColourI) : Int = c & 0xff
  def g(c:ColourI) : Int = (c >>> 8) & 0xff
  def b(c:ColourI) : Int = (c >>> 16) & 0xff
  def a(c:ColourI) : Int = (c >>> 24) & 0xff

  def rf(c:ColourI) : Float = r(c).asInstanceOf[Float] / 255f
  def gf(c:ColourI) : Float = g(c).asInstanceOf[Float] / 255f
  def bf(c:ColourI) : Float = b(c).asInstanceOf[Float] / 255f
  def af(c:ColourI) : Float = a(c).asInstanceOf[Float] / 255f

  val maskOffOneBit = ~ Integer.parseInt("00000001000000000000000000000000", 2)

  def littleEndian : Boolean = ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN
  def colourI(sample:Array[Int]) : ColourI = colourI(sample(0), sample(1), sample(2), sample(3))
  def colourI(r:Int, g:Int, b:Int, a:Int) : ColourI = {
    val ur = clamp(r, 0, 255)
    val ug = clamp(g, 0, 255)
    val ub = clamp(b, 0, 255)
    val ua = clamp(a, 0, 255)
    if(littleEndian) {
      //      println("we are little endian")
      (ua << 24 | ub << 16 | ug << 8 | ur) & maskOffOneBit // mask off one bit just
    } else {
      //      println("we are not little endian!")
      ur << 24 | ug << 16 | ub << 8 | ua
    }
  }
  def clamp(n:Int, a:Int, b:Int) : Int = {
    if(n < a) a else if(n > b ) b else n
  }

  val white = colourI(255,255,255,255)
  val black = colourI(0, 0, 0, 255)
  val transWhite = colourI(255,255,255,0)
  val transBlack = colourI(0, 0, 0, 0)
} 

//设置package包名称以及导入依赖的类
package com.vivint.ceph.model

import akka.util.ByteString
import java.security.SecureRandom
import java.util.UUID
import java.nio.{ByteOrder,ByteBuffer}
case class ClusterSecrets(
  fsid: UUID,
  adminRing: ByteString,
  monRing: ByteString,
  mdsRing: ByteString,
  osdRing: ByteString,
  rgwRing: ByteString)

object ClusterSecrets {
  lazy val random = new SecureRandom()
  val KeySize = 16
  def generateKey = {
    // 0000000: 0100 3c64 f357 3dfe bd34 1000 2a00 93c7  ..<d.W=..4..*...
    // 0000010: 057f 89b6 c0b0 4682 6d22 33f1            ......F.m"3.
    val b = ByteBuffer.allocate(2 + 8 + 2 + KeySize)
    b.order(ByteOrder.LITTLE_ENDIAN)
    b.putShort(1)
    b.putInt((System.currentTimeMillis / 1000).toInt)
    b.putInt((System.nanoTime).toInt)
    b.putShort(16)
    val bytes = Array.fill[Byte](KeySize)(0)
    random.nextBytes(bytes)
    b.put(bytes)
    ByteString(b.array)
  }

  def generate: ClusterSecrets = {
    ClusterSecrets(
      UUID.randomUUID,
      generateKey,
      generateKey,
      generateKey,
      generateKey,
      generateKey)
  }
} 

//设置package包名称以及导入依赖的类
package org.hammerlab.io

import java.nio.ByteOrder.LITTLE_ENDIAN
import java.nio.{ ByteBuffer, ByteOrder }

object Buffer {
  
  def apply(capacity: Int)(
      implicit order: ByteOrder = LITTLE_ENDIAN
  ): ByteBuffer =
    ByteBuffer
      .allocate(capacity)
      .order(LITTLE_ENDIAN)

  def apply(bytes: Array[Byte]): ByteBuffer = ByteBuffer.wrap(bytes)

  def apply(bytes: Array[Byte], offset: Int, length: Int): ByteBuffer = {
    val buffer = apply(bytes)
    buffer.position(offset)
    buffer.limit(offset + length)
    buffer
  }
}