/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 1.0.1
 * User agent: apibuilder app.apibuilder.io/gilt/ionroller-api/1.0.1/http4s_0_23
 */
package com.gilt.ionroller.api.v1.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 com.gilt.ionroller.api.v1.models.json._

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

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

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

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

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

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

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

    implicit def decodeIonrollerAPIEbConfig: Decoder[EbConfig] = Decoder.instance { c =>
     for {
        deploymentBucket <- c.downField("deployment_bucket").as[String]
        stack <- c.downField("stack").as[Option[String]]
        settings <- c.downField("settings").as[Option[Seq[com.gilt.ionroller.api.v1.models.OptionSetting]]]
        resources <- c.downField("resources").as[Option[Map[String, _root_.io.circe.Json]]]
        packages <- c.downField("packages").as[Option[Map[String, _root_.io.circe.Json]]]
        sources <- c.downField("sources").as[Option[Map[String, _root_.io.circe.Json]]]
        files <- c.downField("files").as[Option[Map[String, _root_.io.circe.Json]]]
        users <- c.downField("users").as[Option[Map[String, _root_.io.circe.Json]]]
        groups <- c.downField("groups").as[Option[Map[String, _root_.io.circe.Json]]]
        commands <- c.downField("commands").as[Option[Map[String, _root_.io.circe.Json]]]
        containerCommands <- c.downField("container_commands").as[Option[Map[String, _root_.io.circe.Json]]]
        services <- c.downField("services").as[Option[Map[String, _root_.io.circe.Json]]]
      } yield {
        EbConfig(
          deploymentBucket = deploymentBucket,
          stack = stack,
          settings = settings,
          resources = resources,
          packages = packages,
          sources = sources,
          files = files,
          users = users,
          groups = groups,
          commands = commands,
          containerCommands = containerCommands,
          services = services
        )
      }
    }

    implicit def encodeIonrollerAPIEbConfig: Encoder[EbConfig] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("deployment_bucket" -> t.deploymentBucket.asJson),
        t.stack.map(t => "stack" -> t.asJson),
        t.settings.map(t => "settings" -> t.asJson),
        t.resources.map(t => "resources" -> t.asJson),
        t.packages.map(t => "packages" -> t.asJson),
        t.sources.map(t => "sources" -> t.asJson),
        t.files.map(t => "files" -> t.asJson),
        t.users.map(t => "users" -> t.asJson),
        t.groups.map(t => "groups" -> t.asJson),
        t.commands.map(t => "commands" -> t.asJson),
        t.containerCommands.map(t => "container_commands" -> t.asJson),
        t.services.map(t => "services" -> t.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIElbSettings: Decoder[ElbSettings] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        securityGroup <- c.downField("security_group").as[String]
        rolloutDelayMinutes <- c.downField("rollout_delay_minutes").as[Int]
      } yield {
        ElbSettings(
          name = name,
          securityGroup = securityGroup,
          rolloutDelayMinutes = rolloutDelayMinutes
        )
      }
    }

    implicit def encodeIonrollerAPIElbSettings: Encoder[ElbSettings] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("security_group" -> t.securityGroup.asJson),
        Some("rollout_delay_minutes" -> t.rolloutDelayMinutes.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIEnvironment: Decoder[Environment] = Decoder.instance { c =>
     for {
        release <- c.downField("release").as[com.gilt.ionroller.api.v1.models.Release]
        health <- c.downField("health").as[String]
      } yield {
        Environment(
          release = release,
          health = health
        )
      }
    }

    implicit def encodeIonrollerAPIEnvironment: Encoder[Environment] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("release" -> t.release.asJson),
        Some("health" -> t.health.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIOptionSetting: Decoder[OptionSetting] = Decoder.instance { c =>
     for {
        namespace <- c.downField("Namespace").as[String]
        optionName <- c.downField("OptionName").as[String]
        value <- c.downField("Value").as[String]
      } yield {
        OptionSetting(
          namespace = namespace,
          optionName = optionName,
          value = value
        )
      }
    }

    implicit def encodeIonrollerAPIOptionSetting: Encoder[OptionSetting] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("Namespace" -> t.namespace.asJson),
        Some("OptionName" -> t.optionName.asJson),
        Some("Value" -> t.value.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIPortMapping: Decoder[PortMapping] = Decoder.instance { c =>
     for {
        internal <- c.downField("internal").as[Int]
        external <- c.downField("external").as[Int]
      } yield {
        PortMapping(
          internal = internal,
          external = external
        )
      }
    }

    implicit def encodeIonrollerAPIPortMapping: Encoder[PortMapping] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("internal" -> t.internal.asJson),
        Some("external" -> t.external.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIRelease: Decoder[Release] = Decoder.instance { c =>
     for {
        image <- c.downField("image").as[String]
        tag <- c.downField("tag").as[String]
        config <- c.downField("config").as[_root_.java.time.Instant]
        rolloutStatus <- c.downField("rollout_status").as[Option[com.gilt.ionroller.api.v1.models.RolloutStatus]]
      } yield {
        Release(
          image = image,
          tag = tag,
          config = config,
          rolloutStatus = rolloutStatus
        )
      }
    }

    implicit def encodeIonrollerAPIRelease: Encoder[Release] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("image" -> t.image.asJson),
        Some("tag" -> t.tag.asJson),
        Some("config" -> t.config.asJson),
        t.rolloutStatus.map(t => "rollout_status" -> t.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIRolloutStatus: Decoder[RolloutStatus] = Decoder.instance { c =>
     for {
        numInstances <- c.downField("num_instances").as[Option[Int]]
        completedAt <- c.downField("completed_at").as[Option[_root_.java.time.Instant]]
      } yield {
        RolloutStatus(
          numInstances = numInstances,
          completedAt = completedAt
        )
      }
    }

    implicit def encodeIonrollerAPIRolloutStatus: Encoder[RolloutStatus] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.numInstances.map(t => "num_instances" -> t.asJson),
        t.completedAt.map(t => "completed_at" -> t.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIService: Decoder[Service] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        state <- c.downField("state").as[com.gilt.ionroller.api.v1.models.ServiceState]
      } yield {
        Service(
          name = name,
          state = state
        )
      }
    }

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

    implicit def decodeIonrollerAPIServiceConfig: Decoder[ServiceConfig] = Decoder.instance { c =>
     for {
        url <- c.downField("url").as[String]
        hostedZoneId <- c.downField("hosted_zone_id").as[String]
        awsAccountId <- c.downField("aws_account_id").as[String]
        externalElb <- c.downField("external_elb").as[Option[com.gilt.ionroller.api.v1.models.ElbSettings]]
        serviceRole <- c.downField("service_role").as[String]
        image <- c.downField("image").as[String]
        portMappings <- c.downField("port_mappings").as[Seq[com.gilt.ionroller.api.v1.models.PortMapping]]
        volumeMappings <- c.downField("volume_mappings").as[Option[Seq[com.gilt.ionroller.api.v1.models.VolumeMapping]]]
        runArgs <- c.downField("run_args").as[Seq[String]]
        eb <- c.downField("eb").as[com.gilt.ionroller.api.v1.models.EbConfig]
        removeUnusedAfterMinutes <- c.downField("remove_unused_after_minutes").as[Option[Long]]
        timestamp <- c.downField("timestamp").as[Option[_root_.java.time.Instant]]
      } yield {
        ServiceConfig(
          url = url,
          hostedZoneId = hostedZoneId,
          awsAccountId = awsAccountId,
          externalElb = externalElb,
          serviceRole = serviceRole,
          image = image,
          portMappings = portMappings,
          volumeMappings = volumeMappings,
          runArgs = runArgs,
          eb = eb,
          removeUnusedAfterMinutes = removeUnusedAfterMinutes,
          timestamp = timestamp
        )
      }
    }

    implicit def encodeIonrollerAPIServiceConfig: Encoder[ServiceConfig] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("url" -> t.url.asJson),
        Some("hosted_zone_id" -> t.hostedZoneId.asJson),
        Some("aws_account_id" -> t.awsAccountId.asJson),
        t.externalElb.map(t => "external_elb" -> t.asJson),
        Some("service_role" -> t.serviceRole.asJson),
        Some("image" -> t.image.asJson),
        Some("port_mappings" -> t.portMappings.asJson),
        t.volumeMappings.map(t => "volume_mappings" -> t.asJson),
        Some("run_args" -> t.runArgs.asJson),
        Some("eb" -> t.eb.asJson),
        t.removeUnusedAfterMinutes.map(t => "remove_unused_after_minutes" -> t.asJson),
        t.timestamp.map(t => "timestamp" -> t.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIServiceCurrentState: Decoder[ServiceCurrentState] = Decoder.instance { c =>
     for {
        environments <- c.downField("environments").as[Seq[com.gilt.ionroller.api.v1.models.Environment]]
      } yield {
        ServiceCurrentState(
          environments = environments
        )
      }
    }

    implicit def encodeIonrollerAPIServiceCurrentState: Encoder[ServiceCurrentState] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("environments" -> t.environments.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIServiceDesiredState: Decoder[ServiceDesiredState] = Decoder.instance { c =>
     for {
        current <- c.downField("current").as[Option[com.gilt.ionroller.api.v1.models.Release]]
        next <- c.downField("next").as[Option[com.gilt.ionroller.api.v1.models.Release]]
        future <- c.downField("future").as[Option[com.gilt.ionroller.api.v1.models.Release]]
      } yield {
        ServiceDesiredState(
          current = current,
          next = next,
          future = future
        )
      }
    }

    implicit def encodeIonrollerAPIServiceDesiredState: Encoder[ServiceDesiredState] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.current.map(t => "current" -> t.asJson),
        t.next.map(t => "next" -> t.asJson),
        t.future.map(t => "future" -> t.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIServiceState: Decoder[ServiceState] = Decoder.instance { c =>
     for {
        current <- c.downField("current").as[com.gilt.ionroller.api.v1.models.ServiceCurrentState]
        desired <- c.downField("desired").as[Option[com.gilt.ionroller.api.v1.models.ServiceDesiredState]]
      } yield {
        ServiceState(
          current = current,
          desired = desired
        )
      }
    }

    implicit def encodeIonrollerAPIServiceState: Encoder[ServiceState] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("current" -> t.current.asJson),
        t.desired.map(t => "desired" -> t.asJson)
      ).flatten)
    }

    implicit def decodeIonrollerAPIVolumeMapping: Decoder[VolumeMapping] = Decoder.instance { c =>
     for {
        internal <- c.downField("internal").as[String]
        external <- c.downField("external").as[String]
      } yield {
        VolumeMapping(
          internal = internal,
          external = external
        )
      }
    }

    implicit def encodeIonrollerAPIVolumeMapping: Encoder[VolumeMapping] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("internal" -> t.internal.asJson),
        Some("external" -> t.external.asJson)
      ).flatten)
    }
  }
}