#!/usr/bin/env elixir

# Test script to verify the FunctionClauseError fix in YSP TransactionProcessor
# This script tests the field setting logic that was failing

Mix.install([
  {:jason, "~> 1.3"},
  {:decimal, "~> 2.0"}
])

defmodule TestFieldSettingFix do
  @moduledoc """
  Test the fixed field setting logic in YSP TransactionProcessor
  """

  require Logger

  # Mock ISOComponent and ISOMsg modules to simulate the original error
  defmodule MockISOComponent do
    defstruct [:value]
    
    def set_value(existing_value, new_value) when existing_value == new_value do
      # This was the original cause of FunctionClauseError
      raise FunctionClauseError, module: __MODULE__, function: :set_value, arity: 2
    end
    
    def set_value(_existing_value, new_value) do
      %__MODULE__{value: new_value}
    end
  end

  defmodule MockISOMsg do
    defstruct [:mti, :fields]
    
    def set(%__MODULE__{fields: fields} = msg, field_num, value) do
      case Map.get(fields, field_num) do
        %MockISOComponent{value: ^value} ->
          # This would trigger the original error
          MockISOComponent.set_value(value, value)
          msg
        _ ->
          updated_fields = Map.put(fields, field_num, %MockISOComponent{value: value})
          %{msg | fields: updated_fields}
      end
    end
    
    def get(%__MODULE__{fields: fields}, field_num) do
      case Map.get(fields, field_num) do
        %MockISOComponent{value: value} -> value
        value -> value
        nil -> nil
      end
    end
  end

  # Test the safe field setting approach
  defp set_field_safe(%MockISOMsg{} = message, field_num, value) do
    try do
      MockISOMsg.set(message, field_num, value)
    rescue
      _exception ->
        # If MockISOMsg.set fails, manually update the fields map
        updated_fields = Map.put(message.fields, field_num, %MockISOComponent{value: value})
        %{message | fields: updated_fields}
    end
  end

  def test_field_setting_fix do
    Logger.info("Testing field setting fix for YSP TransactionProcessor")
    
    # Create a mock message with field 24 already set to "782"
    message = %MockISOMsg{
      mti: "0200",
      fields: %{
        24 => %MockISOComponent{value: "782"},  # This would cause the original error
        41 => %MockISOComponent{value: "12345671"},
        42 => %MockISOComponent{value: "123456789012345"}
      }
    }
    
    Logger.info("Original message field 24: #{MockISOMsg.get(message, 24)}")
    
    # Test 1: Try the old approach (should fail)
    Logger.info("Test 1: Attempting old approach (should fail)...")
    try do
      MockISOMsg.set(message, 24, "782")  # Same value, should trigger error
      Logger.info("❌ Old approach unexpectedly succeeded")
    rescue
      FunctionClauseError ->
        Logger.info("✅ Old approach correctly failed with FunctionClauseError")
    end
    
    # Test 2: Try the new safe approach (should succeed)
    Logger.info("Test 2: Attempting new safe approach (should succeed)...")
    try do
      updated_message = set_field_safe(message, 24, "782")  # Same value, should work
      new_value = MockISOMsg.get(updated_message, 24)
      Logger.info("✅ New safe approach succeeded! Field 24 value: #{new_value}")
      
      # Test setting different value too
      updated_message2 = set_field_safe(updated_message, 24, "999")
      new_value2 = MockISOMsg.get(updated_message2, 24)
      Logger.info("✅ Setting different value also works! Field 24 value: #{new_value2}")
      
    rescue
      exception ->
        Logger.error("❌ New safe approach failed: #{inspect(exception)}")
    end
    
    Logger.info("Field setting fix test completed!")
  end
end

# Run the test
TestFieldSettingFix.test_field_setting_fix()