package sigcheck

import (
	"bytes"
	"context"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/base64"
	"fmt"
	"math/big"
	"strings"
	"testing"
	"time"

	"go.mozilla.org/pkcs7"

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

// generateTestCert erzeugt ein selbstsigniertes RSA-Testzertifikat —
// keine externe CA nötig (analog zu tlscert.GenerateSelfSigned, ING-06).
func generateTestCert(t *testing.T, notBefore, notAfter time.Time) (*x509.Certificate, *rsa.PrivateKey) {
	t.Helper()
	key, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		t.Fatalf("schlüssel erzeugen: %v", err)
	}
	serial, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
	if err != nil {
		t.Fatalf("seriennummer erzeugen: %v", err)
	}
	template := x509.Certificate{
		SerialNumber: serial,
		Subject:      pkix.Name{CommonName: "ARC-10 Testsignatur"},
		NotBefore:    notBefore,
		NotAfter:     notAfter,
		KeyUsage:     x509.KeyUsageDigitalSignature,
		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageEmailProtection},
	}
	der, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
	if err != nil {
		t.Fatalf("zertifikat erzeugen: %v", err)
	}
	cert, err := x509.ParseCertificate(der)
	if err != nil {
		t.Fatalf("zertifikat parsen: %v", err)
	}
	return cert, key
}

// buildSignedMessage signiert plaintext EINMALIG (S/MIME opaque,
// application/pkcs7-mime; smime-type=signed-data) und liefert die
// vollständige RFC822-Rohnachricht.
func buildSignedMessage(t *testing.T, cert *x509.Certificate, key *rsa.PrivateKey, plaintext string) []byte {
	t.Helper()
	sd, err := pkcs7.NewSignedData([]byte(plaintext))
	if err != nil {
		t.Fatalf("signeddata erzeugen: %v", err)
	}
	if err := sd.AddSigner(cert, key, pkcs7.SignerInfoConfig{}); err != nil {
		t.Fatalf("signer hinzufügen: %v", err)
	}
	der, err := sd.Finish()
	if err != nil {
		t.Fatalf("signatur abschließen: %v", err)
	}
	return wrapAsRFC822(der)
}

func wrapAsRFC822(pkcs7DER []byte) []byte {
	encoded := base64.StdEncoding.EncodeToString(pkcs7DER)
	var b bytes.Buffer
	b.WriteString("From: absender@example.com\r\n")
	b.WriteString("To: empfaenger@example.com\r\n")
	b.WriteString("Subject: ARC-10 Testmail\r\n")
	b.WriteString("Content-Type: application/pkcs7-mime; smime-type=signed-data; name=\"smime.p7m\"\r\n")
	b.WriteString("Content-Transfer-Encoding: base64\r\n")
	b.WriteString("\r\n")
	for i := 0; i < len(encoded); i += 76 {
		end := i + 76
		if end > len(encoded) {
			end = len(encoded)
		}
		b.WriteString(encoded[i:end])
		b.WriteString("\r\n")
	}
	return b.Bytes()
}

// TestDetect_UnsignedMessageNotDetected ist Teil der geforderten
// Pflichtprüfung/Akzeptanzkriterium 1: unsignierte Mails durchlaufen
// KEINE zusätzliche Prüfung.
func TestDetect_UnsignedMessageNotDetected(t *testing.T) {
	raw := []byte("From: a@example.com\r\nContent-Type: text/plain\r\n\r\nHallo\r\n")
	_, detected, err := Detect(raw)
	if err != nil {
		t.Fatalf("detect: %v", err)
	}
	if detected {
		t.Fatalf("unsignierte nachricht wurde fälschlich als signiert erkannt")
	}
}

// TestDetect_SMIMEOpaqueMessageDetected deckt Akzeptanzkriterium 1
// (S/MIME-Erkennung) ab.
func TestDetect_SMIMEOpaqueMessageDetected(t *testing.T) {
	now := time.Now()
	cert, key := generateTestCert(t, now.Add(-time.Hour), now.Add(time.Hour))
	raw := buildSignedMessage(t, cert, key, "Hallo Welt")

	kind, detected, err := Detect(raw)
	if err != nil {
		t.Fatalf("detect: %v", err)
	}
	if !detected || kind != KindSMIME {
		t.Fatalf("erwartete erkannte S/MIME-signatur, habe kind=%q detected=%v", kind, detected)
	}
}

// TestDetect_PGPMIMEDetectedButNotCryptographicallyVerified belegt die
// dokumentierte Scope-Grenze: PGP/MIME wird ERKANNT (Akzeptanzkriterium
// 1), Verify liefert aber bewusst "Prüfung nicht möglich"
// (Akzeptanzkriterium 2, einer der drei vorgesehenen Zustände) statt
// eines stillen Fallbacks oder Absturzes.
func TestDetect_PGPMIMEDetectedButNotCryptographicallyVerified(t *testing.T) {
	raw := []byte("From: a@example.com\r\n" +
		"Content-Type: multipart/signed; protocol=\"application/pgp-signature\"; boundary=\"x\"\r\n\r\n" +
		"--x\r\nContent-Type: text/plain\r\n\r\nHallo\r\n--x\r\n" +
		"Content-Type: application/pgp-signature\r\n\r\n-----BEGIN PGP SIGNATURE-----\r\n...\r\n-----END PGP SIGNATURE-----\r\n--x--\r\n")

	kind, detected, err := Detect(raw)
	if err != nil {
		t.Fatalf("detect: %v", err)
	}
	if !detected || kind != KindPGP {
		t.Fatalf("erwartete erkannte pgp/mime-signatur, habe kind=%q detected=%v", kind, detected)
	}

	result, err := Verify(raw, kind, time.Now())
	if err != nil {
		t.Fatalf("verify: %v", err)
	}
	if result.Status != StatusUnverifiable {
		t.Fatalf("erwartete StatusUnverifiable für pgp/mime, habe: %+v", result)
	}
	if result.Reason == "" {
		t.Fatalf("erwartete erklärenden grund für 'prüfung nicht möglich'")
	}
}

// TestVerify_ValidSMIMESignatureRecognizedAsValid ist die geforderte
// Pflichtprüfung 1 (ARC-10): Test mit einer echten S/MIME-signierten
// Testmail — Prüfergebnis "gültig" korrekt erkannt und archiviert.
func TestVerify_ValidSMIMESignatureRecognizedAsValid(t *testing.T) {
	now := time.Now()
	cert, key := generateTestCert(t, now.Add(-time.Hour), now.Add(time.Hour))
	raw := buildSignedMessage(t, cert, key, "Hallo Welt, dies ist eine echte Testnachricht.")

	kind, detected, err := Detect(raw)
	if err != nil || !detected {
		t.Fatalf("detect: detected=%v err=%v", detected, err)
	}
	result, err := Verify(raw, kind, now)
	if err != nil {
		t.Fatalf("verify: %v", err)
	}
	if result.Status != StatusValid {
		t.Fatalf("erwartete StatusValid, habe: %+v", result)
	}
	if result.SignerSubject == "" {
		t.Fatalf("erwartete zertifikatsdaten (SignerSubject) im ergebnis")
	}

	// Archivieren + Abrufen (Akzeptanzkriterium 2/3), echter LocalDriver.
	svc := storage.NewService(storage.NewLocalDriver(t.TempDir()), noopReporter{}, "mandant-arc10")
	archiveKey := storage.ArchiveKey("rechnungen@example.com", now, "msg-arc10-valid", 0)
	if err := SaveResult(context.Background(), svc, archiveKey, result); err != nil {
		t.Fatalf("SaveResult: %v", err)
	}
	loaded, err := LoadResult(context.Background(), svc, archiveKey)
	if err != nil {
		t.Fatalf("LoadResult: %v", err)
	}
	if loaded.Status != StatusValid || loaded.SignerSubject != result.SignerSubject {
		t.Fatalf("archivierter nachweis weicht vom ursprünglichen ergebnis ab: %+v vs %+v", loaded, result)
	}
}

// TestVerify_TamperedContentDetectedAsInvalid ist die geforderte
// Pflichtprüfung 2 (ARC-10): Test mit einer signierten Mail mit
// MANIPULIERTEM Inhalt — Prüfergebnis "ungültig" korrekt erkannt. Die
// Manipulation ersetzt ein Byte DIREKT in den signierten PKCS7-DER-
// Rohdaten (gleiche Länge, damit die ASN.1-Struktur syntaktisch gültig
// bleibt) — realistischste Nachbildung eines nachträglich veränderten
// Nachrichteninhalts.
func TestVerify_TamperedContentDetectedAsInvalid(t *testing.T) {
	now := time.Now()
	cert, key := generateTestCert(t, now.Add(-time.Hour), now.Add(time.Hour))
	const plaintext = "Ursprünglicher, signierter Inhalt"

	sd, err := pkcs7.NewSignedData([]byte(plaintext))
	if err != nil {
		t.Fatalf("signeddata: %v", err)
	}
	if err := sd.AddSigner(cert, key, pkcs7.SignerInfoConfig{}); err != nil {
		t.Fatalf("signer: %v", err)
	}
	der, err := sd.Finish()
	if err != nil {
		t.Fatalf("finish: %v", err)
	}

	// Denselben Byte-Bereich (den signierten Klartext innerhalb der DER-
	// Struktur) durch einen gleich langen, ANDEREN Text ersetzen.
	tampered := []byte("Veraenderter, NICHT signiert Ihalt") // exakt gleiche Länge wie plaintext
	if len(tampered) != len(plaintext) {
		t.Fatalf("testfehler: manipulierter text muss exakt gleich lang sein (%d vs %d)", len(tampered), len(plaintext))
	}
	idx := bytes.Index(der, []byte(plaintext))
	if idx < 0 {
		t.Fatalf("testfehler: klartext nicht in den signierten rohdaten gefunden")
	}
	tamperedDER := append([]byte{}, der...)
	copy(tamperedDER[idx:idx+len(tampered)], tampered)

	raw := wrapAsRFC822(tamperedDER)
	kind, detected, err := Detect(raw)
	if err != nil || !detected {
		t.Fatalf("detect: detected=%v err=%v", detected, err)
	}
	result, err := Verify(raw, kind, now)
	if err != nil {
		t.Fatalf("verify: %v", err)
	}
	if result.Status != StatusInvalid {
		t.Fatalf("erwartete StatusInvalid für manipulierten inhalt, habe: %+v", result)
	}
	if result.Reason == "" {
		t.Fatalf("erwartete erklärenden grund für 'ungültig'")
	}
}

// TestVerify_ArchivedResultUnaffectedBySimulatedLaterCertificateExpiry
// ist die geforderte Pflichtprüfung 3 (ARC-10): simulierter
// Zertifikatsablauf NACH Archivierung — der archivierte Prüfnachweis
// bleibt unverändert abrufbar und zeigt weiterhin "zum
// Archivierungszeitpunkt gültig", obwohl eine SPÄTERE Live-Prüfung
// derselben Rohdaten mit einem SPÄTEREN Prüfzeitpunkt "ungültig"
// (abgelaufen) ergäbe.
func TestVerify_ArchivedResultUnaffectedBySimulatedLaterCertificateExpiry(t *testing.T) {
	archivalTime := time.Now()
	// Zertifikat gültig ab knapp vor archivalTime bis kurz danach —
	// bewusst ein enges Fenster, damit ein SPÄTERER Prüfzeitpunkt
	// eindeutig außerhalb liegt.
	certNotBefore := archivalTime.Add(-time.Minute)
	certNotAfter := archivalTime.Add(time.Minute)
	cert, key := generateTestCert(t, certNotBefore, certNotAfter)
	raw := buildSignedMessage(t, cert, key, "Nachweis für langfristige Aufbewahrung")

	kind, detected, err := Detect(raw)
	if err != nil || !detected {
		t.Fatalf("detect: detected=%v err=%v", detected, err)
	}

	// 1. Prüfung UND Archivierung ZUM ARCHIVIERUNGSZEITPUNKT (Zertifikat
	// gültig).
	archivedResult, err := Verify(raw, kind, archivalTime)
	if err != nil {
		t.Fatalf("verify (archivierung): %v", err)
	}
	if archivedResult.Status != StatusValid {
		t.Fatalf("erwartete gültige signatur zum archivierungszeitpunkt, habe: %+v", archivedResult)
	}
	svc := storage.NewService(storage.NewLocalDriver(t.TempDir()), noopReporter{}, "mandant-arc10-expiry")
	archiveKey := storage.ArchiveKey("vertraege@example.com", archivalTime, "msg-arc10-expiry", 0)
	if err := SaveResult(context.Background(), svc, archiveKey, archivedResult); err != nil {
		t.Fatalf("SaveResult: %v", err)
	}

	// 2. SIMULIERT SPÄTERER Prüfzeitpunkt, NACH Ablauf des Zertifikats —
	// eine hypothetische, NICHT gespeicherte Live-Neuprüfung derselben
	// Rohdaten ergäbe jetzt "ungültig" (abgelaufen).
	muchLater := certNotAfter.Add(365 * 24 * time.Hour)
	liveCheckLater, err := Verify(raw, kind, muchLater)
	if err != nil {
		t.Fatalf("verify (simulierte spätere prüfung): %v", err)
	}
	if liveCheckLater.Status != StatusInvalid {
		t.Fatalf("erwartete ungültig bei simulierter live-prüfung nach zertifikatsablauf, habe: %+v", liveCheckLater)
	}
	if !strings.Contains(liveCheckLater.Reason, "gültig") {
		t.Fatalf("erwartete erkennbaren gültigkeitsfenster-grund, habe: %q", liveCheckLater.Reason)
	}

	// 3. Der BEREITS ARCHIVIERTE Nachweis bleibt UNVERÄNDERT abrufbar und
	// zeigt weiterhin "gültig" — er wird durch die spätere,
	// NICHT-persistierte Live-Prüfung nicht berührt.
	loaded, err := LoadResult(context.Background(), svc, archiveKey)
	if err != nil {
		t.Fatalf("LoadResult: %v", err)
	}
	if loaded.Status != StatusValid {
		t.Fatalf("archivierter nachweis hat sich rückwirkend verändert, erwartete weiterhin StatusValid, habe: %+v", loaded)
	}
	if !loaded.CheckedAt.Equal(archivalTime.Truncate(time.Second)) && loaded.CheckedAt.Sub(archivalTime).Abs() > time.Second {
		t.Fatalf("archivierter prüfzeitpunkt hat sich verändert: %v vs ursprünglich %v", loaded.CheckedAt, archivalTime)
	}
}

type noopReporter struct{}

func (noopReporter) Report(context.Context, string, string, int64) error { return nil }

var _ = fmt.Sprintf // Platzhalter, falls fmt künftig entfällt