package calls

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"log/slog"
	"strings"
	"testing"
)

// minimalConfig is a Config with every startup refusal already
// satisfied outside development, so a test can flip exactly the one
// field it cares about (here, Relay) and see only that field's effect.
func minimalConfig(t *testing.T) Config {
	t.Helper()
	return Config{
		Env:              "production",
		Origin:           "https://meet.example",
		InstanceKey:      "calls-test-instance-key",
		DEK:              base64.StdEncoding.EncodeToString(make([]byte, 32)),
		Mailer:           failingSender{},
		AllowedAddresses: []string{"paul@example.com"},
	}
}

// relayVector is the base64 CARLOS_RELAY value for one region, using
// relay's own platform vector key and username suffix (relay_test.go)
// so a leak of either into a log line is unmistakable.
func relayVector(t *testing.T) string {
	t.Helper()
	const vectorKey = "uMhwW4P/9O5dQUIs91t2CCHGhwJbeiM0xQMQ2G0CJLU="
	regions := []map[string]any{{
		"region":          "eu-west-1",
		"urls":            []string{"stun:relay.eu-west-1.oncarlos.com:3478"},
		"key":             vectorKey,
		"username_suffix": "abc:meet:0123456789abcdef:k1",
	}}
	b, err := json.Marshal(regions)
	if err != nil {
		t.Fatal(err)
	}
	return base64.StdEncoding.EncodeToString(b)
}

func TestAMalformedRelayRefusesToStartOutsideDevelopment(t *testing.T) {
	cfg := minimalConfig(t)
	cfg.Env = "production"
	cfg.Relay = "%%%not-base64"
	_, err := resolve(cfg)
	if err == nil || !strings.Contains(err.Error(), "CARLOS_RELAY") {
		t.Fatalf("want a refusal naming the variable, got %v", err)
	}
	// Not just any refusal that happens to name the variable: this must
	// be config.go's own wording, so a case where relay.Parse's error
	// text alone satisfied the assertion above (and resolve silently
	// stopped wrapping it) would still be caught.
	if !strings.Contains(err.Error(), "is present but malformed") {
		t.Fatalf("want config.go's own refusal wording, got %v", err)
	}
	if strings.Contains(err.Error(), "%%%") {
		t.Fatal("the refusal echoes the value")
	}
}

// TestAMalformedRelayBuiltFromTheVectorNeverLeaksIt is the config-layer
// regression test for relay's Task 1 item 1: element 0's "no urls"
// error used to embed the region field verbatim, so a raw value whose
// region field held the platform vector key leaked it straight into
// resolve's refusal. The key and the username_suffix's incarnation
// segment are planted throughout the one region below so any of the
// three fields' checks reintroducing an echo trips this test.
func TestAMalformedRelayBuiltFromTheVectorNeverLeaksIt(t *testing.T) {
	const vectorKey = "uMhwW4P/9O5dQUIs91t2CCHGhwJbeiM0xQMQ2G0CJLU="
	cfg := minimalConfig(t)
	cfg.Env = "production"
	regions := []map[string]any{{
		"region":          vectorKey,
		"urls":            []string{},
		"key":             vectorKey,
		"username_suffix": "abc:meet:0123456789abcdef:k1",
	}}
	b, err := json.Marshal(regions)
	if err != nil {
		t.Fatal(err)
	}
	cfg.Relay = base64.StdEncoding.EncodeToString(b)
	_, err = resolve(cfg)
	if err == nil {
		t.Fatal("want a refusal")
	}
	if strings.Contains(err.Error(), vectorKey) || strings.Contains(err.Error(), "0123456789abcdef") {
		t.Fatalf("the refusal echoes the vector: %v", err)
	}
}

func TestAMalformedRelayIsIgnoredWithAWarningInDevelopment(t *testing.T) {
	var buf bytes.Buffer
	cfg := minimalConfig(t)
	cfg.Env = EnvDevelopment
	cfg.Logger = slog.New(slog.NewTextHandler(&buf, nil))
	cfg.Relay = "%%%not-base64"
	out, err := resolve(cfg)
	if err != nil {
		t.Fatal(err)
	}
	if out.relay != nil || out.relayConfigured {
		t.Fatal("a malformed relay must mean no relay in development")
	}
	if !strings.Contains(buf.String(), "CARLOS_RELAY") || strings.Contains(buf.String(), "%%%") {
		t.Fatalf("want one warning naming the variable and not the value, got %q", buf.String())
	}
}

func TestAGoodRelayIsParsedAndNeverLogged(t *testing.T) {
	var buf bytes.Buffer
	cfg := minimalConfig(t)
	cfg.Logger = slog.New(slog.NewTextHandler(&buf, nil))
	cfg.Relay = relayVector(t) // base64 of the one-region contract with the vector key
	out, err := resolve(cfg)
	if err != nil {
		t.Fatal(err)
	}
	if len(out.relay) != 1 || !out.relayConfigured {
		t.Fatalf("parsed len=%d relayConfigured=%v", len(out.relay), out.relayConfigured)
	}
	if strings.Contains(buf.String(), "uMhwW4P") || strings.Contains(buf.String(), "0123456789abcdef") {
		t.Fatal("the key or the suffix reached a log line")
	}
}

func TestNoRelayIsTheFloor(t *testing.T) {
	cfg := minimalConfig(t)
	cfg.Relay = ""
	out, err := resolve(cfg)
	if err != nil {
		t.Fatal(err)
	}
	if out.relay != nil || out.relayConfigured {
		t.Fatal("absent must mean the floor")
	}
}