package tls_test

import (
	"crypto/tls"
	"encoding/binary"
	"io"
	"net"
	"testing"

	sniff "github.com/xtls/xray-core/common/protocol/tls"
)

func tivraHello(t *testing.T, version uint16) []byte {
	t.Helper()
	client, server := net.Pipe()
	done := make(chan struct{})
	go func() {
		defer close(done)
		c := tls.Client(client, &tls.Config{ServerName: "excluded.example.com", MinVersion: version, MaxVersion: version})
		_ = c.Handshake()
		_ = c.Close()
	}()
	header := make([]byte, 5)
	if _, err := io.ReadFull(server, header); err != nil {
		t.Fatal(err)
	}
	body := make([]byte, int(binary.BigEndian.Uint16(header[3:])))
	if _, err := io.ReadFull(server, body); err != nil {
		t.Fatal(err)
	}
	_ = server.Close()
	<-done
	return append(header, body...)
}

func tivraWithECH(record []byte, first bool) []byte {
	body := append([]byte(nil), record[5:]...)
	offset := 39 + int(body[38])
	offset += 2 + int(binary.BigEndian.Uint16(body[offset:]))
	offset += 1 + int(body[offset])
	old := append([]byte(nil), body[offset+2:]...)
	ech := []byte{0xfe, 0x0d, 0, 1, 0} // Any ECH presence, even GREASE/malformed, must stay proxied.
	extensions := append(old, ech...)
	if first {
		extensions = append(ech, old...)
	}
	body = append(body[:offset+2], extensions...)
	binary.BigEndian.PutUint16(body[offset:offset+2], uint16(len(extensions)))
	length := len(body) - 4
	body[1], body[2], body[3] = byte(length>>16), byte(length>>8), byte(length)
	header := append([]byte(nil), record[:5]...)
	binary.BigEndian.PutUint16(header[3:], uint16(len(body)))
	return append(header, body...)
}

func TestTivraECHRoutingConservative(t *testing.T) {
	for _, version := range []uint16{tls.VersionTLS12, tls.VersionTLS13} {
		hello := tivraHello(t, version)
		t.Setenv("TIVRA_XRAY_DISABLE_ECH_SNI", "1")
		h, err := sniff.SniffTLS(hello)
		if err != nil || h.Domain() != "excluded.example.com" {
			t.Fatalf("ordinary TLS %x lost hostname: %v", version, err)
		}
		for _, first := range []bool{false, true} {
			ech := tivraWithECH(hello, first)
			h, err = sniff.SniffTLS(ech)
			if err == nil || h != nil {
				t.Fatalf("ECH exposed outer SNI, first=%v", first)
			}
			// QUIC decrypts CRYPTO frames then calls this exact shared function.
			q := &sniff.SniffHeader{}
			if sniff.ReadClientHello(ech[5:], q) == nil || q.Domain() != "" {
				t.Fatal("QUIC shared parser exposed ECH hostname")
			}
			t.Setenv("TIVRA_XRAY_DISABLE_ECH_SNI", "0")
			h, err = sniff.SniffTLS(ech)
			if err != nil || h.Domain() != "excluded.example.com" {
				t.Fatal("empty-policy upstream behavior changed")
			}
			t.Setenv("TIVRA_XRAY_DISABLE_ECH_SNI", "1")
		}
		for n := 0; n < len(hello); n++ {
			if h, err := sniff.SniffTLS(hello[:n]); err == nil || h != nil {
				t.Fatalf("partial hello length %d exposed domain", n)
			}
		}
	}
}
