/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 1.1.0
 * User agent: apibuilder app.apibuilder.io/paintbatch-com/paint-batch-optimizer/1.1.0/http4s_0_15
 */
package com.paintbatch.models {

  package object json {
    import io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import com.paintbatch.models.json._

    // Make Scala 2.11 Either monadic
    private[paintbatch] implicit def eitherOps[A,B](e: Either[A,B]) = cats.implicits.catsSyntaxEither(e)

    private[paintbatch] implicit val decodeUUID: Decoder[_root_.java.util.UUID] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.util.UUID.fromString(str)))

    private[paintbatch] implicit val encodeUUID: Encoder[_root_.java.util.UUID] =
      Encoder.encodeString.contramap[_root_.java.util.UUID](uuid => uuid.toString)

    private[paintbatch] implicit val decodeInstant: Decoder[_root_.java.time.Instant] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.OffsetDateTime.parse(str).toInstant))

    private[paintbatch] implicit val encodeInstant: Encoder[_root_.java.time.Instant] =
      Encoder.encodeString.contramap[_root_.java.time.Instant](_.toString)

    private[paintbatch] implicit val decodeLocalDate: Decoder[_root_.java.time.LocalDate] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.LocalDate.parse(str)))

    private[paintbatch] implicit val encodeLocalDate: Encoder[_root_.java.time.LocalDate] =
      Encoder.encodeString.contramap[_root_.java.time.LocalDate](_.toString)

    implicit val jsonDecoderPaintBatchOptimizerSheen: Decoder[com.paintbatch.models.Sheen] =
      Decoder.decodeString.map(com.paintbatch.models.Sheen(_))

    implicit val jsonEncoderPaintBatchOptimizerSheen: Encoder[com.paintbatch.models.Sheen] =
      Encoder.encodeString.contramap[com.paintbatch.models.Sheen](_.toString)

    implicit val jsonDecoderPaintBatchOptimizerStatus: Decoder[com.paintbatch.models.Status] =
      Decoder.decodeString.map(com.paintbatch.models.Status(_))

    implicit val jsonEncoderPaintBatchOptimizerStatus: Encoder[com.paintbatch.models.Status] =
      Encoder.encodeString.contramap[com.paintbatch.models.Status](_.toString)

    implicit def decodePaintBatchOptimizerDemand: Decoder[Demand] = Decoder.instance { c =>
     for {
        paints <- c.downField("paints").as[Seq[com.paintbatch.models.Paint]]
      } yield {
        Demand(
          paints = paints
        )
      }
    }

    implicit def encodePaintBatchOptimizerDemand: Encoder[Demand] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("paints" -> t.paints.asJson)
      ).flatten)
    }

    implicit def decodePaintBatchOptimizerHealthcheck: Decoder[Healthcheck] = Decoder.instance { c =>
     for {
        status <- c.downField("status").as[com.paintbatch.models.Status]
      } yield {
        Healthcheck(
          status = status
        )
      }
    }

    implicit def encodePaintBatchOptimizerHealthcheck: Encoder[Healthcheck] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("status" -> t.status.asJson)
      ).flatten)
    }

    implicit def decodePaintBatchOptimizerOptimizeRequest: Decoder[OptimizeRequest] = Decoder.instance { c =>
     for {
        colors <- c.downField("colors").as[Int]
        customers <- c.downField("customers").as[Int]
        demands <- c.downField("demands").as[Seq[com.paintbatch.models.Demand]]
      } yield {
        OptimizeRequest(
          colors = colors,
          customers = customers,
          demands = demands
        )
      }
    }

    implicit def encodePaintBatchOptimizerOptimizeRequest: Encoder[OptimizeRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("colors" -> t.colors.asJson),
        Some("customers" -> t.customers.asJson),
        Some("demands" -> t.demands.asJson)
      ).flatten)
    }

    implicit def decodePaintBatchOptimizerPaint: Decoder[Paint] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[Int]
        sheen <- c.downField("sheen").as[com.paintbatch.models.Sheen]
      } yield {
        Paint(
          id = id,
          sheen = sheen
        )
      }
    }

    implicit def encodePaintBatchOptimizerPaint: Encoder[Paint] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("sheen" -> t.sheen.asJson)
      ).flatten)
    }

    implicit def decodePaintBatchOptimizerReadableError: Decoder[ReadableError] = Decoder.instance { c =>
     for {
        text <- c.downField("text").as[String]
      } yield {
        ReadableError(
          text = text
        )
      }
    }

    implicit def encodePaintBatchOptimizerReadableError: Encoder[ReadableError] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("text" -> t.text.asJson)
      ).flatten)
    }
  }
}