//设置package包名称以及导入依赖的类
package com.realizationtime.btdogg.persist

import java.time.{Instant, LocalDate}

import com.realizationtime.btdogg.TKey
import com.realizationtime.btdogg.parsing.ParsingResult.{FileEntry, TorrentDir, TorrentFile}
import com.realizationtime.btdogg.persist.MongoPersist.{Liveness, TorrentDocument}
import com.realizationtime.btdogg.persist.MongoTorrentWriter.localDateToString
import reactivemongo.bson.{BSONDateTime, BSONDocument, BSONDocumentWriter, BSONInteger, BSONString, BSONWriter, Macros}

trait MongoTorrentWriter {

  implicit val tkeyWriter = new BSONWriter[TKey, BSONString] {
    override def write(k: TKey): BSONString = BSONString(k.hash)
  }
  implicit val torrentDataFileWriter: BSONDocumentWriter[TorrentFile] = Macros.writer[TorrentFile]
  implicit val torrentDataDirWriter: BSONDocumentWriter[TorrentDir] = Macros.writer[TorrentDir]
  implicit val torrentDataWriter: BSONDocumentWriter[FileEntry] = Macros.writer[FileEntry]
  implicit val instantWriter = new BSONWriter[Instant, BSONDateTime] {
    override def write(t: Instant): BSONDateTime = BSONDateTime(t.toEpochMilli)
  }

  implicit val torrentWriter: BSONDocumentWriter[TorrentDocument] = Macros.writer[TorrentDocument]

  implicit val livenessWriter: BSONDocumentWriter[Liveness] = Macros.writer[Liveness]

  implicit val localDateWriter = new BSONWriter[LocalDate, BSONString] {
    override def write(t: LocalDate): BSONString = BSONString(localDateToString(t))
  }

  implicit val mapWriter: BSONDocumentWriter[Map[LocalDate, Int]] = new BSONDocumentWriter[Map[LocalDate, Int]] {
    def write(map: Map[LocalDate, Int]): BSONDocument = {
      val elements = map.toStream.map { tuple =>
        localDateToString(tuple._1) -> BSONInteger(tuple._2)
      }
      BSONDocument(elements)
    }
  }

}

object MongoTorrentWriter {

  def localDateToString(date: LocalDate): String = date.toString

} 

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

case class AggregateVote(up: Int, down: Int, nb: Int, ratio: Int) {

  def add(v: Boolean) = copy(
    up = up + v.fold(1, 0),
    down = down + v.fold(0, 1)
  ).computeNbAndRatio

  def change(from: Boolean, to: Boolean) = if (from == to) this else copy(
    up = up + to.fold(1, -1),
    down = down + to.fold(-1, 1)
  ).computeNbAndRatio

  def count = up + down

  def sum = up - down

  def computeNbAndRatio = if (up + down > 0) copy(
    ratio = 100 * (up - down) / (up + down),
    nb = up + down
  )
  else copy(
    ratio = 1,
    nb = 0
  )
}

object AggregateVote {

  val default = AggregateVote(1, 0, 1, 100)
  val disable = AggregateVote(0, 9000, 9000, -100).computeNbAndRatio

  val minRatio = -50
  val minVotes = 30

  import reactivemongo.bson.Macros
  implicit val aggregatevoteBSONHandler = Macros.handler[AggregateVote]
} 

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

import java.security.MessageDigest
import lila.db.ByteArray
import org.joda.time.DateTime

private[game] case class Metadata(
    source: Option[Source],
    pgnImport: Option[PgnImport],
    tournamentId: Option[String],
    simulId: Option[String],
    tvAt: Option[DateTime],
    analysed: Boolean
) {

  def pgnDate = pgnImport flatMap (_.date)

  def pgnUser = pgnImport flatMap (_.user)

  def isEmpty = this == Metadata.empty
}

private[game] object Metadata {

  val empty = Metadata(None, None, None, None, None, false)
}

case class PgnImport(
  user: Option[String],
  date: Option[String],
  pgn: String,
  // hashed PGN for DB unicity
  h: Option[ByteArray]
)

object PgnImport {

  def hash(pgn: String) = ByteArray {
    MessageDigest getInstance "MD5" digest
      pgn.lines.map(_.replace(" ", "")).filter(_.nonEmpty).mkString("\n").getBytes("UTF-8") take 12
  }

  def make(
    user: Option[String],
    date: Option[String],
    pgn: String
  ) = PgnImport(
    user = user,
    date = date,
    pgn = pgn,
    h = hash(pgn).some
  )

  import reactivemongo.bson.Macros
  import ByteArray.ByteArrayBSONHandler
  implicit val pgnImportBSONHandler = Macros.handler[PgnImport]
} 

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

import ocr.model.OcrTextAnnotation
import reactivemongo.bson.{BSONDocument, BSONDocumentReader, BSONDocumentWriter, Macros}

case class OcrEntity(
    id: String,
    userId: String,
    result: OcrTextAnnotation
) extends WithId

case class OcrText(text: String)

case class OcrTextOnly(
    id: String,
    result: OcrText
) extends WithId

object OcrTextOnly {
  implicit def ocrTextReader: BSONDocumentReader[OcrText] = Macros.reader[OcrText]
  implicit object OcrTextOnlyBSONReader extends BSONDocumentReader[OcrTextOnly] {

    def read(doc: BSONDocument): OcrTextOnly =
      Serialization.deserialize(doc,
                                OcrTextOnly(
                                  id = doc.getAs[String]("_id").get,
                                  result = doc.getAs[OcrText]("result").get
                                ))
  }
}

object OcrEntity {

  implicit object OcrEntityBSONReader extends BSONDocumentReader[OcrEntity] {

    def read(doc: BSONDocument): OcrEntity =
      Serialization.deserialize(doc,
                                OcrEntity(
                                  id = doc.getAs[String]("_id").get,
                                  userId = doc.getAs[String]("userId").get,
                                  result = doc.getAs[OcrTextAnnotation]("result").get
                                ))
  }

  implicit object OcrEntityBSONWriter extends BSONDocumentWriter[OcrEntity] {

    def write(ocrResult: OcrEntity): BSONDocument = {
      BSONDocument(
        "_id"    -> ocrResult.id,
        "userId" -> ocrResult.userId,
        "result" -> ocrResult.result
      )
    }
  }
}