defmodule DaProductApp.Switch.ConfigTest do
  use ExUnit.Case, async: true
  
  alias DaProductApp.Switch.Config
  
  describe "Config" do
    test "gets message handler configuration" do
      config = Config.get_message_handler_config()
      
      assert Map.has_key?(config, :handler)
      assert Map.has_key?(config, :enable_fallback)
      assert Map.has_key?(config, :timeout_ms)
      assert Map.has_key?(config, :tpdu)
      assert Map.has_key?(config, :error_handling)
    end
    
    test "gets protocol configuration" do
      config = Config.get_protocol_config()
      
      assert Map.has_key?(config, :tcp)
      assert Map.has_key?(config, :ssl)
      assert Map.has_key?(config, :processing)
      assert Map.has_key?(config, :logging)
      
      assert Map.has_key?(config.tcp, :port)
      assert Map.has_key?(config.tcp, :max_connections)
    end
    
    test "gets routing configuration" do
      config = Config.get_routing_config()
      
      assert Map.has_key?(config, :router)
      assert Map.has_key?(config, :strategies)
      assert Map.has_key?(config, :load_balancing)
      assert Map.has_key?(config, :failover)
      assert Map.has_key?(config, :bin_routing)
    end
    
    test "gets enhanced routing configuration" do
      config = Config.get_enhanced_routing_config()
      
      assert Map.has_key?(config, :default_strategy)
      assert Map.has_key?(config, :default_policy)
      assert Map.has_key?(config, :routing_table)
      assert Map.has_key?(config, :connector_weights)
      assert Map.has_key?(config, :merchant_configs)
      assert Map.has_key?(config, :processing_code_routing)
      assert Map.has_key?(config, :load_balancer)
      assert Map.has_key?(config, :connectors)
    end
    
    test "gets connector configuration" do
      config = Config.get_connector_config()
      
      assert Map.has_key?(config, :pool)
      assert Map.has_key?(config, :visa)
      assert Map.has_key?(config, :mastercard)
      assert Map.has_key?(config, :master)
      assert Map.has_key?(config, :fallback)
    end
    
    test "gets switch configuration" do
      config = Config.get_switch_config()
      
      assert Map.has_key?(config, :features)
      assert Map.has_key?(config, :performance)
      assert Map.has_key?(config, :security)
      assert Map.has_key?(config, :monitoring)
    end
    
    test "gets environment-specific configuration" do
      # Test different environments
      envs = [:dev, :test, :prod]
      
      for env do
        # We can't easily change the environment in tests,
        # so we'll just verify the function works
        config = Config.get_env_config()
        
        assert Map.has_key?(config, :log_level)
        assert Map.has_key?(config, :debug_enabled)
        assert Map.has_key?(config, :strict_validation)
        assert Map.has_key?(config, :enable_monitoring)
      end
    end
    
    test "determines message handler correctly" do
      handler = Config.get_message_handler()
      
      # Should return a valid module
      assert is_atom(handler)
      assert Code.ensure_loaded?(handler)
    end
    
    test "gets complete configuration" do
      config = Config.get_complete_config()
      
      assert Map.has_key?(config, :message_handler)
      assert Map.has_key?(config, :protocol)
      assert Map.has_key?(config, :routing)
      assert Map.has_key?(config, :connectors)
      assert Map.has_key?(config, :switch)
      assert Map.has_key?(config, :environment)
    end
    
    test "validates configuration" do
      result = Config.validate_config()
      
      # Should return ok or specific error
      case result do
        {:ok, :configuration_valid} -> :ok
        {:error, reason} -> 
          # Error is acceptable if configuration is incomplete in test environment
          assert is_atom(reason)
      end
    end
    
    test "reloads configuration" do
      result = Config.reload_config()
      
      assert {:ok, config} = result
      assert is_map(config)
    end
    
    test "enhanced routing config has required keys" do
      config = Config.get_enhanced_routing_config()
      
      # Verify routing table structure
      assert Map.has_key?(config.routing_table, :visa_network)
      assert Map.has_key?(config.routing_table, :mastercard_network)
      assert Map.has_key?(config.routing_table, :domestic_processor)
      
      # Verify connector weights
      assert Map.has_key?(config.connector_weights, :visa_primary)
      assert Map.has_key?(config.connector_weights, :mc_primary)
      
      # Verify load balancer config
      assert Map.has_key?(config.load_balancer, :algorithm)
      assert Map.has_key?(config.load_balancer, :health_check_interval)
      
      # Verify connector configs
      assert Map.has_key?(config.connectors, :visa_primary)
      assert Map.has_key?(config.connectors.visa_primary, :weight)
      assert Map.has_key?(config.connectors.visa_primary, :failure_threshold)
    end
    
    test "enhanced routing config has sensible defaults" do
      config = Config.get_enhanced_routing_config()
      
      # Check default strategy and policy
      assert config.default_strategy in [:bin_range, :merchant_config, :processing_code, :manual]
      assert config.default_policy in [:load_balance, :round_robin, :weighted, :failover]
      
      # Check algorithm
      assert config.load_balancer.algorithm in [:round_robin, :weighted, :least_connections, :response_time]
      
      # Check reasonable values
      assert config.load_balancer.health_check_interval > 0
      assert config.load_balancer.failure_threshold > 0
      assert config.load_balancer.recovery_threshold > 0
    end
    
    test "merchant configs are properly structured" do
      config = Config.get_enhanced_routing_config()
      
      for {_merchant_id, merchant_config} <- config.merchant_configs do
        assert Map.has_key?(merchant_config, :preferred_connectors)
        assert Map.has_key?(merchant_config, :routing_strategy)
        assert is_list(merchant_config.preferred_connectors)
        assert is_atom(merchant_config.routing_strategy)
      end
    end
    
    test "processing code routing is properly structured" do
      config = Config.get_enhanced_routing_config()
      
      for {processing_code, connectors} <- config.processing_code_routing do
        assert is_binary(processing_code)
        assert is_list(connectors)
        assert Enum.all?(connectors, &is_atom/1)
      end
    end
    
    test "connector configurations are complete" do
      config = Config.get_enhanced_routing_config()
      
      for {_connector, connector_config} <- config.connectors do
        assert Map.has_key?(connector_config, :weight)
        assert Map.has_key?(connector_config, :failure_threshold)
        assert Map.has_key?(connector_config, :recovery_timeout)
        assert Map.has_key?(connector_config, :timeout)
        
        assert is_integer(connector_config.weight)
        assert is_integer(connector_config.failure_threshold)
        assert is_integer(connector_config.recovery_timeout)
        assert is_integer(connector_config.timeout)
      end
    end
  end
  
  describe "Configuration validation" do
    test "validates message handler config structure" do
      # This tests the private validation functions indirectly
      config = Config.get_message_handler_config()
      
      # Verify required fields exist
      assert is_atom(config.handler)
      assert is_boolean(config.enable_fallback)
      assert is_integer(config.timeout_ms)
    end
    
    test "validates protocol config structure" do
      config = Config.get_protocol_config()
      
      assert is_integer(config.tcp.port)
      assert is_integer(config.tcp.max_connections)
      assert is_list(config.tcp.socket_options)
    end
    
    test "validates routing config structure" do
      config = Config.get_routing_config()
      
      assert config.router in [:enhanced, :legacy]
      assert is_list(config.strategies)
      assert is_map(config.load_balancing)
      assert is_map(config.failover)
    end
    
    test "validates connector config structure" do
      config = Config.get_connector_config()
      
      assert is_integer(config.pool.size)
      assert is_integer(config.pool.max_overflow)
      
      for connector <- [:visa, :mastercard, :master] do
        connector_config = Map.get(config, connector)
        assert is_boolean(connector_config.enabled)
        assert is_binary(connector_config.host)
        assert is_integer(connector_config.port)
      end
    end
  end
end