require 'open_feature/sdk'
require 'json' # For JSON.dump

# API Initialization and configuration

OpenFeature::SDK.configure do |config|
  # your provider of choice, which will be used as the default provider
  config.set_provider(OpenFeature::SDK::Provider::InMemoryProvider.new(
    {
      "flag1" => true,
      "flag2" => 1
    }
  ))
end

# Create a client
client = OpenFeature::SDK.build_client

# fetching boolean value feature flag
bool_value = client.fetch_boolean_value(flag_key: 'boolean_flag', default_value: false)

# a details method is also available for more information about the flag evaluation
# see `ResolutionDetails` for more info
bool_details = client.fetch_boolean_details(flag_key: 'boolean_flag', default_value: false)

# fetching string value feature flag
string_value = client.fetch_string_value(flag_key: 'string_flag', default_value: 'default')

# fetching number value feature flag
float_value = client.fetch_number_value(flag_key: 'number_value', default_value: 1.0)
integer_value = client.fetch_number_value(flag_key: 'number_value', default_value: 1)

# get an object value
object = client.fetch_object_value(flag_key: 'object_value', default_value: { name: 'object'})

OpenFeature::SDK.configure do |config|
  # your provider of choice, which will be used as the default provider
  config.set_provider(OpenFeature::SDK::Provider::InMemoryProvider.new(
    {
      "v2_enabled" => true,
    }
  ))
end

# Using the SDK directly
begin
  OpenFeature::SDK.set_provider_and_wait(my_provider)
  puts "Provider is ready!"
rescue OpenFeature::SDK::ProviderInitializationError => e
  puts "Provider failed to initialize: #{e.message}"
  puts "Error code: #{e.error_code}"
  # original_error contains the underlying exception that caused the initialization failure
  puts "Original error: #{e.original_error}"
end

# With custom timeout (default is 30 seconds)
OpenFeature::SDK.set_provider_and_wait(my_provider, timeout: 60)

# Domain-specific provider
OpenFeature::SDK.set_provider_and_wait(my_provider, domain: "feature-flags")

# Via configuration block
OpenFeature::SDK.configure do |config|
  begin
    config.set_provider_and_wait(my_provider)
  rescue OpenFeature::SDK::ProviderInitializationError => e
    # Handle initialization failure
  end
end

OpenFeature::SDK.configure do |config|
  # you can set a global evaluation context here
  config.evaluation_context = OpenFeature::SDK::EvaluationContext.new("host" => "myhost.com")
end

# Evaluation context can be set on a client as well
client_with_context = OpenFeature::SDK.build_client(
  evaluation_context: OpenFeature::SDK::EvaluationContext.new("controller_name" => "admin")
)

# Invocation evaluation context can also be passed in during flag evaluation.
# During flag evaluation, invocation context takes precedence over client context
# which takes precedence over API (aka global) context.
bool_value = client.fetch_boolean_value(
  flag_key: 'boolean_flag',
  default_value: false,
  evaluation_context: OpenFeature::SDK::EvaluationContext.new("is_friday" => true)
)

# Define a hook
class MyHook
  include OpenFeature::SDK::Hooks::Hook

  def before(hook_context:, hints:)
    puts "Evaluating flag: #{hook_context.flag_key}"
    nil
  end

  def after(hook_context:, evaluation_details:, hints:)
    puts "Flag #{hook_context.flag_key} evaluated to: #{evaluation_details.value}"
  end

  def error(hook_context:, exception:, hints:)
    puts "Error evaluating #{hook_context.flag_key}: #{exception.message}"
  end

  def finally(hook_context:, evaluation_details:, hints:)
    puts "Evaluation complete for #{hook_context.flag_key}"
  end
end

# Register at the API (global) level
OpenFeature::SDK.hooks << MyHook.new

# Register at the client level
client = OpenFeature::SDK.build_client
client.hooks << MyHook.new

# Register at the invocation level
client.fetch_boolean_value(
  flag_key: "my-flag",
  default_value: false,
  hooks: [MyHook.new]
)

# Use the SDK's default logger (from Configuration)
OpenFeature::SDK.hooks << OpenFeature::SDK::Hooks::LoggingHook.new

# Or provide your own logger
logger = Logger.new($stdout)
OpenFeature::SDK.hooks << OpenFeature::SDK::Hooks::LoggingHook.new(logger: logger)

# Optionally include evaluation context in log output
OpenFeature::SDK.hooks << OpenFeature::SDK::Hooks::LoggingHook.new(
  logger: logger,
  include_evaluation_context: true
)

OpenFeature::SDK.configure do |config|
  config.set_provider(OpenFeature::SDK::Provider::NoOpProvider.new, domain: "legacy_flags")
end

# Create a client for a different domain, this will use the provider assigned to that domain
legacy_flag_client = OpenFeature::SDK.build_client(domain: "legacy_flags")

# Register event handlers at the API (global) level
ready_handler = ->(event_details) do
  puts "Provider #{event_details[:provider].metadata.name} is ready!"
end

OpenFeature::SDK.add_handler(OpenFeature::SDK::ProviderEvent::PROVIDER_READY, ready_handler)

# The SDK automatically emits lifecycle events. Providers can emit additional spontaneous events
# using the EventEmitter mixin to signal internal state changes like configuration updates.
class MyEventAwareProvider
  include OpenFeature::SDK::Provider::EventEmitter

  def init(evaluation_context)
    # Start background process to monitor for configuration changes
    # Note: SDK automatically emits PROVIDER_READY when init completes successfully
    start_background_process
  end

  def start_background_process
    Thread.new do
      # Monitor for configuration changes and emit events when they occur
      if configuration_changed?
        emit_event(
          OpenFeature::SDK::ProviderEvent::PROVIDER_CONFIGURATION_CHANGED,
          message: "Flag configuration updated"
        )
      end
    end
  end
end

# Remove specific handlers when no longer needed
OpenFeature::SDK.remove_handler(OpenFeature::SDK::ProviderEvent::PROVIDER_READY, ready_handler)

# Shut down all registered providers and clear state
OpenFeature::SDK.shutdown

class MyProvider
  def shutdown
    # Perform any shutdown/reclamation steps with flag management system here
  end
end

client = OpenFeature::SDK.build_client

# Simple tracking event
client.track("checkout_completed")

# With evaluation context
client.track(
  "purchase",
  evaluation_context: OpenFeature::SDK::EvaluationContext.new(targeting_key: "user-123")
)

# With tracking event details (optional numeric value + custom fields)
details = OpenFeature::SDK::TrackingEventDetails.new(
  value: 99.99,
  plan: "premium",
  currency: "USD"
)
client.track("subscription", tracking_event_details: details)

# Set up the propagator
OpenFeature::SDK.set_transaction_context_propagator(
  OpenFeature::SDK::ThreadLocalTransactionContextPropagator.new
)

# Set transaction context (e.g. in a request middleware)
OpenFeature::SDK.set_transaction_context(
  OpenFeature::SDK::EvaluationContext.new(targeting_key: "user-123", "email" => "user@example.com")
)

# Transaction context is automatically merged during flag evaluation.
# Merge precedence: invocation > client > transaction > API (global)
client = OpenFeature::SDK.build_client
client.fetch_boolean_value(flag_key: "my-flag", default_value: false)

class MyRequestScopedPropagator
  include OpenFeature::SDK::TransactionContextPropagator

  def set_transaction_context(evaluation_context)
    # Store context in your request-scoped storage
    RequestStore[:openfeature_context] = evaluation_context
  end

  def get_transaction_context
    RequestStore[:openfeature_context]
  end
end

class MyProvider
  def init
    # Perform any initialization steps with flag management system here
    # Return value is ignored
    # **Note** The OpenFeature spec defines a lifecycle method called `initialize` to be called when a new provider is set.
    # To avoid conflicting with the Ruby `initialize` method, this method should be named `init` when creating a provider.
  end

  def shutdown
    # Perform any shutdown/reclamation steps with flag management system here
    # Return value is ignored
  end

  def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
    # Retrieve a boolean value from provider source
  end

  def fetch_string_value(flag_key:, default_value:, evaluation_context: nil)
    # Retrieve a string value from provider source
  end

  def fetch_number_value(flag_key:, default_value:, evaluation_context: nil)
    # Retrieve a numeric value from provider source
  end

  def fetch_integer_value(flag_key:, default_value:, evaluation_context: nil)
    # Retrieve a integer value from provider source
  end

  def fetch_float_value(flag_key:, default_value:, evaluation_context: nil)
    # Retrieve a float value from provider source
  end

  def fetch_object_value(flag_key:, default_value:, evaluation_context: nil)
    # Retrieve a hash value from provider source
  end

  # Optional: implement tracking support (spec 6.1.4)
  # If not defined, Client#track is a no-op
  def track(tracking_event_name, evaluation_context:, tracking_event_details:)
    # Record a tracking event with your flag management system
  end
end

class MyLoggingHook
  include OpenFeature::SDK::Hooks::Hook

  def before(hook_context:, hints:)
    puts "Evaluating #{hook_context.flag_key}"
    nil # Return nil or an EvaluationContext to merge
  end

  def after(hook_context:, evaluation_details:, hints:)
    puts "Result: #{evaluation_details.value}"
  end

  # error and finally are optional — only define what you need
end