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

import com.google.common.primitives.{Bytes, Ints}
import io.swagger.annotations.ApiModelProperty
import play.api.libs.json._
import scorex.crypto.encode.Base58

import scala.collection.immutable.Stream
import scala.util.{Failure, Success}

case class BlockCheckpoint(height: Int,
                           @ApiModelProperty(dataType = "java.lang.String") signature: Array[Byte])

case class Checkpoint(items: Seq[BlockCheckpoint],
                      @ApiModelProperty(dataType = "java.lang.String")signature: Array[Byte]) {
  def toSign: Array[Byte] = {
    val length = items.size
    val lengthBytes = Ints.toByteArray(length)

    items.foldLeft(lengthBytes) { case (bs, BlockCheckpoint(h, s)) =>
      Bytes.concat(bs, Ints.toByteArray(h), s)
    }
  }
}

object Checkpoint {
  def historyPoints(n: Int, maxRollback: Int, resultSize: Int = MaxCheckpoints): Seq[Int] =
    mult(maxRollback, 2).map(n - _).takeWhile(_ > 0).take(resultSize)

  private def mult(start: Int, step: Int): Stream[Int] =
    Stream.cons(start, mult(start * step, step))

  val MaxCheckpoints = 10

  implicit val byteArrayReads = new Reads[Array[Byte]] {
    def reads(json: JsValue) = json match {
      case JsString(s) => Base58.decode(s) match {
        case Success(bytes) if bytes.length == scorex.transaction.TransactionParser.SignatureLength => JsSuccess(bytes)
        case Success(bytes) => JsError(JsonValidationError("error.incorrect.signatureLength", bytes.length.toString))
        case Failure(t) => JsError(JsonValidationError(Seq("error.incorrect.base58", t.getLocalizedMessage), s))
      }
      case _ => JsError("error.expected.jsstring")
    }
  }

  implicit val blockCheckpointFormat: Reads[BlockCheckpoint] = Json.reads
  implicit val checkpointFormat: Reads[Checkpoint] = Json.reads
} 

//设置package包名称以及导入依赖的类
import scala.collection.immutable.Stream

object Numbers {

  private lazy val N: Stream[BigInt] = BigInt(1) #:: N.map(_ + BigInt(1))

  
  def binomialCoef(n: Int, k: Int): Option[Long] = {
    type Cache = Map[(Int, Int), Long]
    def memoizedBinCoef(ni: Int, ki: Int)(cache: Cache): (Long, Cache) =
      if(ni == ki) 1L -> cache
      else if(ki == 1) ni.toLong -> cache
      else cache.get(ni -> ki).map(_ -> cache) getOrElse {
        val (a, aCache) = memoizedBinCoef(ni-1, ki-1)(cache)
        val (b, bCache) = memoizedBinCoef(ni-1, ki)(aCache)
        (a+b, bCache.updated(ni -> ki, a+b))
      }
    if(n < 1 || k < 1 || n < k) None
    else Some(memoizedBinCoef(n,k)(Map.empty)._1)
  }

}