#!/usr/bin/env elixir
# Test script for the enhanced header management system

Mix.install([
  {:jason, "~> 1.4"}
])

defmodule HeaderTestScript do
  @moduledoc """
  Comprehensive test script for the header management system.
  
  Tests:
  1. Header utilities (encoding/decoding)
  2. BaseHeader functionality
  3. HeaderFactory configuration parsing
  4. Integration with enhanced protocol
  """

  require Logger
  
  # Mock the required modules for testing
  defmodule HeaderUtils do
    def hex_to_binary("6000782000") do
      {:ok, <<0x60, 0x00, 0x78, 0x20, 0x00>>}
    end
    
    def hex_to_binary("123456") do
      {:ok, <<0x12, 0x34, 0x56>>}
    end
    
    def hex_to_binary(_), do: {:error, :invalid_hex}
    
    def binary_to_hex(<<0x60, 0x00, 0x78, 0x20, 0x00>>), do: "6000782000"
    def binary_to_hex(<<0x12, 0x34, 0x56>>), do: "123456"
    def binary_to_hex(binary), do: Base.encode16(binary, case: :upper)
    
    def bcd_to_binary("123456", 3), do: {:ok, <<0x12, 0x34, 0x56>>}
    def bcd_to_binary(_, _), do: {:error, :invalid_bcd}
    
    def binary_to_bcd(<<0x12, 0x34, 0x56>>), do: "123456"
    
    def string_to_binary(string, :hex), do: hex_to_binary(string)
    def string_to_binary(string, :bcd, length), do: bcd_to_binary(string, length)
    def string_to_binary(string, :ascii), do: {:ok, string}
    
    def matches_pattern?(binary, pattern), do: binary_part(binary, 0, byte_size(pattern)) == pattern
    
    def extract_bytes(binary, start, length), do: binary_part(binary, start, length)
    
    def validate_header_config(%{enabled: _, type: _, encoding: _}), do: {:ok, :valid}
    def validate_header_config(_), do: {:error, :invalid_config}
  end

  def run_tests do
    IO.puts("\n=== HEADER MANAGEMENT SYSTEM TEST ===\n")
    
    # Test 1: Header Utilities
    test_header_utils()
    
    # Test 2: Configuration Parsing
    test_configuration_parsing()
    
    # Test 3: Header Processing Scenarios
    test_header_scenarios()
    
    # Test 4: Integration Scenarios
    test_integration_scenarios()
    
    IO.puts("\n=== ALL TESTS COMPLETED ===\n")
  end

  defp test_header_utils do
    IO.puts("📋 Testing Header Utilities...")
    
    # Test hex conversion
    case HeaderUtils.hex_to_binary("6000782000") do
      {:ok, binary} ->
        hex_back = HeaderUtils.binary_to_hex(binary)
        if hex_back == "6000782000" do
          IO.puts("✅ Hex conversion: PASS")
        else
          IO.puts("❌ Hex conversion: FAIL - #{hex_back}")
        end
      {:error, _} ->
        IO.puts("❌ Hex conversion: FAIL - could not convert")
    end
    
    # Test BCD conversion
    case HeaderUtils.bcd_to_binary("123456", 3) do
      {:ok, binary} ->
        bcd_back = HeaderUtils.binary_to_bcd(binary)
        if bcd_back == "123456" do
          IO.puts("✅ BCD conversion: PASS")
        else
          IO.puts("❌ BCD conversion: FAIL - #{bcd_back}")
        end
      {:error, _} ->
        IO.puts("❌ BCD conversion: FAIL - could not convert")
    end
    
    # Test pattern matching
    {:ok, pattern} = HeaderUtils.hex_to_binary("6000782000")
    {:ok, test_data} = HeaderUtils.hex_to_binary("600078200012345678")
    
    if HeaderUtils.matches_pattern?(test_data, pattern) do
      IO.puts("✅ Pattern matching: PASS")
    else
      IO.puts("❌ Pattern matching: FAIL")
    end
    
    IO.puts()
  end

  defp test_configuration_parsing do
    IO.puts("⚙️  Testing Configuration Parsing...")
    
    # Test valid configuration
    valid_config = %{
      enabled: true,
      type: :base1,
      encoding: :hex,
      pattern: "6000782000",
      length: 5,
      source_address_offset: 2,
      source_address_length: 2,
      dest_address_offset: 4,
      dest_address_length: 2
    }
    
    case HeaderUtils.validate_header_config(valid_config) do
      {:ok, :valid} ->
        IO.puts("✅ Valid configuration: PASS")
      {:error, reason} ->
        IO.puts("❌ Valid configuration: FAIL - #{inspect(reason)}")
    end
    
    # Test invalid configuration
    invalid_config = %{enabled: true}  # Missing required fields
    
    case HeaderUtils.validate_header_config(invalid_config) do
      {:error, _} ->
        IO.puts("✅ Invalid configuration detection: PASS")
      {:ok, _} ->
        IO.puts("❌ Invalid configuration detection: FAIL - should have been invalid")
    end
    
    IO.puts()
  end

  defp test_header_scenarios do
    IO.puts("🔍 Testing Header Processing Scenarios...")
    
    # Scenario 1: Mercury standard TPDU
    mercury_config = %{
      enabled: true,
      type: :base1,
      encoding: :hex,
      pattern: "6000782000",
      length: 5,
      source_address_offset: 2,
      source_address_length: 2,
      dest_address_offset: 4,
      dest_address_length: 2
    }
    
    test_mercury_header(mercury_config)
    
    # Scenario 2: BCD header
    bcd_config = %{
      enabled: true,
      type: :base,
      encoding: :bcd,
      pattern: "123456",
      length: 3
    }
    
    test_bcd_header(bcd_config)
    
    # Scenario 3: Disabled headers
    disabled_config = %{enabled: false}
    
    test_disabled_headers(disabled_config)
    
    IO.puts()
  end

  defp test_mercury_header(config) do
    IO.puts("  Testing Mercury TPDU header...")
    
    # Simulate incoming data: TPDU + ISO message
    tpdu_hex = "6000782000"  # 5-byte TPDU
    iso_hex = "02003220000080000000000000001000000000000456"  # Sample ISO message
    full_data_hex = tpdu_hex <> iso_hex
    
    {:ok, full_data} = HeaderUtils.hex_to_binary(full_data_hex)
    
    # Simulate header processing
    result = process_test_headers(full_data, config)
    
    case result do
      {:ok, iso_data, header_info} ->
        expected_iso_size = byte_size(full_data) - 5  # Full data minus TPDU
        if byte_size(iso_data) == expected_iso_size do
          IO.puts("    ✅ Header extraction: PASS")
          IO.puts("    📊 Header info: #{inspect(header_info)}")
        else
          IO.puts("    ❌ Header extraction: FAIL - wrong ISO data size")
        end
      {:error, reason} ->
        IO.puts("    ❌ Header processing: FAIL - #{inspect(reason)}")
    end
  end

  defp test_bcd_header(config) do
    IO.puts("  Testing BCD header...")
    
    # Simulate BCD header + data
    {:ok, bcd_header} = HeaderUtils.bcd_to_binary("123456", 3)
    iso_data = "some ISO message data"
    full_data = bcd_header <> iso_data
    
    result = process_test_headers(full_data, config)
    
    case result do
      {:ok, remaining_data, header_info} ->
        if remaining_data == iso_data do
          IO.puts("    ✅ BCD header processing: PASS")
        else
          IO.puts("    ❌ BCD header processing: FAIL - wrong remaining data")
        end
      {:error, reason} ->
        IO.puts("    ❌ BCD header processing: FAIL - #{inspect(reason)}")
    end
  end

  defp test_disabled_headers(config) do
    IO.puts("  Testing disabled headers...")
    
    test_data = "raw ISO message without headers"
    result = process_test_headers(test_data, config)
    
    case result do
      {:ok, data, %{}} when data == test_data ->
        IO.puts("    ✅ Disabled headers: PASS")
      _ ->
        IO.puts("    ❌ Disabled headers: FAIL")
    end
  end

  defp test_integration_scenarios do
    IO.puts("🔗 Testing Integration Scenarios...")
    
    # Simulate channel contexts like those from incoming_listeners.exs
    primary_channel = %{
      name: "primary_iso8583",
      packager: "ISO87BPackager",
      header_config: %{
        enabled: true,
        type: :base1,
        encoding: :hex,
        pattern: "6000782000",
        length: 5,
        source_address_offset: 2,
        source_address_length: 2
      }
    }
    
    secondary_channel = %{
      name: "secondary_iso8583",
      header_config: %{
        enabled: true,
        type: :base,
        encoding: :bcd,
        pattern: "123456",
        length: 3
      }
    }
    
    test_channel = %{
      name: "test_channel",
      header_config: %{enabled: false}
    }
    
    test_channel_integration("Primary Channel (port 8583)", primary_channel)
    test_channel_integration("Secondary Channel (port 8584)", secondary_channel)  
    test_channel_integration("Test Channel (port 8585)", test_channel)
    
    IO.puts()
  end

  defp test_channel_integration(channel_name, channel_config) do
    IO.puts("  Testing #{channel_name}...")
    
    # Create test data based on channel configuration
    test_data = case get_in(channel_config, [:header_config, :enabled]) do
      true ->
        # Create data with appropriate header
        header_config = channel_config.header_config
        case header_config.encoding do
          :hex -> create_test_data_with_hex_header(header_config)
          :bcd -> create_test_data_with_bcd_header(header_config)
          _ -> "fallback test data"
        end
      _ ->
        "raw ISO data without headers"
    end
    
    # Simulate enhanced protocol processing
    result = process_test_headers(test_data, channel_config.header_config)
    
    case result do
      {:ok, _iso_data, header_info} ->
        IO.puts("    ✅ #{channel_name}: PASS")
        if map_size(header_info) > 0 do
          IO.puts("    📊 Extracted: #{inspect(Map.keys(header_info))}")
        end
      {:error, reason} ->
        IO.puts("    ❌ #{channel_name}: FAIL - #{inspect(reason)}")
    end
  end

  defp create_test_data_with_hex_header(config) do
    {:ok, header} = HeaderUtils.hex_to_binary(config.pattern)
    iso_msg = "0200322000008000000000000000100000000000456"
    header <> iso_msg
  end

  defp create_test_data_with_bcd_header(config) do
    {:ok, header} = HeaderUtils.bcd_to_binary(config.pattern, config.length)
    iso_msg = "sample ISO message"
    header <> iso_msg
  end

  # Mock the header processing function from enhanced protocol
  defp process_test_headers(data, header_config) do
    case header_config do
      nil ->
        {:ok, data, %{}}
      
      %{enabled: false} ->
        {:ok, data, %{}}
      
      config when is_map(config) ->
        # Simulate header processing
        case HeaderUtils.validate_header_config(config) do
          {:ok, :valid} ->
            # Extract header based on length
            header_length = config.length
            
            if byte_size(data) >= header_length do
              header_data = binary_part(data, 0, header_length)
              remaining_data = binary_part(data, header_length, byte_size(data) - header_length)
              
              # Check pattern if specified
              pattern_match = case Map.get(config, :pattern) do
                nil -> true
                pattern_string ->
                  case HeaderUtils.string_to_binary(pattern_string, config.encoding, header_length) do
                    {:ok, pattern_binary} ->
                      HeaderUtils.matches_pattern?(header_data, pattern_binary)
                    _ -> false
                  end
              end
              
              if pattern_match do
                header_info = %{
                  type: :extracted,
                  length: header_length,
                  data_hex: HeaderUtils.binary_to_hex(header_data),
                  pattern_match: true
                }
                {:ok, remaining_data, header_info}
              else
                {:ok, data, %{pattern_match: false}}
              end
            else
              {:error, :insufficient_data}
            end
          
          {:error, reason} ->
            {:error, reason}
        end
    end
  end

  # Summary function
  def print_configuration_examples do
    IO.puts("\n📖 HEADER CONFIGURATION EXAMPLES:\n")
    
    examples = %{
      "Mercury Standard TPDU" => %{
        enabled: true,
        type: :base1,
        encoding: :hex,
        pattern: "6000782000",
        length: 5,
        source_address_offset: 2,
        source_address_length: 2,
        dest_address_offset: 4,
        dest_address_length: 2
      },
      
      "BCD Header" => %{
        enabled: true,
        type: :base,
        encoding: :bcd,
        pattern: "123456",
        length: 3
      },
      
      "ASCII Header" => %{
        enabled: true,
        type: :custom,
        encoding: :ascii,
        pattern: "MERC",
        length: 4
      },
      
      "Disabled Headers" => %{
        enabled: false
      }
    }
    
    Enum.each(examples, fn {name, config} ->
      IO.puts("#{name}:")
      IO.puts("  #{inspect(config, pretty: true)}")
      IO.puts()
    end)
  end
end

# Run the test suite
HeaderTestScript.run_tests()
HeaderTestScript.print_configuration_examples()

IO.puts("🎯 NEXT STEPS:")
IO.puts("1. Start the enhanced application: mix phx.server")
IO.puts("2. Test with mock upstream server: elixir mock_upstream_server.exs")
IO.puts("3. Send test messages to ports 8583, 8584, 8585")
IO.puts("4. Check logs for header processing information")
IO.puts()