/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1
 * User agent: apibuilder app.apibuilder.io/nccloud/reporting-api/0.0.1/http4s_0_22
 */
package de.nccloud.reporting.api.v0.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 de.nccloud.common.v0.models.json._
    import de.nccloud.reporting.api.v0.models.json._

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

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

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

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

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

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

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

    implicit val jsonDecoderReportingApiScalarType: Decoder[de.nccloud.reporting.api.v0.models.ScalarType] =
      Decoder.decodeString.map(de.nccloud.reporting.api.v0.models.ScalarType(_))

    implicit val jsonEncoderReportingApiScalarType: Encoder[de.nccloud.reporting.api.v0.models.ScalarType] =
      Encoder.encodeString.contramap[de.nccloud.reporting.api.v0.models.ScalarType](_.toString)

    implicit def decodeReportingApiDeleteEvent: Decoder[DeleteEvent] = Decoder.instance { c =>
     for {
        trackingId <- c.downField("tracking_id").as[String]
        audit <- c.downField("audit").as[de.nccloud.common.v0.models.Audit]
      } yield {
        DeleteEvent(
          trackingId = trackingId,
          audit = audit
        )
      }
    }

    implicit def encodeReportingApiDeleteEvent: Encoder[DeleteEvent] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("tracking_id" -> t.trackingId.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiField: Decoder[Field] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[de.nccloud.reporting.api.v0.models.ScalarType]
        isArray <- c.downField("is_array").as[Boolean]
        fields <- c.downField("fields").as[Option[Map[String, de.nccloud.reporting.api.v0.models.Field]]]
        label <- c.downField("label").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
      } yield {
        Field(
          `type` = __type__,
          isArray = isArray,
          fields = fields,
          label = label,
          description = description
        )
      }
    }

    implicit def encodeReportingApiField: Encoder[Field] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        Some("is_array" -> t.isArray.asJson),
        t.fields.map(t => "fields" -> t.asJson),
        t.label.map(t => "label" -> t.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiFilter: Decoder[Filter] = Decoder.instance { c =>
     for {
        expression <- c.downField("expression").as[Option[String]]
        variables <- c.downField("variables").as[Option[Map[String, _root_.io.circe.Json]]]
      } yield {
        Filter(
          expression = expression,
          variables = variables
        )
      }
    }

    implicit def encodeReportingApiFilter: Encoder[Filter] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.expression.map(t => "expression" -> t.asJson),
        t.variables.map(t => "variables" -> t.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiProjectionField: Decoder[ProjectionField] = Decoder.instance { c =>
     for {
        label <- c.downField("label").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        source <- c.downField("source").as[Option[de.nccloud.reporting.api.v0.models.ProjectionFieldSource]]
        fields <- c.downField("fields").as[Option[Map[String, de.nccloud.reporting.api.v0.models.ProjectionField]]]
      } yield {
        ProjectionField(
          label = label,
          description = description,
          source = source,
          fields = fields
        )
      }
    }

    implicit def encodeReportingApiProjectionField: Encoder[ProjectionField] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.label.map(t => "label" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.source.map(t => "source" -> t.asJson),
        t.fields.map(t => "fields" -> t.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiProjectionFieldSource: Decoder[ProjectionFieldSource] = Decoder.instance { c =>
     for {
        topic <- c.downField("topic").as[String]
        path <- c.downField("path").as[String]
        filter <- c.downField("filter").as[String]
      } yield {
        ProjectionFieldSource(
          topic = topic,
          path = path,
          filter = filter
        )
      }
    }

    implicit def encodeReportingApiProjectionFieldSource: Encoder[ProjectionFieldSource] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("topic" -> t.topic.asJson),
        Some("path" -> t.path.asJson),
        Some("filter" -> t.filter.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiQueryForm: Decoder[QueryForm] = Decoder.instance { c =>
     for {
        view <- c.downField("view").as[Option[String]]
        projection <- c.downField("projection").as[Option[Map[String, de.nccloud.reporting.api.v0.models.ProjectionField]]]
        variables <- c.downField("variables").as[Map[String, _root_.io.circe.Json]]
        sort <- c.downField("sort").as[Option[Seq[de.nccloud.common.v0.models.Sort]]]
      } yield {
        QueryForm(
          view = view,
          projection = projection,
          variables = variables,
          sort = sort
        )
      }
    }

    implicit def encodeReportingApiQueryForm: Encoder[QueryForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.view.map(t => "view" -> t.asJson),
        t.projection.map(t => "projection" -> t.asJson),
        Some("variables" -> t.variables.asJson),
        t.sort.map(t => "sort" -> t.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiQueryResponse: Decoder[QueryResponse] = Decoder.instance { c =>
     for {
        page <- c.downField("page").as[de.nccloud.common.v0.models.PageResponse]
        data <- c.downField("data").as[Map[String, _root_.io.circe.Json]]
      } yield {
        QueryResponse(
          page = page,
          data = data
        )
      }
    }

    implicit def encodeReportingApiQueryResponse: Encoder[QueryResponse] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("page" -> t.page.asJson),
        Some("data" -> t.data.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiTopic: Decoder[Topic] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        service <- c.downField("service").as[de.nccloud.common.v0.models.ServiceInfo]
        schema <- c.downField("schema").as[Map[String, de.nccloud.reporting.api.v0.models.Field]]
      } yield {
        Topic(
          name = name,
          service = service,
          schema = schema
        )
      }
    }

    implicit def encodeReportingApiTopic: Encoder[Topic] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("service" -> t.service.asJson),
        Some("schema" -> t.schema.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiTopicResponse: Decoder[TopicResponse] = Decoder.instance { c =>
     for {
        page <- c.downField("page").as[de.nccloud.common.v0.models.PageResponse]
        data <- c.downField("data").as[Seq[de.nccloud.reporting.api.v0.models.Topic]]
      } yield {
        TopicResponse(
          page = page,
          data = data
        )
      }
    }

    implicit def encodeReportingApiTopicResponse: Encoder[TopicResponse] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("page" -> t.page.asJson),
        Some("data" -> t.data.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiUpdateEvent: Decoder[UpdateEvent] = Decoder.instance { c =>
     for {
        trackingId <- c.downField("tracking_id").as[String]
        payload <- c.downField("payload").as[Map[String, _root_.io.circe.Json]]
        audit <- c.downField("audit").as[de.nccloud.common.v0.models.Audit]
      } yield {
        UpdateEvent(
          trackingId = trackingId,
          payload = payload,
          audit = audit
        )
      }
    }

    implicit def encodeReportingApiUpdateEvent: Encoder[UpdateEvent] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("tracking_id" -> t.trackingId.asJson),
        Some("payload" -> t.payload.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiView: Decoder[View] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        name <- c.downField("name").as[String]
        projection <- c.downField("projection").as[Map[String, de.nccloud.reporting.api.v0.models.ProjectionField]]
        variables <- c.downField("variables").as[Map[String, de.nccloud.reporting.api.v0.models.ScalarType]]
      } yield {
        View(
          guid = guid,
          name = name,
          projection = projection,
          variables = variables
        )
      }
    }

    implicit def encodeReportingApiView: Encoder[View] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("name" -> t.name.asJson),
        Some("projection" -> t.projection.asJson),
        Some("variables" -> t.variables.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiViewForm: Decoder[ViewForm] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        projection <- c.downField("projection").as[Map[String, de.nccloud.reporting.api.v0.models.ProjectionField]]
        variables <- c.downField("variables").as[Map[String, de.nccloud.reporting.api.v0.models.ScalarType]]
      } yield {
        ViewForm(
          name = name,
          projection = projection,
          variables = variables
        )
      }
    }

    implicit def encodeReportingApiViewForm: Encoder[ViewForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("projection" -> t.projection.asJson),
        Some("variables" -> t.variables.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiViewResponse: Decoder[ViewResponse] = Decoder.instance { c =>
     for {
        page <- c.downField("page").as[de.nccloud.common.v0.models.PageResponse]
        data <- c.downField("data").as[Seq[de.nccloud.reporting.api.v0.models.View]]
      } yield {
        ViewResponse(
          page = page,
          data = data
        )
      }
    }

    implicit def encodeReportingApiViewResponse: Encoder[ViewResponse] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("page" -> t.page.asJson),
        Some("data" -> t.data.asJson)
      ).flatten)
    }

    implicit def decodeReportingApiReportingEvent: Decoder[ReportingEvent] = Decoder.instance { c =>
      c.get[Option[String]]("type") match {
        case Right(Some(s)) if s == "update_event" => c.as[de.nccloud.reporting.api.v0.models.UpdateEvent]
        case Right(Some(s)) if s == "delete_event" => c.as[de.nccloud.reporting.api.v0.models.DeleteEvent]
        case Right(Some(s)) => Right(de.nccloud.reporting.api.v0.models.ReportingEventUndefinedType(s))
        case _ => Left(DecodingFailure("Union[ReportingEvent] requires a discriminator named 'type' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeReportingApiReportingEvent: Encoder[ReportingEvent] = Encoder.instance {
      case t: de.nccloud.reporting.api.v0.models.UpdateEvent => t.asJson.mapObject(obj => ("type", Json.fromString("update_event")) +: obj)
      case t: de.nccloud.reporting.api.v0.models.DeleteEvent => t.asJson.mapObject(obj => ("type", Json.fromString("delete_event")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}