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

import play.api.libs.json.JsResult
import play.api.mvc.{Result, Controller}

import scala.concurrent.Future

trait ControllerUtils extends Logged {
  self: Controller =>

  def transformAsFuture[T](json: JsResult[T]): Future[T] =
    if (json.isSuccess) Future.successful(json.get)
    else {
      log.debug(s"unable to parse json value: $json")
      Future.failed(new Exception("error parsing json"))
    }

  val withRecover: PartialFunction[Throwable, Result] = {
    case e: Exception => BadRequest(s"bad request: ${e.getMessage}")
  }
} 

//设置package包名称以及导入依赖的类
package com.clemble.loveit.thank.model

import com.clemble.loveit.common.model.{Resource, UserID}
import com.clemble.loveit.common.util.WriteableUtils
import play.api.libs.json.{Format, JsResult, JsValue, Json}


  val verification: Option[ROVerification[Resource]]
}

object UserResource {

  def empty(user: UserID): UserResource = SimpleUserResource(user)

  implicit val jsonFormat: Format[UserResource] = new Format[UserResource] {
    override def reads(json: JsValue): JsResult[UserResource] = SimpleUserResource.jsonFormat.reads(json)
    override def writes(o: UserResource): JsValue = SimpleUserResource.jsonFormat.writes(SimpleUserResource(o.id, o.owns, o.verification))
  }

  implicit val writeable = WriteableUtils.jsonToWriteable[UserResource]()
}

private case class SimpleUserResource(
                               id: UserID,
                               owns: Set[Resource] = Set.empty,
                               verification: Option[ROVerification[Resource]] = None
                             ) extends UserResource

private object SimpleUserResource {
  implicit val jsonFormat = Json.format[SimpleUserResource]
} 

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

import javax.inject.Inject

import akka.actor.ActorRef
import akka.stream.scaladsl.Source
import akka.util.Timeout
import com.github.jeroenr.bson.BsonDocument
import com.github.jeroenr.bson.BsonDsl._
import helpers.BsonDocumentHelper._
import play.api.libs.json.{JsResult, JsSuccess, Json}
import play.api.modules.tepkinmongo.TepkinMongoApi

import scala.concurrent.Future
import scala.concurrent.duration._

case class Project(_id: String, name: String)

object Project {
  implicit val projectFormatter = Json.format[Project]
  def apply(bson: BsonDocument): JsResult[Project] = {
    Json.fromJson[Project](bson)
  }

  def toBsonDocument(project: Project): BsonDocument =
    ("_id" := project._id) ~
      ("name" := project.name)
}


class ProjectRepo @Inject() (tepkinMongoApi: TepkinMongoApi) {
  implicit val ec = tepkinMongoApi.client.ec
  implicit val timeout: Timeout = 5.seconds

  val projects = tepkinMongoApi.client("tepkin")("projects")

  def create(name: String): Future[Boolean] = {
    val project = "name" := name
    projects.insert(project).map(_.ok)
  }

  def all: Source[List[Project], ActorRef] = {
    projects.find(new BsonDocument()).map(l => l.map(Project(_)).collect {
      case JsSuccess(p, _ ) => p
    })
  }

  def insert(ps: List[Project]) =
    projects.insert(ps.map(Project.toBsonDocument))

  def findByName(name: String): Future[Option[Project]] = {
    val byId = "name" := name
    projects.findOne(byId).map(_.flatMap(Project(_).asOpt))
  }


} 

//设置package包名称以及导入依赖的类
package com.malliina.logstreams.ws

import com.malliina.logstreams.models._
import com.malliina.logstreams.ws.SourceMediator.{SourceInfo, SourceJoined}
import com.malliina.play.ws.{ClientActor, ClientContext}
import play.api.libs.json.{JsResult, JsValue, Json}

class SourceActor(app: AppName, ctx: ClientContext) extends ClientActor(ctx) {
  val src = LogSource(app, address)

  override def preStart(): Unit = {
    super.preStart()
    mediator ! SourceJoined(SourceInfo(src, ctx.out))
  }

  override def transform(message: JsValue): JsResult[JsValue] =
    message.validate[LogEvents].map(les => Json.toJson(toAppEvents(les)))

  def toAppEvents(logEvents: LogEvents) = {
    val appEvents = logEvents.events.map(event => AppLogEvent(src, event))
    AppLogEvents(appEvents)
  }
} 

//设置package包名称以及导入依赖的类
package com.gxq.learn.recontool.utils

import com.gxq.learn.recontool.entity.ReconToolTSchema
import org.apache.spark.SparkContext
import play.api.libs.json.Json
import play.api.libs.json.JsValue
import play.api.libs.json.JsResult
import play.api.libs.json.JsSuccess
import play.api.libs.json.JsPath
import play.api.libs.json.JsError
import scala.collection.SortedMap

object TSchemaUtil {
  def getTSchema(sc: SparkContext, fileUrl: String): ReconToolTSchema = {
    val jsonString = sc.textFile(fileUrl).collect().mkString
    implicit val rtReads = Json.reads[ReconToolTSchema]
    val jsonValue: JsValue = Json.parse(jsonString)
    val rtFromJson: JsResult[ReconToolTSchema] = Json.fromJson[ReconToolTSchema](jsonValue)
    val result = rtFromJson match {
      case JsSuccess(rt: ReconToolTSchema, path: JsPath) => rt
      case e: JsError                                    => throw new IllegalArgumentException(JsError.toJson(e).toString())
    }
    result
  }

  def getHeaderIndexMap(header: String): SortedMap[Int, String] = {
    var headMap = SortedMap[Int, String]()
    val hArr = header.split(",", -1)
    for (i <- 0 until hArr.length) {
      headMap = headMap + (i -> hArr(i).trim())
    }
    headMap
  }
} 

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

import models.{ErrorResponse, Person}
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsPath, JsResult, JsValue, Json}
import play.api.mvc.{Action, AnyContent, Controller}
import ErrorResponse._

class PersonController extends Controller {
  def personById(personId: String): Action[AnyContent] = Action {
    Ok(personId)
  }

  def echo: Action[JsValue] = Action(parse.json) {
    implicit request =>
      val eitherPerson = validateParsedResult(request.body.validate[Person])
      eitherPerson.fold(
        errorResponse => BadRequest(Json.toJson(errorResponse)),
        person => Ok(Json.toJson(person))
      )
  }

  def validateParsedResult[T](jsResult: JsResult[T]): Either[ErrorResponse, T] =
    jsResult.fold(
      (errors: Seq[(JsPath, Seq[ValidationError])]) => {
        val map = fmtValidationResults(errors)
        Left(ErrorResponse("Validation Error", map))
      },
      (t: T) => Right(t)
    )
} 

//设置package包名称以及导入依赖的类
package com.takatori.hundredthings.controllers

import com.takatori.hundredthings.dao.ThingDao
import com.takatori.hundredthings.models.Thing
import play.api.libs.json.{JsError, JsResult, Json}
import play.api.mvc.{Action, Controller}

import scala.concurrent.{ExecutionContext, Future}

class ThingController(thingDao: ThingDao)(implicit ec: ExecutionContext) extends Controller {

  def list(userId: Int) = Action.async { request =>
    thingDao.list(userId) map { things => Ok(Json.toJson(things)) }
  }

  def fetch(id: Int) = Action.async { request =>
    thingDao.fetch(id) map { thing => Ok(Json.toJson(thing)) }
  }

  def create(userId: Int) = Action.async(parse.json) { request =>
    val thingResult: JsResult[Thing] = request.body.validate[Thing]
    thingResult.fold(
      errors => Future.successful(BadRequest(Json.obj("status" -> "KO", "message" -> JsError.toJson(errors)))),
      thing => {
        thingDao.create(userId, thing) map { id =>
          Ok(Json.obj("status" -> "OK", "message" -> ("Place" +  id + "saved.")))
        }
      }
    )
  }

  def update(thingId: Int) = Action.async(parse.json) { request =>
    val thingResult: JsResult[Thing] = request.body.validate[Thing]
    thingResult.fold(
      errors => Future.successful(BadRequest(Json.obj("status" -> "KO", "message" -> JsError.toJson(errors)))),
      thing => {
        thingDao.update(thingId, thing) map { affetctedRows =>
          Ok(Json.obj("status" -> "OK", "message" -> ("Place '" + thing.title + "' update.")))
        }
      })
  }

  def delete(thingId: Int) = Action.async { request =>
    thingDao.delete(thingId) map { result => Ok(Json.toJson("Succeed in delete thing.")) }
  }
} 

//设置package包名称以及导入依赖的类
package com.takatori.hundredthings.controllers

import com.takatori.hundredthings.dao.UserDao
import com.takatori.hundredthings.models.User
import play.api.libs.json.{JsError, JsResult, Json}
import play.api.mvc.{Action, Controller}

import scala.concurrent.{ExecutionContext, Future}

class UserController(userDao: UserDao)(implicit ec: ExecutionContext) extends Controller {

  def fetchAll() = Action.async { request => userDao.all.map { users => Ok(Json.toJson(users)) } }

  def fetch(userId: Int) = Action.async { request =>
    userDao.fetch(userId) map { user => Ok(Json.toJson(user)) }
    //BadRequest(Json.obj("status" -> "KO", "message" -> JsError.toJson("not found")))
  }

  def insert() = Action.async(parse.json) { request =>
    val userResult: JsResult[User] = request.body.validate[User]
    // Future[Result]???????????
    userResult.fold(
      errors => Future.successful(BadRequest(Json.obj("status" -> "KO", "message" -> JsError.toJson(errors)))),
      user => {
        userDao.insert(user) map { id =>
            Ok(Json.obj("status" -> "OK", "message" -> ("Place '" + user.name + "' saved.")))
        }
      })
  }

  def update(userId: Int) = Action.async(parse.json) { request =>
    val userResult: JsResult[User] = request.body.validate[User]
    userResult.fold(
      errors => Future.successful(BadRequest(Json.obj("status" -> "KO", "message" -> JsError.toJson(errors)))),
      user => {
        userDao.update(userId, user) map { affetctedRows =>
          Ok(Json.obj("status" -> "OK", "message" -> ("Place '" + user.name + "' update.")))
        }
      })
  }

  def delete(userId: Int) = Action.async { request =>
    userDao.delete(userId) map { result => Ok(Json.toJson("Succeed in delete user.")) } // TODO: ??????
  }
} 

//设置package包名称以及导入依赖的类
package lifelines
package models
package messages

import play.api.libs.json.{ Format, Json, JsError, JsResult, JsSuccess }
import play.api.libs.json.{ JsValue, JsObject, JsString }

case class Input(action: String)
object Input {
  implicit val jsonFormat = new Format[Input] {
    def reads(json: JsValue): JsResult[Input] = {
      (json \ "action").validate[String].map(Input(_))
    }
    def writes(input: Input): JsValue = {
      Json.obj("action" -> input.action)
    }
  }
}

sealed trait Output
case object Talking extends Output
case class Talk(content: String) extends Output
case class Info(content: String) extends Output
case class Error(content: String) extends Output
case class Choices(choices: Map[String, String]) extends Output
object Output {
  implicit val jsonFormat = new Format[Output] {
    def reads(json: JsValue): JsResult[Output] = {
      (json \ "kind").validate[String].flatMap {
        case "talking" => JsSuccess(Talking)
        case "talk" => (json \ "message").validate[String].map(Talk(_))
        case "info" => (json \ "message").validate[String].map(Info(_))
        case "error" => (json \ "message").validate[String].map(Error(_))
        case "choices" => (json \ "choices").validate[Map[String, String]].map(Choices(_))
        case _ => JsError("Unknown kind")
      }
    }
    def writes(o: Output): JsValue = o match {
      case Talking => Json.obj("kind" -> "talking")
      case Talk(content) => Json.obj("kind" -> "talk", "message" -> content)
      case Info(content) => Json.obj("kind" -> "info", "message" -> content)
      case Error(content) => Json.obj("kind" -> "error", "message" -> content)
      case Choices(choices) => Json.obj(
        "kind" -> "choices",
        "choices" -> JsObject(choices.toSeq.map{ case (n, v) => n -> JsString(v) })
      )
    }
  }
} 

//设置package包名称以及导入依赖的类
package storage.local.collection

import java.io.File
import java.nio.file.{Files, Paths}

import play.api.libs.json.{JsResult, Json}
import storage.model.StorageModelUser

object LocalCollectionUserTest extends LocalCollection[StorageModelUser] {
  override def collectionName: String = "userTest"

  override def getBaseDirectory: Option[String] = {
    val basePath = System.getProperty("user.dir") + File.separator + "data" + File.separator + collectionName
    try {
      if (Files.exists(Paths.get(basePath))) {
        Some(basePath)
      } else {
        try {
          Files.createDirectories(Paths.get(basePath))
          Some(basePath)
        } catch {
          case e: Exception => None
        }
      }
    } catch {
      case e: Exception => None
    }
  }


  override def serialize(data: StorageModelUser): Array[Byte] = {
    Json.stringify(Json.toJson(data)).getBytes()
  }

  override def deserialize(serializedData: Array[Byte]): JsResult[StorageModelUser] = {
    Json.fromJson[StorageModelUser](Json.parse(serializedData))
  }
} 

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

import models.player.{Player, Rank}
import models.Model
import play.api.libs.json.{JsObject, JsResult, JsValue, Json}
import utils.JsonUtils


case class PingpongMatch(
                      id: String,
                      playerA: Option[Player],
                      playerB: Option[Player],
                      roundId: String,
                      handicap: Int,
                      isHandicapForB: Boolean,
                      targetScore: Int,
                      numberOfSetsToWin: Int,
                      wonSetsA: Int,
                      wonSetsB: Int,
                      games: List[PingpongGame])

object MatchEvidence{

  implicit object matchIsModel extends Model[PingpongMatch]{
    override def getId(m: PingpongMatch): Option[String] = Some(m.id)

    override def setId(id: String)(m: PingpongMatch): PingpongMatch = m.copy(id = id)

    implicit val rankFormat = Json.format[Rank]
    implicit val playerFormat = Json.format[Player]
    val optionPlayerWrites = JsonUtils.optionWrites(playerFormat)
    implicit val gameWrites = Json.format[PingpongGame]
    override def writes(o: PingpongMatch): JsObject = Json.format[PingpongMatch].writes(o)

    override def reads(json: JsValue): JsResult[PingpongMatch] = Json.format[PingpongMatch].reads(json)
  }
}

object MatchChecker{
  def calculateSets(pingpongMatch: PingpongMatch): PingpongMatch = {
    val result = pingpongMatch.games.foldLeft[(Int, Int)]((0,0)){ (acc, game) => {
      if(game.pointA == pingpongMatch.targetScore || (game.pointA - 2 == game.pointB && game.pointA> pingpongMatch.targetScore)){
       (acc._1 + 1, acc._2)
      } else if(game.pointB == pingpongMatch.targetScore || (game.pointB - 2 == game.pointA && game.pointB> pingpongMatch.targetScore)){
        (acc._1 , acc._2 + 1)
      } else {
        acc
      }
    }}

    pingpongMatch.copy(wonSetsA = result._1, wonSetsB = result._2)
  }

  def isWon(pingpongMatch: PingpongMatch): Boolean = {
    val checkecMatch = calculateSets(pingpongMatch)
    (checkecMatch.wonSetsA > checkecMatch.wonSetsB) && checkecMatch.wonSetsA == checkecMatch.numberOfSetsToWin ||
      checkecMatch.wonSetsA < checkecMatch.wonSetsB && checkecMatch.wonSetsB == checkecMatch.numberOfSetsToWin
  }
} 

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

import models.player.SeriesPlayer
import play.api.libs.json.{JsObject, JsResult, JsValue, Json}

case class TournamentSeries(
                             id: String,
                             seriesName: String,
                             seriesColor: String,
                             numberOfSetsToWin: Int,
                             setTargetScore: Int,
                             playingWithHandicaps: Boolean,
                             extraHandicapForRecs: Int,
                             showReferees: Boolean,
                             currentRoundNr: Int=1,
                             tournamentId: String)
  object SeriesEvidence {

    implicit object seriesIsModel extends Model[TournamentSeries] {
      override def getId(m: TournamentSeries): Option[String] = Some(m.id)

      override def setId(id: String)(m: TournamentSeries): TournamentSeries = m.copy(id = id)

      override def writes(o: TournamentSeries): JsObject = Json.format[TournamentSeries].writes(o)

      override def reads(json: JsValue): JsResult[TournamentSeries] = Json.format[TournamentSeries].reads(json)
    }

  }

case class SeriesWithPlayers(seriesId: String,
                             seriesName: String,
                             seriesColor: String,
                             numberOfSetsToWin: Int,
                             setTargetScore: Int,
                             playingWithHandicaps: Boolean,
                             extraHandicapForRecs: Int,
                             showReferees: Boolean,
                             currentRoundNr: Int=1,
                             seriesPlayers: List[SeriesPlayer],
                             tournamentId: String) 

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

import _root_.io.really.ReallyGlobals
import play.api.libs.json.{ JsObject, JsResult, JsValue, JsPath }

case class SequenceField[T](
    key: FieldKey,
    dataType: DataType[T],
    validationExpression: Option[JsScript],
    default: Option[JsScript],
    required: Boolean
)(implicit val globals: ReallyGlobals) extends ActiveField[T] {
  override def read(root: JsPath, in: JsObject): JsResult[JsObject] = ???

  def runThroughValidator(path: JsPath, in: JsValue): JsResult[JsObject] = ???

  protected def readDefault(path: JsPath): JsResult[JsValue] = ???

}