package datagram

import (
	"context"
	"errors"
	"testing"
	"time"
)

func TestDatagramSession_Dial(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test in short mode")
	}

	// Create two sessions - one for listener, one for dialer
	sam1, keys1 := setupTestSAM(t)
	defer sam1.Close()

	sam2, keys2 := setupTestSAM(t)
	defer sam2.Close()

	// Create listener session
	listenerSession, err := NewDatagramSession(sam1, "test_dial_listener", keys1, []string{
		"inbound.length=0", "outbound.length=0",
	})
	if err != nil {
		t.Fatalf("Failed to create listener session: %v", err)
	}
	defer listenerSession.Close()

	listener, err := listenerSession.Listen()
	if err != nil {
		t.Fatalf("Failed to create listener: %v", err)
	}
	defer listener.Close()

	// Create dialer session
	dialerSession, err := NewDatagramSession(sam2, "test_dial_dialer", keys2, []string{
		"inbound.length=0", "outbound.length=0",
	})
	if err != nil {
		t.Fatalf("Failed to create dialer session: %v", err)
	}
	defer dialerSession.Close()

	// Test dial
	dest, err := dialerSession.sam.Lookup(listener.Addr().String())
	if err != nil {
		t.Fatalf("Failed to lookup listener address: %v", err)
	}
	conn, err := dialerSession.Dial(dest.Base64())
	if err != nil {
		t.Fatalf("Failed to dial: %v", err)
	}
	defer conn.Close()

	// Verify connection properties
	if conn == nil {
		t.Fatal("Dial returned nil connection")
	}

	if conn.LocalAddr().String() != dialerSession.Addr().String() {
		t.Errorf("Local address mismatch: got %s, want %s",
			conn.LocalAddr().String(), dialerSession.Addr().String())
	}
}

func TestDatagramSession_DialContext(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test in short mode")
	}

	// Create two sessions
	sam1, keys1 := setupTestSAM(t)
	defer sam1.Close()

	sam2, keys2 := setupTestSAM(t)
	defer sam2.Close()

	// Create listener session
	listenerSession, err := NewDatagramSession(sam1, "test_dialctx_listener", keys1, nil)
	if err != nil {
		t.Fatalf("Failed to create listener session: %v", err)
	}
	defer listenerSession.Close()

	listener, err := listenerSession.Listen()
	if err != nil {
		t.Fatalf("Failed to create listener: %v", err)
	}
	defer listener.Close()

	// Create dialer session
	dialerSession, err := NewDatagramSession(sam2, "test_dialctx_dialer", keys2, nil)
	if err != nil {
		t.Fatalf("Failed to create dialer session: %v", err)
	}
	defer dialerSession.Close()

	// Test dial with context
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	addr, err := dialerSession.sam.Lookup(listener.Addr().String())
	if err != nil {
		t.Fatalf("Failed to lookup listener address: %v", err)
	}

	conn, err := dialerSession.DialContext(ctx, addr.Base64())
	if err != nil {
		t.Fatalf("Failed to dial with context: %v", err)
	}
	defer conn.Close()
	if conn == nil {
		t.Fatal("DialContext returned nil connection")
	}
}

func TestDatagramSession_DialContext_Timeout(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test in short mode")
	}

	sam, keys := setupTestSAM(t)
	defer sam.Close()

	session, err := NewDatagramSession(sam, "test_dialctx_timeout", keys, nil)
	if err != nil {
		t.Fatalf("Failed to create session: %v", err)
	}
	defer session.Close()

	// Use very short timeout to force timeout
	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Microsecond)
	defer cancel()

	addr, err := session.sam.Lookup("idk.i2p")
	if err != nil {
		t.Fatalf("Failed to lookup address: %v", err)
	}

	// Try to dial with short timeout
	conn, err := session.DialContext(ctx, addr.Base64())

	// Should get context deadline exceeded error
	if err == nil {
		if conn != nil {
			conn.Close()
		}
		t.Fatal("Expected timeout error")
	}

	// Should be a context deadline exceeded error
	if !errors.Is(err, context.DeadlineExceeded) {
		t.Errorf("Expected context.DeadlineExceeded, got: %v", err)
	}

	if conn != nil {
		t.Error("Expected nil connection on timeout")
	}
}

func TestDatagramSession_Dial_ClosedSession(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test in short mode")
	}

	sam, keys := setupTestSAM(t)
	defer sam.Close()

	session, err := NewDatagramSession(sam, "test_dial_closed", keys, nil)
	if err != nil {
		t.Fatalf("Failed to create session: %v", err)
	}

	// Close the session first
	session.Close()

	// Try to dial on closed session
	conn, err := session.Dial("test.b32.i2p")
	if err == nil {
		if conn != nil {
			conn.Close()
		}
		t.Error("Expected error when dialing on closed session")
	}

	if conn != nil {
		t.Error("Expected nil connection when session is closed")
	}
}

func TestDatagramSession_NewDialer(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test in short mode")
	}

	sam, keys := setupTestSAM(t)
	defer sam.Close()

	session, err := NewDatagramSession(sam, "test_newdialer", keys, nil)
	if err != nil {
		t.Fatalf("Failed to create session: %v", err)
	}
	defer session.Close()

	// Test that session can dial successfully (since NewDialer method doesn't exist)
	// This test now verifies the basic dialing functionality
	conn, err := session.Dial("test.b32.i2p")
	if err != nil {
		// Expected to fail with invalid address, but should not panic
		t.Logf("Dial failed as expected with invalid address: %v", err)
	} else if conn != nil {
		conn.Close()
	}
}