/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.12.53
 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-internal/0.12.53/http4s_0_17
 */
package io.apibuilder.internal.v0.models {

  sealed trait TaskData extends _root_.scala.Product with _root_.scala.Serializable
  /**
   * @param numberAttempts Records the number of times we have attempted to run this task. Commonly we
   *        increment number attempts, process the task, and if succeeds we then delete the
   *        task. If it fails, we update last_error. This allows us to retry a task say
   *        twice; after which we no longer process the task (can notify an admin of the
   *        error).
   */

  final case class Task(
    guid: _root_.java.util.UUID,
    data: io.apibuilder.internal.v0.models.TaskData,
    numberAttempts: Long = 0L,
    lastError: _root_.scala.Option[String] = None
  )

  final case class TaskDataDiffVersion(
    oldVersionGuid: _root_.java.util.UUID,
    newVersionGuid: _root_.java.util.UUID
  ) extends TaskData

  final case class TaskDataIndexApplication(
    applicationGuid: _root_.java.util.UUID
  ) extends TaskData

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union TaskData, 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 TaskDataUndefinedType(
    description: String
  ) extends TaskData

}

package io.apibuilder.internal.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.apibuilder.internal.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 decodeApibuilderInternalTask: Decoder[Task] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        data <- c.downField("data").as[io.apibuilder.internal.v0.models.TaskData]
        numberAttempts <- c.downField("number_attempts").as[Long]
        lastError <- c.downField("last_error").as[Option[String]]
      } yield {
        Task(
          guid = guid,
          data = data,
          numberAttempts = numberAttempts,
          lastError = lastError
        )
      }
    }

    implicit def encodeApibuilderInternalTask: Encoder[Task] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("data" -> t.data.asJson),
        Some("number_attempts" -> t.numberAttempts.asJson),
        t.lastError.map(t => "last_error" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderInternalTaskDataDiffVersion: Decoder[TaskDataDiffVersion] = Decoder.instance { c =>
     for {
        oldVersionGuid <- c.downField("old_version_guid").as[_root_.java.util.UUID]
        newVersionGuid <- c.downField("new_version_guid").as[_root_.java.util.UUID]
      } yield {
        TaskDataDiffVersion(
          oldVersionGuid = oldVersionGuid,
          newVersionGuid = newVersionGuid
        )
      }
    }

    implicit def encodeApibuilderInternalTaskDataDiffVersion: Encoder[TaskDataDiffVersion] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("old_version_guid" -> t.oldVersionGuid.asJson),
        Some("new_version_guid" -> t.newVersionGuid.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderInternalTaskDataIndexApplication: Decoder[TaskDataIndexApplication] = Decoder.instance { c =>
     for {
        applicationGuid <- c.downField("application_guid").as[_root_.java.util.UUID]
      } yield {
        TaskDataIndexApplication(
          applicationGuid = applicationGuid
        )
      }
    }

    implicit def encodeApibuilderInternalTaskDataIndexApplication: Encoder[TaskDataIndexApplication] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("application_guid" -> t.applicationGuid.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderInternalTaskData: Decoder[TaskData] = Decoder.instance { c =>
      c.get[io.apibuilder.internal.v0.models.TaskDataIndexApplication]("task_data_index_application") orElse
      c.get[io.apibuilder.internal.v0.models.TaskDataDiffVersion]("task_data_diff_version") orElse
      Right(io.apibuilder.internal.v0.models.TaskDataUndefinedType(c.value.toString))
    }

    implicit def encodeApibuilderInternalTaskData: Encoder[TaskData] = Encoder.instance {
      case t: io.apibuilder.internal.v0.models.TaskDataIndexApplication => Json.fromJsonObject(JsonObject.singleton("task_data_index_application", t.asJson))
      case t: io.apibuilder.internal.v0.models.TaskDataDiffVersion => Json.fromJsonObject(JsonObject.singleton("task_data_diff_version", t.asJson))
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}