package xray

import (
	"crypto/tls"
	"crypto/x509"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync/atomic"
	"testing"
	"time"
)

const probeConfig = `{"log":{"loglevel":"none"},"outbounds":[{"protocol":"blackhole","tag":"default-block"},{"protocol":"freedom","tag":"fixture-route"}]}`

func startProbeFixture(t *testing.T, handler http.HandlerFunc) (*httptest.Server, *tls.Config) {
	t.Helper()
	server := httptest.NewTLSServer(handler)
	t.Cleanup(server.Close)
	roots := x509.NewCertPool()
	roots.AddCert(server.Certificate())
	return server, &tls.Config{RootCAs: roots, MinVersion: tls.VersionTLS12}
}

func startManagedProbeCore(t *testing.T) {
	t.Helper()
	if err := RunXray(probeConfig); err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = StopXray() })
}

func TestManagedProbeForcesExistingOutboundAndValidatesTLS(t *testing.T) {
	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("fixture-ok")) })
	startManagedProbeCore(t)
	// The default route blocks; only explicit fixture-route can reach TLS.
	result, err := probeManagedConnectivity("fixture-route", server.URL, 1000, trust)
	if err != nil || result.Status != "response" || result.HTTPStatus != 200 || result.Body != "fixture-ok" {
		t.Fatalf("forced route: %+v %v", result, err)
	}
	result, err = ProbeManagedConnectivity("fixture-route", server.URL, 1000)
	if err != nil || result.Status != "failed" || result.Reason != "tls_or_transport" {
		t.Fatalf("untrusted TLS accepted: %+v %v", result, err)
	}
	// Explicitly absent routes may never fall back to the default outbound.
	result, err = probeManagedConnectivity("missing", server.URL, 1000, trust)
	if err != nil || result.Status != "unavailable" || result.Reason != "missing_outbound" {
		t.Fatalf("missing route: %+v %v", result, err)
	}
}

func TestManagedProbeRejectsRedirectAndOversizedBody(t *testing.T) {
	var redirectFollowed atomic.Bool
	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case "/redirect":
			http.Redirect(w, r, "/secret", http.StatusFound)
		case "/secret":
			redirectFollowed.Store(true)
			_, _ = w.Write([]byte("bad"))
		default:
			_, _ = w.Write([]byte(strings.Repeat("a", 129)))
		}
	})
	startManagedProbeCore(t)
	result, err := probeManagedConnectivity("fixture-route", server.URL+"/redirect", 1000, trust)
	if err != nil || result.Reason != "redirect" || redirectFollowed.Load() {
		t.Fatalf("redirect followed: %+v %v", result, err)
	}
	result, err = probeManagedConnectivity("fixture-route", server.URL, 1000, trust)
	if err != nil || result.Reason != "response_too_large" || result.Body != "" {
		t.Fatalf("unbounded body: %+v %v", result, err)
	}
}

func TestManagedProbeTimeoutClosesVirtualConnection(t *testing.T) {
	entered, closed := make(chan struct{}), make(chan struct{})
	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) { close(entered); <-r.Context().Done(); close(closed) })
	startManagedProbeCore(t)
	started := time.Now()
	result, err := probeManagedConnectivity("fixture-route", server.URL, 200, trust)
	if err != nil || result.Status != "failed" || result.Reason != "timeout" || time.Since(started) > time.Second {
		t.Fatalf("unbounded timeout: %+v %v", result, err)
	}
	select {
	case <-entered:
	default:
		t.Fatal("fixture not reached")
	}
	select {
	case <-closed:
	case <-time.After(time.Second):
		t.Fatal("timed-out core connection not closed")
	}
}

func TestManagedProbeStopCancelsWithoutWaitingForDeadline(t *testing.T) {
	entered := make(chan struct{})
	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) { close(entered); <-r.Context().Done() })
	startManagedProbeCore(t)
	resultChannel := make(chan ManagedProbeResult, 1)
	go func() {
		result, _ := probeManagedConnectivity("fixture-route", server.URL, 7000, trust)
		resultChannel <- result
	}()
	select {
	case <-entered:
	case <-time.After(time.Second):
		t.Fatal("fixture not reached")
	}
	started := time.Now()
	if err := StopXray(); err != nil {
		t.Fatal(err)
	}
	if time.Since(started) > time.Second {
		t.Fatal("stop waited for probe timeout")
	}
	// A new generation must never adopt completion from the cancelled one.
	if err := RunXray(probeConfig); err != nil {
		t.Fatal(err)
	}
	select {
	case result := <-resultChannel:
		if result.Status != "unavailable" || result.Reason != "stopped" {
			t.Fatalf("stale success: %+v", result)
		}
	case <-time.After(time.Second):
		t.Fatal("probe not cancelled")
	}
}

func TestManagedProbeRequestValidationAndInactive(t *testing.T) {
	for _, target := range []string{"http://example.com/", "https://user:secret@example.com/", "https://example.com/#x", "/relative"} {
		if _, err := ProbeManagedConnectivity("route", target, 7000); err == nil {
			t.Fatalf("accepted %q", target)
		}
	}
	for _, timeout := range []int{-1, 99, 7001} {
		if _, err := ProbeManagedConnectivity("route", "https://example.com", timeout); err == nil {
			t.Fatal("bad timeout accepted")
		}
	}
	result, err := ProbeManagedConnectivity("route", "https://example.com", 0)
	if err != nil || result.Status != "unavailable" || result.Reason != "inactive" {
		t.Fatalf("inactive: %+v %v", result, err)
	}
}
