content: {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE DerivingStrategies #-}
  {-# LANGUAGE DuplicateRecordFields #-}
  {-# LANGUAGE ImportQualifiedPost #-}
  {-# LANGUAGE LambdaCase #-}
  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE PatternSynonyms #-}
  {-# LANGUAGE RecordWildCards #-}
  {-# LANGUAGE StrictData #-}
  {-# LANGUAGE TypeFamilies #-}
  {-# LANGUAGE NoImplicitPrelude #-}
  {-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
  {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
  {-# OPTIONS_GHC -fno-warn-unused-binds #-}
  {-# OPTIONS_GHC -fno-warn-unused-imports #-}
  {-# OPTIONS_GHC -fno-warn-unused-matches #-}
  
  -- |
  -- Module      : Gogol.FirebaseRemoteConfig.Internal.Product
  -- Copyright   : (c) 2015-2025 Brendan Hay
  -- License     : Mozilla Public License, v. 2.0.
  -- Maintainer  : Brendan Hay <brendan.g.hay+gogol@gmail.com>
  --               Toni Cebrián <toni@tonicebrian.com>
  -- Stability   : auto-generated
  -- Portability : non-portable (GHC extensions)
  module Gogol.FirebaseRemoteConfig.Internal.Product
    ( -- * RemoteConfig
      RemoteConfig (..),
      newRemoteConfig,
  
      -- * RemoteConfig_Parameters
      RemoteConfig_Parameters (..),
      newRemoteConfig_Parameters,
  
      -- * RemoteConfigCondition
      RemoteConfigCondition (..),
      newRemoteConfigCondition,
  
      -- * RemoteConfigParameter
      RemoteConfigParameter (..),
      newRemoteConfigParameter,
  
      -- * RemoteConfigParameter_ConditionalValues
      RemoteConfigParameter_ConditionalValues (..),
      newRemoteConfigParameter_ConditionalValues,
  
      -- * RemoteConfigParameterValue
      RemoteConfigParameterValue (..),
      newRemoteConfigParameterValue,
    )
  where
  
  import Gogol.FirebaseRemoteConfig.Internal.Sum
  import Gogol.Prelude qualified as Core
  
  -- | -   The RemoteConfig consists of a list of conditions (which can be thought of as named \"if\" statements) and a map of parameters (parameter key to a structure containing an optional default value, as well as a optional submap of (condition name to value when that condition is true).
  --
  -- /See:/ 'newRemoteConfig' smart constructor.
  data RemoteConfig = RemoteConfig
    { -- | The list of named conditions. The order /does/ affect the semantics. The condition_name values of these entries must be unique.
      --
      -- The resolved value of a config parameter P is determined as follow: * Let Y be the set of values from the submap of P that refer to conditions that evaluate to \<code>true\<\/code>. * If Y is non empty, the value is taken from the specific submap in Y whose condition/name is the earliest in this condition list. * Else, if P has a default value option (condition/name is empty) then the value is taken from that option. * Else, parameter P has no value and is omitted from the config result.
      --
      -- Example: parameter key \"p1\", default value \"v1\", submap specified as {\"c1\": v2, \"c2\": v3} where \"c1\" and \"c2\" are names of conditions in the condition list (where \"c1\" in this example appears before \"c2\"). The value of p1 would be v2 as long as c1 is true. Otherwise, if c2 is true, p1 would evaluate to v3, and if c1 and c2 are both false, p1 would evaluate to v1. If no default value was specified, and c1 and c2 were both false, no value for p1 would be generated.
      conditions :: (Core.Maybe [RemoteConfigCondition]),
      -- | Map of parameter keys to their optional default values and optional submap of (condition name : value). Order doesn\'t affect semantics, and so is sorted by the server. The \'key\' values of the params must be unique.
      parameters :: (Core.Maybe RemoteConfig_Parameters)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RemoteConfig' with the minimum fields required to make a request.
  newRemoteConfig ::
    RemoteConfig
  newRemoteConfig =
    RemoteConfig
      { conditions = Core.Nothing,
        parameters = Core.Nothing
      }
  
  instance Core.FromJSON RemoteConfig where
    parseJSON =
      Core.withObject
        "RemoteConfig"
        ( \o ->
            RemoteConfig
              Core.<$> (o Core..:? "conditions")
              Core.<*> (o Core..:? "parameters")
        )
  
  instance Core.ToJSON RemoteConfig where
    toJSON RemoteConfig {..} =
      Core.object
        ( Core.catMaybes
            [ ("conditions" Core..=) Core.<$> conditions,
              ("parameters" Core..=) Core.<$> parameters
            ]
        )
  
  -- | Map of parameter keys to their optional default values and optional submap of (condition name : value). Order doesn\'t affect semantics, and so is sorted by the server. The \'key\' values of the params must be unique.
  --
  -- /See:/ 'newRemoteConfig_Parameters' smart constructor.
  newtype RemoteConfig_Parameters = RemoteConfig_Parameters
    { additional :: (Core.HashMap Core.Text RemoteConfigParameter)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RemoteConfig_Parameters' with the minimum fields required to make a request.
  newRemoteConfig_Parameters ::
    -- |  See 'additional'.
    Core.HashMap Core.Text RemoteConfigParameter ->
    RemoteConfig_Parameters
  newRemoteConfig_Parameters additional =
    RemoteConfig_Parameters {additional = additional}
  
  instance Core.FromJSON RemoteConfig_Parameters where
    parseJSON =
      Core.withObject
        "RemoteConfig_Parameters"
        (\o -> RemoteConfig_Parameters Core.<$> (Core.parseJSONObject o))
  
  instance Core.ToJSON RemoteConfig_Parameters where
    toJSON RemoteConfig_Parameters {..} = Core.toJSON additional
  
  -- | A single RemoteConfig Condition. A list of these (because order matters) are part of a single RemoteConfig template.
  --
  -- /See:/ 'newRemoteConfigCondition' smart constructor.
  data RemoteConfigCondition = RemoteConfigCondition
    { -- | DO NOT USE. Implementation removed and will not be added unless requested. A description for this Condition. Length must be less than or equal to 100 characters (or more precisely, unicode code points, which is defined in java\/com\/google\/wireless\/android\/config\/ConstsExporter.java). A description may contain any Unicode characters
      description :: (Core.Maybe Core.Text),
      -- | Required.
      expression :: (Core.Maybe Core.Text),
      -- | Required. A non empty and unique name of this condition.
      name :: (Core.Maybe Core.Text),
      -- | Optional. The display (tag) color of this condition. This serves as part of a tag (in the future, we may add tag text as well as tag color, but that is not yet implemented in the UI). This value has no affect on the semantics of the delivered config and it is ignored by the backend, except for passing it through write\/read requests. Not having this value or having the \"CONDITION/DISPLAY/COLOR_UNSPECIFIED\" value (0) have the same meaning: Let the UI choose any valid color when displaying the condition.
      tagColor :: (Core.Maybe RemoteConfigCondition_TagColor)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RemoteConfigCondition' with the minimum fields required to make a request.
  newRemoteConfigCondition ::
    RemoteConfigCondition
  newRemoteConfigCondition =
    RemoteConfigCondition
      { description = Core.Nothing,
        expression = Core.Nothing,
        name = Core.Nothing,
        tagColor = Core.Nothing
      }
  
  instance Core.FromJSON RemoteConfigCondition where
    parseJSON =
      Core.withObject
        "RemoteConfigCondition"
        ( \o ->
            RemoteConfigCondition
              Core.<$> (o Core..:? "description")
              Core.<*> (o Core..:? "expression")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "tagColor")
        )
  
  instance Core.ToJSON RemoteConfigCondition where
    toJSON RemoteConfigCondition {..} =
      Core.object
        ( Core.catMaybes
            [ ("description" Core..=) Core.<$> description,
              ("expression" Core..=) Core.<$> expression,
              ("name" Core..=) Core.<$> name,
              ("tagColor" Core..=) Core.<$> tagColor
            ]
        )
  
  -- | While default/value and conditional/values are each optional, at least one of the two is required - otherwise, the parameter is meaningless (and an exception will be thrown by the validation logic).
  --
  -- /See:/ 'newRemoteConfigParameter' smart constructor.
  data RemoteConfigParameter = RemoteConfigParameter
    { -- | Optional - a map of (condition/name, value). The condition/name of the highest priority (the one listed first in the conditions array) determines the value of this parameter.
      conditionalValues :: (Core.Maybe RemoteConfigParameter_ConditionalValues),
      -- | Optional - value to set the parameter to, when none of the named conditions evaluate to \<code>true\<\/code>.
      defaultValue :: (Core.Maybe RemoteConfigParameterValue),
      -- | Optional. A description for this Parameter. Length must be less than or equal to 100 characters (or more precisely, unicode code points, which is defined in java\/com\/google\/wireless\/android\/config\/ConstsExporter.java). A description may contain any Unicode characters
      description :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RemoteConfigParameter' with the minimum fields required to make a request.
  newRemoteConfigParameter ::
    RemoteConfigParameter
  newRemoteConfigParameter =
    RemoteConfigParameter
      { conditionalValues = Core.Nothing,
        defaultValue = Core.Nothing,
        description = Core.Nothing
      }
  
  instance Core.FromJSON RemoteConfigParameter where
    parseJSON =
      Core.withObject
        "RemoteConfigParameter"
        ( \o ->
            RemoteConfigParameter
              Core.<$> (o Core..:? "conditionalValues")
              Core.<*> (o Core..:? "defaultValue")
              Core.<*> (o Core..:? "description")
        )
  
  instance Core.ToJSON RemoteConfigParameter where
    toJSON RemoteConfigParameter {..} =
      Core.object
        ( Core.catMaybes
            [ ("conditionalValues" Core..=) Core.<$> conditionalValues,
              ("defaultValue" Core..=) Core.<$> defaultValue,
              ("description" Core..=) Core.<$> description
            ]
        )
  
  -- | Optional - a map of (condition/name, value). The condition/name of the highest priority (the one listed first in the conditions array) determines the value of this parameter.
  --
  -- /See:/ 'newRemoteConfigParameter_ConditionalValues' smart constructor.
  newtype RemoteConfigParameter_ConditionalValues = RemoteConfigParameter_ConditionalValues
    { additional :: (Core.HashMap Core.Text RemoteConfigParameterValue)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RemoteConfigParameter_ConditionalValues' with the minimum fields required to make a request.
  newRemoteConfigParameter_ConditionalValues ::
    -- |  See 'additional'.
    Core.HashMap Core.Text RemoteConfigParameterValue ->
    RemoteConfigParameter_ConditionalValues
  newRemoteConfigParameter_ConditionalValues additional =
    RemoteConfigParameter_ConditionalValues {additional = additional}
  
  instance Core.FromJSON RemoteConfigParameter_ConditionalValues where
    parseJSON =
      Core.withObject
        "RemoteConfigParameter_ConditionalValues"
        ( \o ->
            RemoteConfigParameter_ConditionalValues
              Core.<$> (Core.parseJSONObject o)
        )
  
  instance Core.ToJSON RemoteConfigParameter_ConditionalValues where
    toJSON RemoteConfigParameter_ConditionalValues {..} =
      Core.toJSON additional
  
  -- | A RemoteConfigParameter\'s \"value\" (either the default value, or the value associated with a condition name) is either a string, or the \"use/in/app/default\" indicator (which means to leave out the parameter from the returned \<key, value> map that is the output of the parameter fetch). We represent the \"use/in/app/default\" as a bool, but (when using the boolean instead of the string) it should always be \<code>true\<\/code>.
  --
  -- /See:/ 'newRemoteConfigParameterValue' smart constructor.
  data RemoteConfigParameterValue = RemoteConfigParameterValue
    { -- | if true, omit the parameter from the map of fetched parameter values
      useInAppDefault :: (Core.Maybe Core.Bool),
      -- | the string to set the parameter to
      value :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'RemoteConfigParameterValue' with the minimum fields required to make a request.
  newRemoteConfigParameterValue ::
    RemoteConfigParameterValue
  newRemoteConfigParameterValue =
    RemoteConfigParameterValue
      { useInAppDefault = Core.Nothing,
        value = Core.Nothing
      }
  
  instance Core.FromJSON RemoteConfigParameterValue where
    parseJSON =
      Core.withObject
        "RemoteConfigParameterValue"
        ( \o ->
            RemoteConfigParameterValue
              Core.<$> (o Core..:? "useInAppDefault")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON RemoteConfigParameterValue where
    toJSON RemoteConfigParameterValue {..} =
      Core.object
        ( Core.catMaybes
            [ ("useInAppDefault" Core..=) Core.<$> useInAppDefault,
              ("value" Core..=) Core.<$> value
            ]
        )
  