#!/usr/bin/env elixir

# Test the corrected BusinessLogic and IncomingMessageProcessor architecture

# Load required modules in dependency order  
Code.require_file("lib/da_product_app/mercury_iso8583/packagers/iso_component.ex")
Code.require_file("lib/da_product_app/mercury_iso8583/packagers/iso_msg.ex")
Code.require_file("lib/da_product_app/mercury_iso8583/processors/business_logic.ex")

alias DaProductApp.MercuryISO8583.Packagers.ISOMsg

# Create test message using ISOMsg functions
test_message = ISOMsg.new()
|> ISOMsg.set_mti("0200")
|> ISOMsg.set(3, "000000")      # Processing code
|> ISOMsg.set(4, "000000005000") # Transaction amount (50.00)  
|> ISOMsg.set(11, "123456")     # STAN
|> ISOMsg.set(12, "123456")     # Time
|> ISOMsg.set(13, "1225")       # Date

IO.puts("🧪 Testing Corrected Architecture")
IO.puts("=" |> String.duplicate(50))

# Test BusinessLogic with normal amount
IO.puts("\n1️⃣ Testing BusinessLogic.process_message/1 - Normal Amount")
result = DaProductApp.MercuryISO8583.Processors.BusinessLogic.process_message(test_message)
IO.puts("Result: #{inspect(result)}")

case result do
  {:approve, enriched_msg} ->
    IO.puts("✅ APPROVED: Message will be routed to upstream")
    IO.puts("   Enriched message: #{inspect(enriched_msg)}")
  
  {:decline, reason, enriched_msg} ->
    IO.puts("❌ DECLINED: #{inspect(reason)} - Local response will be created")
    IO.puts("   Enriched message: #{inspect(enriched_msg)}")
  
  {:refer, enriched_msg} ->
    IO.puts("⚠️  REFERRED: Needs manual review")
    IO.puts("   Enriched message: #{inspect(enriched_msg)}")
  
  {:error, reason} ->
    IO.puts("💥 ERROR: #{inspect(reason)}")
end

# Test BusinessLogic with high amount (should refer)
IO.puts("\n2️⃣ Testing BusinessLogic.process_message/1 - High Amount")
high_amount_message = ISOMsg.new()
|> ISOMsg.set_mti("0200")
|> ISOMsg.set(3, "000000")
|> ISOMsg.set(4, "000000500001")  # $5000.01 - above high_value_threshold
|> ISOMsg.set(11, "123457")
|> ISOMsg.set(12, "123456")
|> ISOMsg.set(13, "1225")

result2 = DaProductApp.MercuryISO8583.Processors.BusinessLogic.process_message(high_amount_message)
IO.puts("Result: #{inspect(result2)}")

case result2 do
  {:approve, _} -> IO.puts("✅ APPROVED")
  {:decline, reason, _} -> IO.puts("❌ DECLINED: #{inspect(reason)}")
  {:refer, _} -> IO.puts("⚠️  REFERRED: High value transaction")
  {:error, reason} -> IO.puts("💥 ERROR: #{inspect(reason)}")
end

# Test BusinessLogic with zero amount (should decline)
IO.puts("\n3️⃣ Testing BusinessLogic.process_message/1 - Invalid Amount")
zero_amount_message = ISOMsg.new()
|> ISOMsg.set_mti("0200")
|> ISOMsg.set(3, "000000")
|> ISOMsg.set(4, "000000000000")  # $0.00 - invalid
|> ISOMsg.set(11, "123458")
|> ISOMsg.set(12, "123456") 
|> ISOMsg.set(13, "1225")

result3 = DaProductApp.MercuryISO8583.Processors.BusinessLogic.process_message(zero_amount_message)
IO.puts("Result: #{inspect(result3)}")

case result3 do
  {:approve, _} -> IO.puts("✅ APPROVED")
  {:decline, reason, _} -> IO.puts("❌ DECLINED: #{inspect(reason)}")
  {:refer, _} -> IO.puts("⚠️  REFERRED")
  {:error, reason} -> IO.puts("💥 ERROR: #{inspect(reason)}")
end

IO.puts("\n" <> "=" |> String.duplicate(50))
IO.puts("🏗️ **ARCHITECTURE SUMMARY**")
IO.puts("=" |> String.duplicate(50))

IO.puts("""
✅ **FIXED ARCHITECTURE:**

1. **BusinessLogic.process_message/1 Returns:**
   - {:approve, enriched_message} → Route to upstream
   - {:decline, reason, enriched_message} → Create local response  
   - {:refer, enriched_message} → Create referral response
   - {:error, reason} → Handle processing error

2. **IncomingMessageProcessor Flow:**
   ```
   validate_message → enrich_message → apply_business_logic
         ↓                                    ↓
   {:approve, msg} → route_to_upstream → process_upstream_response
   {:decline, reason, msg} → create_decline_response (local)
   {:refer, msg} → create_referral_response (local)
   ```

3. **Eliminated Overlaps:**
   ❌ Removed response generation from BusinessLogic
   ❌ Removed duplicate validation logic
   ❌ Removed duplicate error handling
   ✅ BusinessLogic focuses on decisions only
   ✅ IncomingMessageProcessor handles orchestration and responses
   ✅ Clear separation of concerns

4. **Benefits:**
   - BusinessLogic is now a pure decision maker
   - No more architectural confusion about response generation
   - IncomingMessageProcessor properly orchestrates the flow
   - Upstream routing only happens when approved
   - Local responses for declines/referrals
""")

IO.puts("\n✨ Architecture fix completed successfully!")