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

import org.http4s.dsl._

import com.gilt.public.api.models.json._

private[server] object Matchers {

  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): Boolean = req.headers.get(ApiVersionMajor) match {
      case Some(v) if v.value == "1" => true
      case _ => false
    }
  }

  object StoreVal {
    def unapply(s: String): Option[com.gilt.public.api.models.Store] = com.gilt.public.api.models.Store.fromString(s)
  }

  object ApikeyStringMatcher extends QueryParamDecoderMatcher[String]("apikey")
}

trait ProductRoutes {

  import Matchers._

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

  sealed trait GetDetailJsonByProductIdResponse

  object GetDetailJsonByProductIdResponse {
    case class HTTP200(value: com.gilt.public.api.models.Product, headers: Seq[org.http4s.Header] = Nil) extends GetDetailJsonByProductIdResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetDetailJsonByProductIdResponse
  }

  def getDetailJsonByProductId(
    _req: org.http4s.Request,
    productId: String,
    apikey: String
  ): scalaz.concurrent.Task[GetDetailJsonByProductIdResponse]

  sealed trait GetCategoriesJsonResponse

  object GetCategoriesJsonResponse {
    case class HTTP200(value: com.gilt.public.api.models.ProductCategories, headers: Seq[org.http4s.Header] = Nil) extends GetCategoriesJsonResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetCategoriesJsonResponse
  }

  def getCategoriesJson(
    _req: org.http4s.Request,
    apikey: String
  ): scalaz.concurrent.Task[GetCategoriesJsonResponse]

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

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "products" / productId / "detail.json" :? ApikeyStringMatcher(apikey) if apiVersionMatch(_req) =>
      getDetailJsonByProductId(_req, productId, apikey).flatMap {
        case GetDetailJsonByProductIdResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetDetailJsonByProductIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "products" / productId / "detail.json" :? ApikeyStringMatcher(apikey) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "products" / "categories.json" :? ApikeyStringMatcher(apikey) if apiVersionMatch(_req) =>
      getCategoriesJson(_req, apikey).flatMap {
        case GetCategoriesJsonResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetCategoriesJsonResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "products" / "categories.json" :? ApikeyStringMatcher(apikey) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait SaleDetailRoutes {

  import Matchers._

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

  sealed trait GetDetailJsonResponse

  object GetDetailJsonResponse {
    case class HTTP200(value: com.gilt.public.api.models.SaleDetail, headers: Seq[org.http4s.Header] = Nil) extends GetDetailJsonResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetDetailJsonResponse
  }

  def getDetailJson(
    _req: org.http4s.Request,
    store: com.gilt.public.api.models.Store,
    sale: String,
    apikey: String
  ): scalaz.concurrent.Task[GetDetailJsonResponse]

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

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "sales" / StoreVal(store) / ":saledetail.json" :? ApikeyStringMatcher(apikey) if apiVersionMatch(_req) =>
      getDetailJson(_req, store, sale, apikey).flatMap {
        case GetDetailJsonResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetDetailJsonResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "sales" / StoreVal(store) / ":saledetail.json" :? ApikeyStringMatcher(apikey) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait SaleListRoutes {

  import Matchers._

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

  sealed trait GetActiveJsonResponse

  object GetActiveJsonResponse {
    case class HTTP200(value: com.gilt.public.api.models.SaleList, headers: Seq[org.http4s.Header] = Nil) extends GetActiveJsonResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetActiveJsonResponse
  }

  def getActiveJson(
    _req: org.http4s.Request,
    apikey: String
  ): scalaz.concurrent.Task[GetActiveJsonResponse]

  sealed trait GetActiveJsonByStoreResponse

  object GetActiveJsonByStoreResponse {
    case class HTTP200(value: com.gilt.public.api.models.SaleList, headers: Seq[org.http4s.Header] = Nil) extends GetActiveJsonByStoreResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetActiveJsonByStoreResponse
  }

  def getActiveJsonByStore(
    _req: org.http4s.Request,
    store: String,
    apikey: String
  ): scalaz.concurrent.Task[GetActiveJsonByStoreResponse]

  sealed trait GetUpcomingJsonResponse

  object GetUpcomingJsonResponse {
    case class HTTP200(value: com.gilt.public.api.models.SaleList, headers: Seq[org.http4s.Header] = Nil) extends GetUpcomingJsonResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetUpcomingJsonResponse
  }

  def getUpcomingJson(
    _req: org.http4s.Request,
    apikey: String
  ): scalaz.concurrent.Task[GetUpcomingJsonResponse]

  sealed trait GetUpcomingJsonByStoreResponse

  object GetUpcomingJsonByStoreResponse {
    case class HTTP200(value: com.gilt.public.api.models.SaleList, headers: Seq[org.http4s.Header] = Nil) extends GetUpcomingJsonByStoreResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetUpcomingJsonByStoreResponse
  }

  def getUpcomingJsonByStore(
    _req: org.http4s.Request,
    store: String,
    apikey: String
  ): scalaz.concurrent.Task[GetUpcomingJsonByStoreResponse]

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

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "sales" / "active.json" :? ApikeyStringMatcher(apikey) if apiVersionMatch(_req) =>
      getActiveJson(_req, apikey).flatMap {
        case GetActiveJsonResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetActiveJsonResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "sales" / "active.json" :? ApikeyStringMatcher(apikey) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "sales" / store / "active.json" :? ApikeyStringMatcher(apikey) if apiVersionMatch(_req) =>
      getActiveJsonByStore(_req, store, apikey).flatMap {
        case GetActiveJsonByStoreResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetActiveJsonByStoreResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "sales" / store / "active.json" :? ApikeyStringMatcher(apikey) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "sales" / "upcoming.json" :? ApikeyStringMatcher(apikey) if apiVersionMatch(_req) =>
      getUpcomingJson(_req, apikey).flatMap {
        case GetUpcomingJsonResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetUpcomingJsonResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "sales" / "upcoming.json" :? ApikeyStringMatcher(apikey) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "sales" / store / "upcoming.json" :? ApikeyStringMatcher(apikey) if apiVersionMatch(_req) =>
      getUpcomingJsonByStore(_req, store, apikey).flatMap {
        case GetUpcomingJsonByStoreResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetUpcomingJsonByStoreResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "sales" / store / "upcoming.json" :? ApikeyStringMatcher(apikey) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}