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

    // 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 jsonDecoderCommonErrorSourceType: Decoder[de.nccloud.common.v0.models.ErrorSourceType] =
      Decoder.decodeString.map(de.nccloud.common.v0.models.ErrorSourceType(_))

    implicit val jsonEncoderCommonErrorSourceType: Encoder[de.nccloud.common.v0.models.ErrorSourceType] =
      Encoder.encodeString.contramap[de.nccloud.common.v0.models.ErrorSourceType](_.toString)

    implicit val jsonDecoderCommonHealthStatus: Decoder[de.nccloud.common.v0.models.HealthStatus] =
      Decoder.decodeString.map(de.nccloud.common.v0.models.HealthStatus(_))

    implicit val jsonEncoderCommonHealthStatus: Encoder[de.nccloud.common.v0.models.HealthStatus] =
      Encoder.encodeString.contramap[de.nccloud.common.v0.models.HealthStatus](_.toString)

    implicit val jsonDecoderCommonSortDirection: Decoder[de.nccloud.common.v0.models.SortDirection] =
      Decoder.decodeString.map(de.nccloud.common.v0.models.SortDirection(_))

    implicit val jsonEncoderCommonSortDirection: Encoder[de.nccloud.common.v0.models.SortDirection] =
      Encoder.encodeString.contramap[de.nccloud.common.v0.models.SortDirection](_.toString)

    implicit def decodeCommonAudit: Decoder[Audit] = Decoder.instance { c =>
     for {
        createdAt <- c.downField("created_at").as[_root_.java.time.Instant]
        createdBy <- c.downField("created_by").as[_root_.java.util.UUID]
        updatedAt <- c.downField("updated_at").as[_root_.java.time.Instant]
        updatedBy <- c.downField("updated_by").as[_root_.java.util.UUID]
      } yield {
        Audit(
          createdAt = createdAt,
          createdBy = createdBy,
          updatedAt = updatedAt,
          updatedBy = updatedBy
        )
      }
    }

    implicit def encodeCommonAudit: Encoder[Audit] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("created_at" -> t.createdAt.asJson),
        Some("created_by" -> t.createdBy.asJson),
        Some("updated_at" -> t.updatedAt.asJson),
        Some("updated_by" -> t.updatedBy.asJson)
      ).flatten)
    }

    implicit def decodeCommonErrorLinks: Decoder[ErrorLinks] = Decoder.instance { c =>
     for {
        about <- c.downField("about").as[Option[de.nccloud.common.v0.models.Link]]
        __type__ <- c.downField("type").as[Option[de.nccloud.common.v0.models.Link]]
      } yield {
        ErrorLinks(
          about = about,
          `type` = __type__
        )
      }
    }

    implicit def encodeCommonErrorLinks: Encoder[ErrorLinks] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.about.map(t => "about" -> t.asJson),
        t.`type`.map(t => "type" -> t.asJson)
      ).flatten)
    }

    implicit def decodeCommonErrorSource: Decoder[ErrorSource] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[de.nccloud.common.v0.models.ErrorSourceType]
        source <- c.downField("source").as[String]
      } yield {
        ErrorSource(
          `type` = __type__,
          source = source
        )
      }
    }

    implicit def encodeCommonErrorSource: Encoder[ErrorSource] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        Some("source" -> t.source.asJson)
      ).flatten)
    }

    implicit def decodeCommonGenericError: Decoder[GenericError] = Decoder.instance { c =>
     for {
        links <- c.downField("links").as[Option[de.nccloud.common.v0.models.ErrorLinks]]
        code <- c.downField("code").as[String]
        title <- c.downField("title").as[String]
        detail <- c.downField("detail").as[String]
        source <- c.downField("source").as[Option[de.nccloud.common.v0.models.ErrorSource]]
        meta <- c.downField("meta").as[Option[Map[String, _root_.io.circe.Json]]]
      } yield {
        GenericError(
          links = links,
          code = code,
          title = title,
          detail = detail,
          source = source,
          meta = meta
        )
      }
    }

    implicit def encodeCommonGenericError: Encoder[GenericError] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.links.map(t => "links" -> t.asJson),
        Some("code" -> t.code.asJson),
        Some("title" -> t.title.asJson),
        Some("detail" -> t.detail.asJson),
        t.source.map(t => "source" -> t.asJson),
        t.meta.map(t => "meta" -> t.asJson)
      ).flatten)
    }

    implicit def decodeCommonHealthCheck: Decoder[HealthCheck] = Decoder.instance { c =>
     for {
        status <- c.downField("status").as[de.nccloud.common.v0.models.HealthStatus]
        message <- c.downField("message").as[Option[String]]
      } yield {
        HealthCheck(
          status = status,
          message = message
        )
      }
    }

    implicit def encodeCommonHealthCheck: Encoder[HealthCheck] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("status" -> t.status.asJson),
        t.message.map(t => "message" -> t.asJson)
      ).flatten)
    }

    implicit def decodeCommonLinkObject: Decoder[LinkObject] = Decoder.instance { c =>
     for {
        href <- c.downField("href").as[String]
        title <- c.downField("title").as[Option[String]]
        __type__ <- c.downField("type").as[Option[String]]
      } yield {
        LinkObject(
          href = href,
          title = title,
          `type` = __type__
        )
      }
    }

    implicit def encodeCommonLinkObject: Encoder[LinkObject] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("href" -> t.href.asJson),
        t.title.map(t => "title" -> t.asJson),
        t.`type`.map(t => "type" -> t.asJson)
      ).flatten)
    }

    implicit def decodeCommonPageResponse: Decoder[PageResponse] = Decoder.instance { c =>
     for {
        offset <- c.downField("offset").as[Int]
        limit <- c.downField("limit").as[Int]
        sort <- c.downField("sort").as[Seq[de.nccloud.common.v0.models.Sort]]
        totalResults <- c.downField("total_results").as[Long]
        totalPages <- c.downField("total_pages").as[Long]
      } yield {
        PageResponse(
          offset = offset,
          limit = limit,
          sort = sort,
          totalResults = totalResults,
          totalPages = totalPages
        )
      }
    }

    implicit def encodeCommonPageResponse: Encoder[PageResponse] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("offset" -> t.offset.asJson),
        Some("limit" -> t.limit.asJson),
        Some("sort" -> t.sort.asJson),
        Some("total_results" -> t.totalResults.asJson),
        Some("total_pages" -> t.totalPages.asJson)
      ).flatten)
    }

    implicit def decodeCommonPagingForm: Decoder[PagingForm] = Decoder.instance { c =>
     for {
        offset <- c.downField("offset").as[Int]
        limit <- c.downField("limit").as[Int]
        sort <- c.downField("sort").as[Option[Seq[de.nccloud.common.v0.models.Sort]]]
      } yield {
        PagingForm(
          offset = offset,
          limit = limit,
          sort = sort
        )
      }
    }

    implicit def encodeCommonPagingForm: Encoder[PagingForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("offset" -> t.offset.asJson),
        Some("limit" -> t.limit.asJson),
        t.sort.map(t => "sort" -> t.asJson)
      ).flatten)
    }

    implicit def decodeCommonServiceInfo: Decoder[ServiceInfo] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        version <- c.downField("version").as[String]
        uri <- c.downField("uri").as[String]
        title <- c.downField("title").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ServiceInfo(
          name = name,
          version = version,
          uri = uri,
          title = title,
          description = description
        )
      }
    }

    implicit def encodeCommonServiceInfo: Encoder[ServiceInfo] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("version" -> t.version.asJson),
        Some("uri" -> t.uri.asJson),
        t.title.map(t => "title" -> t.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeCommonSort: Decoder[Sort] = Decoder.instance { c =>
     for {
        property <- c.downField("property").as[String]
        direction <- c.downField("direction").as[de.nccloud.common.v0.models.SortDirection]
      } yield {
        Sort(
          property = property,
          direction = direction
        )
      }
    }

    implicit def encodeCommonSort: Encoder[Sort] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("property" -> t.property.asJson),
        Some("direction" -> t.direction.asJson)
      ).flatten)
    }

    implicit def decodeCommonLinkString: Decoder[LinkString] = Decoder.instance { c =>
     for {
        value <- c.downField("value").as[String]
      } yield {
        LinkString(
          value = value
        )
      }
    }

    implicit def encodeCommonLinkString: Encoder[LinkString] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("value" -> t.value.asJson)
      ).flatten)
    }

    implicit def decodeCommonLink: Decoder[Link] = Decoder.instance { c =>
      c.get[de.nccloud.common.v0.models.LinkString]("string") orElse
      c.get[de.nccloud.common.v0.models.LinkObject]("link_object") orElse
      Right(de.nccloud.common.v0.models.LinkUndefinedType(c.value.toString))
    }

    implicit def encodeCommonLink: Encoder[Link] = Encoder.instance {
      case t: de.nccloud.common.v0.models.LinkString => Json.fromJsonObject(JsonObject.singleton("string", t.asJson))
      case t: de.nccloud.common.v0.models.LinkObject => Json.fromJsonObject(JsonObject.singleton("link_object", t.asJson))
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}