/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 1.0.1
 * User agent: apibuilder app.apibuilder.io/gilt/ionroller-api/1.0.1/http4s_0_22
 */
package com.gilt.ionroller.api.v1.server

import org.http4s.circe.decodeUri
import org.http4s.circe.encodeUri
import org.http4s.dsl.{io => _, _}
import org.http4s.implicits._
import cats.effect._
import cats.implicits._
import com.gilt.ionroller.api.v1.models.json._

private[server] trait Matchers[F[_]] extends Http4sDsl[F] {

  implicit lazy val queryParamDecodeBigDecimal: org.http4s.QueryParamDecoder[BigDecimal] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[BigDecimal](p => BigDecimal(p.value))("BigDecimal")

  implicit lazy val queryParamDecodeInstant: org.http4s.QueryParamDecoder[_root_.java.time.Instant] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.time.Instant](p => _root_.java.time.OffsetDateTime.parse(p.value).toInstant)("_root_.java.time.Instant")

  implicit lazy val queryParamDecodeLocalDate: org.http4s.QueryParamDecoder[_root_.java.time.LocalDate] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.time.LocalDate](p => _root_.java.time.LocalDate.parse(p.value))("_root_.java.time.LocalDate")

  implicit lazy val queryParamDecodeUUID: org.http4s.QueryParamDecoder[_root_.java.util.UUID] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.util.UUID](p => _root_.java.util.UUID.fromString(p.value))("_root_.java.util.UUID")


  object ApiVersion {
    val ApiVersionMajor = {
      "X-Apidoc-Version-Major".ci
    }

    def apply(req: org.http4s.Message[F]): Boolean = req.headers.get(ApiVersionMajor).map(_.head) match {
      case Some(v) if v.value == "1" => true
      case _ => false
    }
  }

  object InstantVal {
    def unapply(s: String): Option[_root_.java.time.Instant] = scala.util.Try(_root_.java.time.OffsetDateTime.parse(s).toInstant).toOption
  }

  object FromOptInstantMatcher extends OptionalQueryParamDecoderMatcher[_root_.java.time.Instant]("from")

  object ToOptInstantMatcher extends OptionalQueryParamDecoderMatcher[_root_.java.time.Instant]("to")
}

trait ServiceRoutes[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, A]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[com.gilt.ionroller.api.v1.models.Service], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request[F]
  ): F[GetResponse]

  sealed trait GetByServiceNameResponse

  object GetByServiceNameResponse {
    case class HTTP200(value: com.gilt.ionroller.api.v1.models.Service, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByServiceNameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByServiceNameResponse
  }

  def getByServiceName(
    _req: org.http4s.Request[F],
    serviceName: String
  ): F[GetByServiceNameResponse]

  sealed trait PutConfigByServiceNameResponse

  object PutConfigByServiceNameResponse {
    case class HTTP204(headers: Seq[org.http4s.Header.ToRaw] = Nil) extends PutConfigByServiceNameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PutConfigByServiceNameResponse
  }

  def putConfigByServiceName(
    _req: org.http4s.Request[F],
    serviceName: String,
    body: => org.http4s.DecodeResult[F, com.gilt.ionroller.api.v1.models.ServiceConfig]
  ): F[PutConfigByServiceNameResponse]

  sealed trait GetConfigsByServiceNameResponse

  object GetConfigsByServiceNameResponse {
    case class HTTP200(value: Seq[com.gilt.ionroller.api.v1.models.ServiceConfig], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetConfigsByServiceNameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetConfigsByServiceNameResponse
  }

  def getConfigsByServiceName(
    _req: org.http4s.Request[F],
    serviceName: String,
    from: _root_.scala.Option[_root_.java.time.Instant],
    to: _root_.scala.Option[_root_.java.time.Instant]
  ): F[GetConfigsByServiceNameResponse]

  sealed trait GetConfigByServiceNameResponse

  object GetConfigByServiceNameResponse {
    case class HTTP200(value: com.gilt.ionroller.api.v1.models.ServiceConfig, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetConfigByServiceNameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetConfigByServiceNameResponse
  }

  def getConfigByServiceName(
    _req: org.http4s.Request[F],
    serviceName: String
  ): F[GetConfigByServiceNameResponse]

  sealed trait GetConfigsByServiceNameAndTimestampResponse

  object GetConfigsByServiceNameAndTimestampResponse {
    case class HTTP200(value: com.gilt.ionroller.api.v1.models.ServiceConfig, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetConfigsByServiceNameAndTimestampResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetConfigsByServiceNameAndTimestampResponse
  }

  def getConfigsByServiceNameAndTimestamp(
    _req: org.http4s.Request[F],
    serviceName: String,
    timestamp: _root_.java.time.Instant
  ): F[GetConfigsByServiceNameAndTimestampResponse]

  sealed trait DeleteConfigByServiceNameResponse

  object DeleteConfigByServiceNameResponse {
    case class HTTP204(headers: Seq[org.http4s.Header.ToRaw] = Nil) extends DeleteConfigByServiceNameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends DeleteConfigByServiceNameResponse
  }

  def deleteConfigByServiceName(
    _req: org.http4s.Request[F],
    serviceName: String
  ): F[DeleteConfigByServiceNameResponse]

  case class PostReleaseByServiceNameRequest(serviceName: String, version: String, config: _root_.scala.Option[_root_.java.time.Instant])

  implicit val PostReleaseByServiceNameRequestDecoder: _root_.io.circe.Decoder[PostReleaseByServiceNameRequest] = _root_.io.circe.Decoder.instance { a =>
    for {
      serviceName <- a.downField("serviceName").as[String]
      version <- a.downField("version").as[String]
      config <- a.downField("config").as[_root_.scala.Option[_root_.java.time.Instant]]
    } yield {
      PostReleaseByServiceNameRequest(
        serviceName = serviceName,
        version = version,
        config = config
      )
    }
  }

  sealed trait PostReleaseByServiceNameResponse

  object PostReleaseByServiceNameResponse {
    case class HTTP200(value: Long, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends PostReleaseByServiceNameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PostReleaseByServiceNameResponse
  }

  def postReleaseByServiceName(
    _req: org.http4s.Request[F],
    serviceName: String,
    version: String,
    config: _root_.scala.Option[_root_.java.time.Instant]
  ): F[PostReleaseByServiceNameResponse]

  case class PostDropByServiceNameRequest(serviceName: String, version: String, config: _root_.scala.Option[_root_.java.time.Instant], force: Boolean)

  implicit val PostDropByServiceNameRequestDecoder: _root_.io.circe.Decoder[PostDropByServiceNameRequest] = _root_.io.circe.Decoder.instance { a =>
    for {
      serviceName <- a.downField("serviceName").as[String]
      version <- a.downField("version").as[String]
      config <- a.downField("config").as[_root_.scala.Option[_root_.java.time.Instant]]
      force <- a.downField("force").as[Boolean]
    } yield {
      PostDropByServiceNameRequest(
        serviceName = serviceName,
        version = version,
        config = config,
        force = force
      )
    }
  }

  sealed trait PostDropByServiceNameResponse

  object PostDropByServiceNameResponse {
    case class HTTP200(value: Long, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends PostDropByServiceNameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PostDropByServiceNameResponse
  }

  def postDropByServiceName(
    _req: org.http4s.Request[F],
    serviceName: String,
    version: String,
    config: _root_.scala.Option[_root_.java.time.Instant],
    force: Boolean
  ): F[PostDropByServiceNameResponse]

  def apiVersionMatch(req: org.http4s.Message[F]): Boolean = ApiVersion(req)

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "services" if apiVersionMatch(_req) =>
      get(_req).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "services" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "services" / serviceName if apiVersionMatch(_req) =>
      getByServiceName(_req, serviceName).flatMap {
        case GetByServiceNameResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetByServiceNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "services" / serviceName if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ PUT -> Root / "services" / serviceName / "config" if apiVersionMatch(_req) =>
      putConfigByServiceName(_req, serviceName, _req.attemptAs[com.gilt.ionroller.api.v1.models.ServiceConfig]).flatMap {
        case PutConfigByServiceNameResponse.HTTP204(headers) => NoContent(headers: _*)
        case PutConfigByServiceNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ PUT -> Root / "services" / serviceName / "config" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "services" / serviceName / "configs" :? FromOptInstantMatcher(from) +& ToOptInstantMatcher(to) if apiVersionMatch(_req) =>
      getConfigsByServiceName(_req, serviceName, from, to).flatMap {
        case GetConfigsByServiceNameResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetConfigsByServiceNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "services" / serviceName / "configs" :? FromOptInstantMatcher(from) +& ToOptInstantMatcher(to) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "services" / serviceName / "config" if apiVersionMatch(_req) =>
      getConfigByServiceName(_req, serviceName).flatMap {
        case GetConfigByServiceNameResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetConfigByServiceNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "services" / serviceName / "config" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "services" / serviceName / "configs" / InstantVal(timestamp) if apiVersionMatch(_req) =>
      getConfigsByServiceNameAndTimestamp(_req, serviceName, timestamp).flatMap {
        case GetConfigsByServiceNameAndTimestampResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetConfigsByServiceNameAndTimestampResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "services" / serviceName / "configs" / InstantVal(timestamp) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "services" / serviceName / "config" if apiVersionMatch(_req) =>
      deleteConfigByServiceName(_req, serviceName).flatMap {
        case DeleteConfigByServiceNameResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteConfigByServiceNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "services" / serviceName / "config" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "services" / serviceName / "release" if apiVersionMatch(_req) =>
    if (_req.contentType.exists(_.mediaType == _root_.org.http4s.MediaType.application.json)) {
      _req.attemptAs[PostReleaseByServiceNameRequest].value.flatMap{
        case Right(req) =>
          postReleaseByServiceName(_req, req.serviceName, req.version, req.config).flatMap {
            case PostReleaseByServiceNameResponse.HTTP200(value, headers) => Ok(value, headers: _*)
            case PostReleaseByServiceNameResponse.UndocumentedResponse(response) => response
          }
        case Left(_) => BadRequest()
      }
    } else {
        _req.decode[_root_.org.http4s.UrlForm] {
          req =>
            val responseOpt = for {
              serviceName <- req.getFirst("serviceName")
              version <- req.getFirst("version")
              config <- Some(req.getFirst("config").flatMap(f => _root_.io.circe.parser.decode[_root_.java.time.Instant](f).toOption))
            } yield {
                postReleaseByServiceName(_req, serviceName, version, config).flatMap {
                  case PostReleaseByServiceNameResponse.HTTP200(value, headers) => Ok(value, headers: _*)
                  case PostReleaseByServiceNameResponse.UndocumentedResponse(response) => response
                }
              }
            responseOpt.getOrElse(BadRequest())
      }
    }
    case _req @ POST -> Root / "services" / serviceName / "release" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "services" / serviceName / "drop" if apiVersionMatch(_req) =>
    if (_req.contentType.exists(_.mediaType == _root_.org.http4s.MediaType.application.json)) {
      _req.attemptAs[PostDropByServiceNameRequest].value.flatMap{
        case Right(req) =>
          postDropByServiceName(_req, req.serviceName, req.version, req.config, req.force).flatMap {
            case PostDropByServiceNameResponse.HTTP200(value, headers) => Ok(value, headers: _*)
            case PostDropByServiceNameResponse.UndocumentedResponse(response) => response
          }
        case Left(_) => BadRequest()
      }
    } else {
        _req.decode[_root_.org.http4s.UrlForm] {
          req =>
            val responseOpt = for {
              serviceName <- req.getFirst("serviceName")
              version <- req.getFirst("version")
              config <- Some(req.getFirst("config").flatMap(f => _root_.io.circe.parser.decode[_root_.java.time.Instant](f).toOption))
              force <- req.getFirst("force").flatMap(f => _root_.io.circe.parser.decode[Boolean](f).toOption)
            } yield {
                postDropByServiceName(_req, serviceName, version, config, force).flatMap {
                  case PostDropByServiceNameResponse.HTTP200(value, headers) => Ok(value, headers: _*)
                  case PostDropByServiceNameResponse.UndocumentedResponse(response) => response
                }
              }
            responseOpt.getOrElse(BadRequest())
      }
    }
    case _req @ POST -> Root / "services" / serviceName / "drop" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}