package helps

import (
	"bytes"
	"context"
	"fmt"
	"net/http"
	"strings"
	"testing"

	"github.com/router-for-me/CLIProxyAPI/v7/internal/config"
	_ "github.com/router-for-me/CLIProxyAPI/v7/internal/translator"
	sdktranslator "github.com/router-for-me/CLIProxyAPI/v7/sdk/translator"
	"github.com/tidwall/gjson"
	"github.com/tidwall/sjson"
)

type pairRequestPluginHooks struct {
	calls int64
}

func (h *pairRequestPluginHooks) NormalizeRequest(_ context.Context, _, _ sdktranslator.Format, _ string, body []byte, _ bool) []byte {
	h.calls++
	updated, _ := sjson.SetBytes(body, "plugin_call", h.calls)
	return updated
}

func (*pairRequestPluginHooks) TranslateRequest(context.Context, sdktranslator.Format, sdktranslator.Format, string, []byte, bool) ([]byte, bool) {
	return nil, false
}

func (*pairRequestPluginHooks) NormalizeResponseBefore(context.Context, sdktranslator.Format, sdktranslator.Format, string, []byte, []byte, []byte, bool) []byte {
	return nil
}

func (*pairRequestPluginHooks) TranslateResponse(context.Context, sdktranslator.Format, sdktranslator.Format, string, []byte, []byte, []byte, bool) ([]byte, bool) {
	return nil, false
}

func (*pairRequestPluginHooks) NormalizeResponseAfter(context.Context, sdktranslator.Format, sdktranslator.Format, string, []byte, []byte, []byte, bool) []byte {
	return nil
}

func geminiToolHistoryPayload(turns int) []byte {
	contents := []string{`{"role":"user","parts":[{"text":"start"}]}`}
	for i := 0; i < turns; i++ {
		contents = append(contents,
			fmt.Sprintf(`{"role":"user","parts":[{"text":"ask %d"}]}`, i),
			fmt.Sprintf(`{"role":"model","parts":[{"text":"think %d"},{"thoughtSignature":"sig-%d","functionCall":{"id":"c%d","name":"read_file","args":{"path":"a%d.go"}}}]}`, i, i, i, i),
			fmt.Sprintf(`{"role":"user","parts":[{"functionResponse":{"id":"c%d","name":"read_file","response":{"content":"data %d"}}}]}`, i, i),
			fmt.Sprintf(`{"role":"model","parts":[{"text":"answer %d"}]}`, i))
	}
	return []byte(fmt.Sprintf(
		`{"contents":[%s],"tools":[{"functionDeclarations":[{"name":"read_file","description":"read a file","parameters":{"type":"object","properties":{"path":{"type":"string"}},"required":["path"]}}]}],"generationConfig":{"temperature":1}}`,
		strings.Join(contents, ",")))
}

// TestTranslateRequestPairMatchesSeparateTranslations pins the reuse fast path to
// the behavior of translating both payloads independently.
func TestTranslateRequestPairMatchesSeparateTranslations(t *testing.T) {
	from := sdktranslator.FormatGemini
	to := sdktranslator.FromString("antigravity")
	cfg := &config.Config{}
	const model = "gemini-3.6-flash-high"

	for _, turns := range []int{0, 1, 5, 20} {
		payload := geminiToolHistoryPayload(turns)
		// Same bytes in a different backing array forces the translate-twice branch.
		detached := append([]byte(nil), payload...)

		want := TranslateRequestWithCodexMultiAgentV2(context.Background(), http.Header{}, cfg, from, to, model, payload, true)

		reuseBase, reuseWork := TranslateRequestPairWithCodexMultiAgentV2(
			context.Background(), http.Header{}, cfg, from, to, model, payload, payload, true)
		twiceBase, twiceWork := TranslateRequestPairWithCodexMultiAgentV2(
			context.Background(), http.Header{}, cfg, from, to, model, payload, detached, true)

		for name, got := range map[string][]byte{
			"reuse baseline": reuseBase,
			"reuse working":  reuseWork,
			"twice baseline": twiceBase,
			"twice working":  twiceWork,
		} {
			if !bytes.Equal(want, got) {
				t.Fatalf("turns=%d: %s translation differs from a standalone translation", turns, name)
			}
		}

		if len(reuseBase) > 0 && &reuseBase[0] == &reuseWork[0] {
			t.Fatalf("turns=%d: working copy aliases the baseline; later in-place edits would corrupt it", turns)
		}

		// The caller mutates the working copy, so the baseline must stay intact.
		baselineBefore := append([]byte(nil), reuseBase...)
		reuseWork[0] = 'X'
		if !bytes.Equal(baselineBefore, reuseBase) {
			t.Fatalf("turns=%d: mutating the working copy changed the baseline", turns)
		}
	}
}

// TestTranslateRequestPairTranslatesDistinctPayloads guards the case where the
// executor really does hand over two different requests.
func TestTranslateRequestPairTranslatesDistinctPayloads(t *testing.T) {
	from := sdktranslator.FormatGemini
	to := sdktranslator.FromString("antigravity")
	cfg := &config.Config{}
	const model = "gemini-3.6-flash-high"

	original := geminiToolHistoryPayload(2)
	request := geminiToolHistoryPayload(4)

	base, work := TranslateRequestPairWithCodexMultiAgentV2(
		context.Background(), http.Header{}, cfg, from, to, model, original, request, true)

	wantBase := TranslateRequestWithCodexMultiAgentV2(context.Background(), http.Header{}, cfg, from, to, model, original, true)
	wantWork := TranslateRequestWithCodexMultiAgentV2(context.Background(), http.Header{}, cfg, from, to, model, request, true)

	if !bytes.Equal(wantBase, base) {
		t.Fatal("baseline translation differs for distinct payloads")
	}
	if !bytes.Equal(wantWork, work) {
		t.Fatal("working translation differs for distinct payloads")
	}
	if bytes.Equal(base, work) {
		t.Fatal("distinct payloads produced identical translations; the reuse path was taken by mistake")
	}
}

func TestTranslateRequestPairPreservesPluginHookInvocations(t *testing.T) {
	hooks := &pairRequestPluginHooks{}
	sdktranslator.SetPluginHooks(hooks)
	t.Cleanup(func() { sdktranslator.SetPluginHooks(nil) })

	payload := geminiToolHistoryPayload(1)
	base, work := TranslateRequestPairWithCodexMultiAgentV2(
		context.Background(),
		http.Header{},
		&config.Config{},
		sdktranslator.FormatGemini,
		sdktranslator.FromString("antigravity"),
		"gemini-3.6-flash-high",
		payload,
		payload,
		true,
	)

	if hooks.calls != 2 {
		t.Fatalf("plugin hook calls = %d, want 2", hooks.calls)
	}
	if got := gjson.GetBytes(base, "plugin_call").Int(); got != 1 {
		t.Fatalf("baseline plugin_call = %d, want 1", got)
	}
	if got := gjson.GetBytes(work, "plugin_call").Int(); got != 2 {
		t.Fatalf("working plugin_call = %d, want 2", got)
	}
}

func TestSameByteSlice(t *testing.T) {
	buf := []byte("payload")
	cases := []struct {
		name string
		a, b []byte
		want bool
	}{
		{"identical slice", buf, buf, true},
		{"same array same length", buf[:3], buf[:3], true},
		{"equal bytes different array", buf, append([]byte(nil), buf...), false},
		{"different length", buf, buf[:3], false},
		{"both nil", nil, nil, true},
		{"nil and empty", nil, []byte{}, true},
		{"nil and non-empty", nil, buf, false},
		{"offset alias", buf, buf[1:], false},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			if got := sameByteSlice(tc.a, tc.b); got != tc.want {
				t.Fatalf("sameByteSlice() = %v, want %v", got, tc.want)
			}
		})
	}
}