/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.15.4
 * User agent: apibuilder app.apibuilder.io/apicollective/example-interface/0.15.4/http4s_0_22
 */
package io.example.interface.v0.models {

  trait DatabaseRecord {
    def id: String
  }
  sealed trait Person extends _root_.scala.Product with _root_.scala.Serializable {
    def personDiscriminator: PersonDiscriminator
    def email: _root_.scala.Option[String]
    def name: _root_.scala.Option[String]
  }

  /**
   * Defines the valid discriminator values for the type Person
   */
  sealed trait PersonDiscriminator extends _root_.scala.Product with _root_.scala.Serializable

  object PersonDiscriminator {

    case object Guest extends PersonDiscriminator { override def toString = "guest" }
    case object User extends PersonDiscriminator { override def toString = "user" }

    final case class UNDEFINED(override val toString: String) extends PersonDiscriminator

    val all: scala.List[PersonDiscriminator] = scala.List(Guest, User)

    private val byName: Map[String, PersonDiscriminator] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): PersonDiscriminator = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[PersonDiscriminator] = byName.get(value.toLowerCase)

  }
  final case class Guest(
    sessionId: String,
    override val email: _root_.scala.Option[String] = None,
    override val name: _root_.scala.Option[String] = None
  ) extends Person {
    override val personDiscriminator: PersonDiscriminator = PersonDiscriminator.Guest
  }

  final case class User(
    override val id: String,
    override val email: _root_.scala.Option[String] = None,
    override val name: _root_.scala.Option[String] = None,
    registrationDate: _root_.java.time.Instant
  ) extends DatabaseRecord with Person {
    override val personDiscriminator: PersonDiscriminator = PersonDiscriminator.User
  }

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union Person, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class PersonUndefinedType(
    description: String
  ) extends Person {
    override val personDiscriminator: PersonDiscriminator = PersonDiscriminator.UNDEFINED(description)
    override def email: _root_.scala.Option[String] = ???
    override def name: _root_.scala.Option[String] = ???
  }

}

package io.example.interface.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 io.example.interface.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 def decodeExampleInterfaceGuest: Decoder[Guest] = Decoder.instance { c =>
     for {
        sessionId <- c.downField("session_id").as[String]
        email <- c.downField("email").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
      } yield {
        Guest(
          sessionId = sessionId,
          email = email,
          name = name
        )
      }
    }

    implicit def encodeExampleInterfaceGuest: Encoder[Guest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("session_id" -> t.sessionId.asJson),
        t.email.map(t => "email" -> t.asJson),
        t.name.map(t => "name" -> t.asJson)
      ).flatten)
    }

    implicit def decodeExampleInterfaceUser: Decoder[User] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        email <- c.downField("email").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
        registrationDate <- c.downField("registration_date").as[_root_.java.time.Instant]
      } yield {
        User(
          id = id,
          email = email,
          name = name,
          registrationDate = registrationDate
        )
      }
    }

    implicit def encodeExampleInterfaceUser: Encoder[User] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        t.email.map(t => "email" -> t.asJson),
        t.name.map(t => "name" -> t.asJson),
        Some("registration_date" -> t.registrationDate.asJson)
      ).flatten)
    }

    implicit def decodeExampleInterfacePerson: Decoder[Person] = Decoder.instance { c =>
      c.get[Option[String]]("discriminator") match {
        case Right(Some(s)) if s == "guest" => c.as[io.example.interface.v0.models.Guest]
        case Right(Some(s)) if s == "user" => c.as[io.example.interface.v0.models.User]
        case Right(Some(s)) => Right(io.example.interface.v0.models.PersonUndefinedType(s))
        case _ => Left(DecodingFailure("Union[Person] requires a discriminator named 'discriminator' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeExampleInterfacePerson: Encoder[Person] = Encoder.instance {
      case t: io.example.interface.v0.models.Guest => t.asJson.mapObject(obj => ("discriminator", Json.fromString("guest")) +: obj)
      case t: io.example.interface.v0.models.User => t.asJson.mapObject(obj => ("discriminator", Json.fromString("user")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}