configuration.rb

# frozen_string_literal: true

require "timeout"
require_relative "api"
require_relative "provider_initialization_error"
require_relative "event_dispatcher"
require_relative "provider_event"
require_relative "provider_state_registry"
require_relative "provider/event_emitter"

module OpenFeature
  module SDK
    # Represents the configuration object for the global API where <tt>Provider</tt>, <tt>Hook</tt>,
    # and <tt>EvaluationContext</tt> are configured.
    # This class is not meant to be interacted with directly but instead through the <tt>OpenFeature::SDK.configure</tt>
    # method
    class Configuration
      extend Forwardable

      attr_accessor :evaluation_context, :hooks, :transaction_context_propagator
      attr_reader :logger

      def initialize
        @hooks = []
        @providers = {}
        @provider_mutex = Mutex.new
        @logger = nil
        @event_dispatcher = EventDispatcher.new(@logger)
        @provider_state_registry = ProviderStateRegistry.new
        @client_handlers = {}
        @client_handlers_mutex = Mutex.new
      end

      def add_hooks(*new_hooks)
        @hooks.concat(new_hooks.flatten)
      end

      def provider(domain: nil)
        @providers[domain] || @providers[nil]
      end

      def logger=(new_logger)
        @logger = new_logger
        @event_dispatcher.logger = new_logger if @event_dispatcher
      end

      def add_handler(event_type, handler)
        @event_dispatcher.add_handler(event_type, handler)
        run_immediate_handler(event_type, handler, nil)
      end

      def remove_handler(event_type, handler)
        @event_dispatcher.remove_handler(event_type, handler)
      end

      # @api private
      def add_client_handler(client, event_type, handler)
        @client_handlers_mutex.synchronize do
          @client_handlers[client] ||= Hash.new { |h, k| h[k] = [] }
          @client_handlers[client][event_type] << handler
        end

        run_immediate_handler(event_type, handler, client)
      end

      # @api private
      def remove_client_handler(client, event_type, handler)
        @client_handlers_mutex.synchronize do
          return unless @client_handlers[client]
          handlers = @client_handlers[client][event_type]
          handlers&.delete(handler)
        end
      end

      def set_provider(provider, domain: nil)
        set_provider_internal(provider, domain: domain, wait_for_init: false)
      end

      def set_provider_and_wait(provider, domain: nil)
        set_provider_internal(provider, domain: domain, wait_for_init: true)
      end

      def provider_state(provider)
        @provider_state_registry.get_state(provider)
      end

      def provider_tracked?(provider)
        @provider_state_registry.tracked?(provider)
      end

      def shutdown
        providers_to_shutdown = @provider_mutex.synchronize { @providers.values.uniq(&:object_id) }

        providers_to_shutdown.each do |prov|
          # Spec 1.7.9: Set provider state to NOT_READY before shutdown
          @provider_state_registry.set_initial_state(prov, ProviderState::NOT_READY)
          prov.shutdown if prov.respond_to?(:shutdown)
        rescue => e
          @logger&.warn("Error shutting down provider #{prov&.class&.name || "unknown"}: #{e.message}")
        end

        reset
      end

      private

      def reset
        @event_dispatcher.clear_all_handlers
        @client_handlers_mutex.synchronize do
          @client_handlers.clear
        end
        @provider_state_registry.clear
        @provider_mutex.synchronize do
          @providers.clear
        end
        @hooks.clear
        @evaluation_context = nil
        @transaction_context_propagator = nil
      end

      def set_provider_internal(provider, domain:, wait_for_init:)
        # Capture evaluation context before acquiring mutex to prevent race conditions
        context_for_init = @evaluation_context

        old_provider = nil
        needs_init = false
        needs_shutdown = false

        @provider_mutex.synchronize do
          validate_domain_scoped_binding!(provider, domain)

          old_provider = @providers[domain]

          new_providers = @providers.dup
          new_providers[domain] = provider
          @providers = new_providers

          # Spec 1.1.2.2: Only initialize if the provider is not already active
          was_bound_elsewhere = @providers.any? do |d, p|
            d != domain && p.equal?(provider) && @provider_state_registry.tracked?(p)
          end
          was_bound_here = old_provider&.equal?(provider) && @provider_state_registry.tracked?(provider)
          already_active = was_bound_elsewhere || was_bound_here
          needs_init = !already_active

          if needs_init
            @provider_state_registry.set_initial_state(provider)
            provider.send(:attach, self) if provider.is_a?(Provider::EventEmitter)
          end

          # Spec 1.1.2.3: Only shutdown old provider if it's no longer bound to any domain
          if old_provider && !old_provider.equal?(provider)
            still_bound = @providers.any? { |_, p| p.equal?(old_provider) }
            needs_shutdown = !still_bound
            @provider_state_registry.remove_provider(old_provider) unless still_bound
          end
        end

        # Shutdown old provider outside mutex to avoid blocking other operations
        if needs_shutdown
          begin
            old_provider.shutdown if old_provider.respond_to?(:shutdown)
          rescue => e
            @logger&.warn("Error shutting down previous provider #{old_provider&.class&.name || "unknown"}: #{e.message}")
          end
        end

        # Initialize provider outside the mutex to avoid blocking other operations
        if needs_init
          if wait_for_init
            init_provider(provider, context_for_init, domain: domain, raise_on_error: true)
          else
            Thread.new do
              init_provider(provider, context_for_init, domain: domain, raise_on_error: false)
            end
          end
        elsif wait_for_init
          # Provider already active; no init needed but still dispatch READY
          dispatch_provider_event(provider, ProviderEvent::PROVIDER_READY)
        end
      end

      def init_provider(provider, context, domain:, raise_on_error: false)
        call_init(provider, context, domain)

        dispatch_provider_event(provider, ProviderEvent::PROVIDER_READY)
      rescue => e
        # Spec 1.7.8: Propagate error code from provider if available
        error_code = if e.respond_to?(:error_code) && e.error_code
          e.error_code
        else
          Provider::ErrorCode::GENERAL
        end

        dispatch_provider_event(provider, ProviderEvent::PROVIDER_ERROR,
          error_code: error_code,
          message: e.message)

        if raise_on_error
          raise ProviderInitializationError.new(
            "Provider #{provider.class.name} initialization failed: #{e.message}",
            provider:,
            error_code: error_code,
            original_error: e
          )
        end
      end

      def dispatch_provider_event(provider, event_type, details = {})
        @provider_state_registry.update_state_from_event(provider, event_type, details)

        provider_name = extract_provider_name(provider)

        event_details = {
          provider_name: provider_name
        }.merge(details)

        run_handlers_for_provider(provider, event_type, event_details)
      end

      private

      def extract_provider_name(provider)
        provider.respond_to?(:metadata) ? provider.metadata.name : provider.class.name
      end

      def domain_scoped?(provider)
        return false unless declares_domain_scoped?(provider)

        provider.domain_scoped?
      end

      def declares_domain_scoped?(provider)
        class_declares_method?(provider.class, :domain_scoped?)
      end

      def provider_bindings(provider)
        @providers.select { |_, p| p.equal?(provider) }.keys
      end

      def validate_domain_scoped_binding!(provider, domain)
        return unless domain_scoped?(provider)

        bindings = provider_bindings(provider)
        return if bindings.empty?
        return if bindings.include?(domain)

        raise ArgumentError, "Cannot bind domain-scoped provider to more than one domain"
      end

      def call_init(provider, context, domain)
        return unless provider.respond_to?(:init)

        if init_accepts_domain?(provider)
          if init_accepts_evaluation_context?(provider)
            provider.init(context, domain: domain)
          else
            provider.init(domain: domain)
          end
        elsif init_accepts_evaluation_context?(provider)
          provider.init(context)
        else
          provider.init
        end
      end

      def init_accepts_domain?(provider)
        init_parameters(provider).any? do |kind, name|
          name == :domain || kind == :keyrest
        end
      end

      def init_accepts_evaluation_context?(provider)
        init_parameters(provider).any? do |kind, name|
          next false if name == :domain

          kind == :opt || kind == :req
        end
      end

      def init_parameters(provider)
        method = instance_method_on_class(provider.class, :init)
        method&.parameters || []
      end

      def instance_method_on_class(klass, method_name)
        while klass && klass != Object
          if klass.method_defined?(method_name, false)
            return klass.instance_method(method_name)
          end
          klass = klass.superclass
        end
        nil
      end

      def class_declares_method?(klass, method_name)
        while klass && klass != Object
          return true if klass.method_defined?(method_name, false)
          klass = klass.superclass
        end
        false
      end

      def run_handlers_for_provider(provider, event_type, event_details)
        # Run global handlers (API-level, no domain filtering)
        @event_dispatcher.trigger_event(event_type, event_details)

        # Run client handlers (domain-scoped)
        @client_handlers_mutex.synchronize do
          @client_handlers.each do |client, handlers_by_event|
            # Check if this client should receive events from this provider
            client_provider = provider(domain: client.metadata.domain)
            next unless client_provider&.equal?(provider)

            # Trigger handlers for this client
            handlers = handlers_by_event[event_type]
            handlers.each do |handler|
              handler.call(event_details)
            rescue => e
              @logger&.error("Client event handler failed: #{e.message}")
            end
          end
        end
      end

      def run_immediate_handler(event_type, handler, client)
        status_to_event = {
          ProviderState::READY => ProviderEvent::PROVIDER_READY,
          ProviderState::ERROR => ProviderEvent::PROVIDER_ERROR,
          ProviderState::FATAL => ProviderEvent::PROVIDER_ERROR,
          ProviderState::STALE => ProviderEvent::PROVIDER_STALE
        }

        if client.nil?
          # API-level handler: check all providers
          @providers.each do |domain, provider|
            next unless provider

            provider_state = @provider_state_registry.get_state(provider)

            if event_type == status_to_event[provider_state]
              event_details = build_event_details(provider)

              begin
                handler.call(event_details)
              rescue => e
                @logger&.error("Immediate API event handler failed: #{e.message}")
              end
            end
          end
        else
          # Client-level handler: check specific provider only
          client_provider = provider(domain: client.metadata.domain)
          return unless client_provider

          provider_state = @provider_state_registry.get_state(client_provider)

          if event_type == status_to_event[provider_state]
            event_details = build_event_details(client_provider)

            begin
              handler.call(event_details)
            rescue => e
              @logger&.error("Immediate client event handler failed: #{e.message}")
            end
          end
        end
      end

      def build_event_details(provider)
        stored_details = @provider_state_registry.get_details(provider)
        {provider_name: extract_provider_name(provider)}.merge(stored_details)
      end
    end
  end
end