/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.12.1
 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-generator/0.12.1/http4s_0_23
 */
package io.apibuilder.generator.v0.models {

  /**
   * An attribute represents a key/value pair that is optionally used to provide
   * additional instructions / data to the code generator. An example could be an
   * attribute to specify the root import path for a go client..
   */

  final case class Attribute(
    name: String,
    value: String
  )

  /**
   * @param code Machine readable code for this specific error message
   * @param message Description of the error
   */

  final case class Error(
    code: String,
    message: String
  )

  /**
   * Represents a source file
   *
   * @param name The recommended name for the file.
   * @param dir The recommended directory path for the file where appropriate.
   * @param contents The actual source code.
   */

  final case class File(
    name: String,
    dir: _root_.scala.Option[String] = None,
    contents: String
  )

  /**
   * The generator metadata.
   *
   * @param language A comma separate list of the programming language(s) that this generator
   *        produces
   * @param attributes The list of attributes that this code generator can use. You can find the full
   *        list of available attributes and their descriptions at
   *        http://apibuilder.io/doc/attributes
   */

  final case class Generator(
    key: String,
    name: String,
    language: _root_.scala.Option[String] = None,
    description: _root_.scala.Option[String] = None,
    attributes: Seq[String] = Nil
  )

  final case class Healthcheck(
    status: String
  )

  /**
   * The result of invoking a generator.
   *
   * @param source The actual source code.
   * @param files A collection of source files
   */

  final case class Invocation(
    @deprecated("Use files instead") source: String,
    files: Seq[io.apibuilder.generator.v0.models.File]
  )

  /**
   * The invocation form is the payload send to the code generators when requesting
   * generation of client code.
   */

  final case class InvocationForm(
    service: io.apibuilder.spec.v0.models.Service,
    attributes: Seq[io.apibuilder.generator.v0.models.Attribute] = Nil,
    userAgent: _root_.scala.Option[String] = None
  )

}

package io.apibuilder.generator.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.common.v0.models.json._
    import io.apibuilder.generator.v0.models.json._
    import io.apibuilder.spec.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 decodeApibuilderGeneratorAttribute: Decoder[Attribute] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        value <- c.downField("value").as[String]
      } yield {
        Attribute(
          name = name,
          value = value
        )
      }
    }

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

    implicit def decodeApibuilderGeneratorError: Decoder[Error] = Decoder.instance { c =>
     for {
        code <- c.downField("code").as[String]
        message <- c.downField("message").as[String]
      } yield {
        Error(
          code = code,
          message = message
        )
      }
    }

    implicit def encodeApibuilderGeneratorError: Encoder[Error] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("code" -> t.code.asJson),
        Some("message" -> t.message.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderGeneratorFile: Decoder[File] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        dir <- c.downField("dir").as[Option[String]]
        contents <- c.downField("contents").as[String]
      } yield {
        File(
          name = name,
          dir = dir,
          contents = contents
        )
      }
    }

    implicit def encodeApibuilderGeneratorFile: Encoder[File] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.dir.map(t => "dir" -> t.asJson),
        Some("contents" -> t.contents.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderGeneratorGenerator: Decoder[Generator] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
        name <- c.downField("name").as[String]
        language <- c.downField("language").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        attributes <- c.downField("attributes").as[Seq[String]]
      } yield {
        Generator(
          key = key,
          name = name,
          language = language,
          description = description,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderGeneratorGenerator: Encoder[Generator] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson),
        Some("name" -> t.name.asJson),
        t.language.map(t => "language" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderGeneratorHealthcheck: Decoder[Healthcheck] = Decoder.instance { c =>
     for {
        status <- c.downField("status").as[String]
      } yield {
        Healthcheck(
          status = status
        )
      }
    }

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

    implicit def decodeApibuilderGeneratorInvocation: Decoder[Invocation] = Decoder.instance { c =>
     for {
        source <- c.downField("source").as[String]
        files <- c.downField("files").as[Seq[io.apibuilder.generator.v0.models.File]]
      } yield {
        Invocation(
          source = source,
          files = files
        )
      }
    }

    implicit def encodeApibuilderGeneratorInvocation: Encoder[Invocation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("source" -> t.source.asJson),
        Some("files" -> t.files.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderGeneratorInvocationForm: Decoder[InvocationForm] = Decoder.instance { c =>
     for {
        service <- c.downField("service").as[io.apibuilder.spec.v0.models.Service]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.generator.v0.models.Attribute]]
        userAgent <- c.downField("user_agent").as[Option[String]]
      } yield {
        InvocationForm(
          service = service,
          attributes = attributes,
          userAgent = userAgent
        )
      }
    }

    implicit def encodeApibuilderGeneratorInvocationForm: Encoder[InvocationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("service" -> t.service.asJson),
        Some("attributes" -> t.attributes.asJson),
        t.userAgent.map(t => "user_agent" -> t.asJson)
      ).flatten)
    }
  }
}