package smtp

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"log/slog"
	"net"
	"strings"
	"testing"
	"time"

	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protolog"
)

func startLoggedTestServer(t *testing.T, sink MessageSink, logger *slog.Logger) (addr string, stop func()) {
	t.Helper()
	srv := NewServerWithMaxMessageBytesTLSAndLogger(sink, defaultMaxMessageBytes, nil, logger)

	listener, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("listener: %v", err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	done := make(chan struct{})
	go func() {
		_ = srv.Serve(ctx, listener)
		close(done)
	}()
	return listener.Addr().String(), func() {
		cancel()
		<-done
	}
}

func runFullSession(t *testing.T, addr string) {
	t.Helper()
	conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
	if err != nil {
		t.Fatalf("dial: %v", err)
	}
	defer func() { _ = conn.Close() }()
	reader := bufio.NewReader(conn)
	_, _ = reader.ReadString('\n')
	_, _ = conn.Write([]byte("EHLO client.example.com\r\n"))
	for {
		line, _ := reader.ReadString('\n')
		if strings.HasPrefix(line, "250 ") {
			break
		}
	}
	_, _ = conn.Write([]byte("MAIL FROM:<a@example.com>\r\n"))
	_, _ = reader.ReadString('\n')
	_, _ = conn.Write([]byte("RCPT TO:<b@example.com>\r\n"))
	_, _ = reader.ReadString('\n')
	_, _ = conn.Write([]byte("DATA\r\n"))
	_, _ = reader.ReadString('\n')
	_, _ = conn.Write([]byte("Subject: geheime betreffzeile Passwort=geheim123\r\n\r\nGeheimer Nachrichtentext.\r\n.\r\n"))
	_, _ = reader.ReadString('\n')
	_, _ = conn.Write([]byte("QUIT\r\n"))
	_, _ = reader.ReadString('\n')
}

// TestProtolog_NeverLogsMessageBodyOrRedactsCredentials ist die
// geforderte Pflichtprüfung 1 (ING-08) gegen den echten, laufenden
// SMTP-Server: Nachrichteninhalte (DATA-Body, hier bewusst mit einem
// eingebetteten "Passwort=geheim123" versehen) erscheinen NIE im Log,
// weil DATA-Zeilen strukturell gar nicht durch den Kommando-Logpfad
// laufen.
func TestProtolog_NeverLogsMessageBodyOrRedactsCredentials(t *testing.T) {
	var buf bytes.Buffer
	logger := slog.New(slog.NewJSONHandler(&buf, nil))
	sink := &fakeSink{}
	addr, stop := startLoggedTestServer(t, sink, logger)
	defer stop()

	runFullSession(t, addr)

	if sink.count() != 1 {
		t.Fatalf("testaufbau fehlerhaft: erwartete 1 angenommene nachricht, habe %d", sink.count())
	}
	logged := buf.String()
	if strings.Contains(logged, "geheim123") {
		t.Fatalf("nachrichteninhalt (mit eingebettetem geheimnis) im log gefunden:\n%s", logged)
	}
	if strings.Contains(logged, "Geheimer Nachrichtentext") {
		t.Fatalf("nachrichtentext im log gefunden:\n%s", logged)
	}
}

// TestProtolog_SessionFullyReconstructableByCorrelationID ist die
// geforderte Pflichtprüfung 2 (ING-08).
func TestProtolog_SessionFullyReconstructableByCorrelationID(t *testing.T) {
	var buf bytes.Buffer
	logger := slog.New(slog.NewJSONHandler(&buf, nil))
	sink := &fakeSink{}
	addr, stop := startLoggedTestServer(t, sink, logger)
	defer stop()

	runFullSession(t, addr)
	runFullSession(t, addr)

	firstLine := strings.SplitN(buf.String(), "\n", 2)[0]
	var raw map[string]any
	if err := json.Unmarshal([]byte(firstLine), &raw); err != nil {
		t.Fatalf("erste logzeile parsen: %v", err)
	}
	firstID, _ := raw["correlation_id"].(string)
	if firstID == "" {
		t.Fatalf("keine correlation_id in erster logzeile: %s", firstLine)
	}

	entries, err := protolog.Reconstruct(bytes.NewReader(buf.Bytes()), firstID)
	if err != nil {
		t.Fatalf("Reconstruct: %v", err)
	}
	// session_start, 4 kommandos (EHLO/MAIL/RCPT/DATA), session_end.
	// QUIT wird VOR seiner eigenen Verarbeitung noch geloggt, danach
	// endet die Sitzung -> zusätzlich 1 kommando-eintrag für QUIT.
	if len(entries) != 7 {
		t.Fatalf("erwartete 7 lückenlose einträge für die session, habe %d: %+v", len(entries), entries)
	}
	if entries[0].Msg != "session_start" || entries[len(entries)-1].Msg != "session_end" {
		t.Fatalf("session nicht lückenlos rekonstruierbar: %+v", entries)
	}
}

// TestProtolog_LoggingDoesNotRelevantlyImpactThroughput ist die
// geforderte Pflichtprüfung 3 (ING-08).
func TestProtolog_LoggingDoesNotRelevantlyImpactThroughput(t *testing.T) {
	const sessions = 100

	sinkOff := &fakeSink{}
	addrOff, stopOff := startLoggedTestServer(t, sinkOff, nil)
	startOff := time.Now()
	for i := 0; i < sessions; i++ {
		runFullSession(t, addrOff)
	}
	durationOff := time.Since(startOff)
	stopOff()

	var buf bytes.Buffer
	logger := slog.New(slog.NewJSONHandler(&buf, nil))
	sinkOn := &fakeSink{}
	addrOn, stopOn := startLoggedTestServer(t, sinkOn, logger)
	startOn := time.Now()
	for i := 0; i < sessions; i++ {
		runFullSession(t, addrOn)
	}
	durationOn := time.Since(startOn)
	stopOn()

	if durationOn > 3*durationOff+5*time.Millisecond {
		t.Fatalf("logging verlangsamt durchsatz relevant: ohne=%v, mit=%v", durationOff, durationOn)
	}
}