package helpers

import (
	"context"
	"fmt"
	"io"
	"os"
	"strings"
	"testing"
	"time"

	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/pkg/edition"
)

type aitableCommandCoverageCaller struct {
	viewType string
	err      error
	response map[string]string
}

func (c *aitableCommandCoverageCaller) CallTool(_ context.Context, _, tool string, _ map[string]any) (*edition.ToolResult, error) {
	if c.err != nil {
		return nil, c.err
	}
	if response, ok := c.response[tool]; ok {
		return textToolResult(response), nil
	}
	viewType := c.viewType
	if viewType == "" {
		viewType = "Grid"
	}
	var response string
	switch tool {
	case "get_views":
		response = fmt.Sprintf(`{"data":{"views":[{"viewId":"view","viewType":%q,"kanbanCard":{},"galleryCard":{},"ganttTimebar":{},"aggregate":{},"filter":[],"sort":[],"group":[],"visibleFieldIds":[],"custom":{"widthMap":{}}}]}}`, viewType)
	case "list_form_views":
		response = `{"data":[{"viewId":"view","title":"Form"}]}`
	case "query_records":
		response = `{"data":{"records":[],"hasMore":false,"nextCursor":""}}`
	default:
		response = `{"success":true,"data":{}}`
	}
	return textToolResult(response), nil
}

func (*aitableCommandCoverageCaller) Format() string { return "json" }
func (*aitableCommandCoverageCaller) DryRun() bool   { return false }
func (*aitableCommandCoverageCaller) Fields() string { return "" }
func (*aitableCommandCoverageCaller) JQ() string     { return "" }

func runAitableCoverageCommand(t *testing.T, caller edition.ToolCaller, args ...string) error {
	t.Helper()
	InitDeps(caller)
	deps.Out.w = io.Discard
	deps.Out.errW = io.Discard
	root := newAitableCommand()
	installExampleGlobalFlags(root)
	root.SilenceErrors = true
	root.SilenceUsage = true
	root.SetOut(io.Discard)
	root.SetErr(io.Discard)
	root.SetArgs(args)
	return root.ExecuteContext(context.Background())
}

func TestCrossPlatformCoverageAitableRetryWrappersExhaustAndRecover(t *testing.T) {
	oldDeps, oldSleep := deps, helperSleep
	t.Cleanup(func() { deps, helperSleep = oldDeps, oldSleep })
	helperSleep = func(time.Duration) {}

	retryable := fmt.Errorf("timeout: retryable: true")
	caller := &aitableTestCaller{errors: []error{retryable, retryable, retryable, retryable}}
	installAitableDeps(t, caller)
	if err := callAitableTool("retry", nil); err == nil {
		t.Fatal("exhausted aitable retries returned nil")
	}

	caller = &aitableTestCaller{errors: []error{retryable, retryable}}
	installAitableDeps(t, caller)
	if err := callAitableHelperTool("retry", nil); err != nil {
		t.Fatalf("helper retry did not recover: %v", err)
	}

	caller = &aitableTestCaller{errors: []error{retryable, retryable, retryable, retryable}}
	installAitableDeps(t, caller)
	if err := callAitableHelperTool("retry", nil); err == nil {
		t.Fatal("exhausted helper retries returned nil")
	}
}

func TestCrossPlatformCoverageAitableCommandValidationEdges(t *testing.T) {
	oldDeps, oldArgs, oldStdin, oldSleep := deps, os.Args, os.Stdin, helperSleep
	t.Cleanup(func() {
		deps, os.Args, os.Stdin, helperSleep = oldDeps, oldArgs, oldStdin, oldSleep
	})
	helperSleep = func(time.Duration) {}
	os.Args = []string{"dws", "aitable", "--yes"}
	caller := &aitableCommandCoverageCaller{}

	manyIDs := make([]string, 101)
	for i := range manyIDs {
		manyIDs[i] = fmt.Sprintf("r%d", i)
	}
	manyRecords := "[" + strings.TrimSuffix(strings.Repeat(`{"cells":{}},`, 101), ",") + "]"

	scenarios := []struct {
		name string
		args []string
	}{
		{"primary doc missing base", []string{"base", "get-primary-doc-id", "--table-id=t", "--record-id=r"}},
		{"table create invalid fields", []string{"table", "create", "--base-id=b", "--name=n", "--fields={"}},
		{"table create missing base", []string{"table", "create", "--name=n", `--fields=[{"fieldName":"N","type":"text"}]`}},
		{"field create invalid fields", []string{"field", "create", "--base-id=b", "--table-id=t", "--fields={"}},
		{"field create invalid configured options", []string{"field", "create", "--base-id=b", "--table-id=t", "--name=n", "--type=singleSelect", "--config={}", "--options={"}},
		{"field create configured options", []string{"field", "create", "--base-id=b", "--table-id=t", "--name=n", "--type=singleSelect", "--config={}", `--options=[{"name":"A"}]`}},
		{"field create scalar config", []string{"field", "create", "--base-id=b", "--table-id=t", "--name=n", "--type=text", "--config=[]"}},
		{"field create invalid options", []string{"field", "create", "--base-id=b", "--table-id=t", "--name=n", "--type=singleSelect", "--options={"}},
		{"field create options and ai", []string{"field", "create", "--base-id=b", "--table-id=t", "--name=n", "--type=singleSelect", `--options=[{"name":"A"}]`, `--ai-config={"enabled":true}`}},
		{"field update no changes", []string{"field", "update", "--base-id=b", "--table-id=t", "--field-id=f"}},
		{"query explicitly empty table", []string{"record", "query", "--base-id=b", "--table-id="}},
		{"query rich options", []string{"record", "query", "--base-id=b", "--table-id=t", "--view-id=v", "--record-ids=r1,r2", "--field-ids=f1,f2", `--filters={"operator":"and","operands":[{"operator":"eq","operands":["f","v"]}]}`, `--sort=[{"fieldId":"f","order":"desc"},{"fieldId":"g","order":"asc","direction":"desc"}]`, "--keyword=k", "--page-size=2", "--cursor=c"}},
		{"query primary options", []string{"record", "query", "--base-id=b", "--table-id=t", "--query=k", "--limit=2"}},
		{"query invalid sort", []string{"record", "query", "--base-id=b", "--table-id=t", "--sort={"}},
		{"query all default page limit", []string{"record", "query", "--base-id=b", "--table-id=t", "--all"}},
		{"query all unlimited", []string{"record", "query", "--base-id=b", "--table-id=t", "--all", "--page-limit=0"}},
		{"create invalid cells", []string{"record", "create", "--base-id=b", "--table-id=t", "--cells={"}},
		{"create cells shortcut", []string{"record", "create", "--base-id=b", "--table-id=t", `--cells={"f":"v"}`}},
		{"create invalid records", []string{"record", "create", "--base-id=b", "--table-id=t", "--records={"}},
		{"update half shortcut", []string{"record", "update", "--base-id=b", "--table-id=t", "--record-id=r"}},
		{"update invalid shortcut cells", []string{"record", "update", "--base-id=b", "--table-id=t", "--record-id=r", "--cells={"}},
		{"update shortcut missing base", []string{"record", "update", "--table-id=t", "--record-id=r", `--cells={"f":"v"}`}},
		{"update invalid records", []string{"record", "update", "--base-id=b", "--table-id=t", "--records={"}},
		{"update records", []string{"record", "update", "--base-id=b", "--table-id=t", `--records=[{"recordId":"r","cells":{}}]`}},
		{"batch empty ids", []string{"record", "batch-update", "--base-id=b", "--table-id=t", "--record-ids=,", `--cells={"f":"v"}`}},
		{"batch too many ids", []string{"record", "batch-update", "--base-id=b", "--table-id=t", "--record-ids=" + strings.Join(manyIDs, ","), `--cells={"f":"v"}`}},
		{"batch invalid cells", []string{"record", "batch-update", "--base-id=b", "--table-id=t", "--record-ids=r", "--cells={"}},
		{"batch empty cells", []string{"record", "batch-update", "--base-id=b", "--table-id=t", "--record-ids=r", "--cells={}"}},
		{"batch missing base", []string{"record", "batch-update", "--table-id=t", "--record-ids=r", `--cells={"f":"v"}`}},
		{"query empty invalid limit", []string{"record", "query-empty", "--base-id=b", "--table-id=t", "--limit=0"}},
		{"history invalid offset", []string{"record", "history-list", "--base-id=b", "--table-id=t", "--record-id=r", "--offset=-1"}},
		{"history invalid limit", []string{"record", "history-list", "--base-id=b", "--table-id=t", "--record-id=r", "--limit=0"}},
		{"share empty ids", []string{"record", "share-url", "--base-id=b", "--table-id=t", "--record-ids=,"}},
		{"share too many ids", []string{"record", "share-url", "--base-id=b", "--table-id=t", "--record-ids=" + strings.Join(manyIDs[:21], ",")}},
		{"upsert invalid records", []string{"record", "upsert", "--base-id=b", "--table-id=t", "--records={"}},
		{"upsert empty records", []string{"record", "upsert", "--base-id=b", "--table-id=t", "--records=[]"}},
		{"upsert too many records", []string{"record", "upsert", "--base-id=b", "--table-id=t", "--records=" + manyRecords}},
		{"primary doc create missing base", []string{"record", "primary-doc-create", "--table-id=t", "--field-id=f", "--record-id=r"}},
		{"attachment all options", []string{"attachment", "upload", "--base-id=b", "--file-name=x", "--size=1", "--mime-type=text/plain"}},
		{"form update no changes", []string{"form", "update", "--base-id=b", "--table-id=t", "--view-id=v"}},
		{"form field update missing base", []string{"form", "field", "update", "--table-id=t", "--view-id=v", "--field-id=f"}},
		{"form field hide missing base", []string{"form", "field", "hide", "--table-id=t", "--view-id=v", "--field-id=f", "--hidden=true"}},
		{"form share update missing base", []string{"form", "share", "update", "--table-id=t", "--view-id=v", "--enabled=true"}},
		{"dashboard create empty", []string{"dashboard", "create", "--base-id=b"}},
		{"dashboard create invalid config scalar", []string{"dashboard", "create", "--base-id=b", "--config=[]"}},
		{"dashboard create config", []string{"dashboard", "create", "--base-id=b", `--config={"name":"n"}`}},
		{"dashboard update config", []string{"dashboard", "update", "--base-id=b", "--dashboard-id=d", `--config={"name":"n"}`}},
		{"dashboard share invalid bool", []string{"dashboard", "share", "update", "--base-id=b", "--dashboard-id=d", "--enabled=invalid"}},
		{"dashboard share missing base", []string{"dashboard", "share", "update", "--dashboard-id=d", "--enabled=true"}},
		{"dashboard share all options", []string{"dashboard", "share", "update", "--base-id=b", "--dashboard-id=d", "--enabled=true", "--share-type=PUBLIC", "--allow-back-to-doc"}},
		{"chart create missing base", []string{"chart", "create", "--dashboard-id=d", `--config={"name":"n"}`, `--layout={"x":0}`}},
		{"chart update missing base", []string{"chart", "update", "--dashboard-id=d", "--chart-id=c", `--config={"name":"n"}`}},
		{"chart share invalid bool", []string{"chart", "share", "update", "--base-id=b", "--dashboard-id=d", "--chart-id=c", "--enabled=invalid"}},
		{"chart share missing base", []string{"chart", "share", "update", "--dashboard-id=d", "--chart-id=c", "--enabled=true"}},
		{"chart share all options", []string{"chart", "share", "update", "--base-id=b", "--dashboard-id=d", "--chart-id=c", "--enabled=true", "--share-type=ORG", "--allow-back-to-doc"}},
		{"workflow invalid limit", []string{"workflow", "list", "--base-id=b", "--limit=0"}},
		{"workflow invalid offset", []string{"workflow", "list", "--base-id=b", "--offset=-1"}},
		{"export create task", []string{"export", "data", "--base-id=b", "--scope=all", "--format=excel", "--table-id=t", "--view-id=v", "--timeout-ms=1"}},
		{"role create invalid json", []string{"advperm", "role-create", "--base-id=b", "--name=n", "--sub-roles={"}},
		{"role create non-array", []string{"advperm", "role-create", "--base-id=b", "--name=n", "--sub-roles={}"}},
		{"role create array", []string{"advperm", "role-create", "--base-id=b", "--name=n", "--sub-roles=[]"}},
		{"role update invalid json", []string{"advperm", "role-update", "--base-id=b", "--role-id=r", "--sub-roles={"}},
		{"role update non-array", []string{"advperm", "role-update", "--base-id=b", "--role-id=r", "--sub-roles={}"}},
		{"role update array", []string{"advperm", "role-update", "--base-id=b", "--role-id=r", "--sub-roles=[]"}},
		{"import rich options", []string{"import", "data", "--import-id=i", "--table-id=t", "--timeout=1", "--header-row=2", "--src-sheet-name=Sheet1", `--field-mapping={"A":"f"}`}},
		{"import invalid mapping", []string{"import", "data", "--import-id=i", "--field-mapping={"}},
	}
	for _, scenario := range scenarios {
		t.Run(scenario.name, func(t *testing.T) {
			if err := runAitableCoverageCommand(t, caller, scenario.args...); err != nil {
				t.Logf("command returned: %v", err)
			}
		})
	}

	formGet := []string{"form", "get", "--base-id=b", "--table-id=t", "--view-id=view"}
	_ = runAitableCoverageCommand(t, &aitableCommandCoverageCaller{err: fmt.Errorf("transport")}, formGet...)
	_ = runAitableCoverageCommand(t, &aitableCommandCoverageCaller{response: map[string]string{"list_form_views": "{"}}, formGet...)
	_ = runAitableCoverageCommand(t, &aitableCommandCoverageCaller{response: map[string]string{"list_form_views": `{}`}}, formGet...)
	_ = runAitableCoverageCommand(t, caller, formGet...)
}

func TestCrossPlatformCoverageAitableViewCommandEdges(t *testing.T) {
	oldDeps, oldArgs, oldSleep := deps, os.Args, helperSleep
	t.Cleanup(func() { deps, os.Args, helperSleep = oldDeps, oldArgs, oldSleep })
	helperSleep = func(time.Duration) {}
	os.Args = []string{"dws", "aitable", "--yes"}

	type scenario struct {
		name     string
		viewType string
		args     []string
	}
	base := []string{"--base-id=b", "--table-id=t", "--view-id=view"}
	with := func(prefix []string, flags ...string) []string {
		out := append([]string(nil), prefix...)
		out = append(out, base...)
		return append(out, flags...)
	}
	scenarios := []scenario{
		{"get card unsupported", "Grid", with([]string{"view", "get", "card"})},
		{"get card", "Kanban", with([]string{"view", "get", "card"})},
		{"get timebar wrong type", "Grid", with([]string{"view", "get", "timebar"})},
		{"get timebar", "Gantt", with([]string{"view", "get", "timebar"})},
		{"get filter", "Grid", with([]string{"view", "get", "filter"})},
		{"update invalid config", "Grid", with([]string{"view", "update"}, `--config={"filter":1}`)},
		{"update normalized config", "Grid", with([]string{"view", "update"}, `--config={"filter":{"operator":"and","operands":[]}}`)},
		{"card conflict", "Kanban", with([]string{"view", "update", "card"}, "--no-cover", "--cover-field-id=f")},
		{"card unsupported", "Grid", with([]string{"view", "update", "card"}, "--no-cover")},
		{"card no cover", "Kanban", with([]string{"view", "update", "card"}, "--no-cover", "--hidden-field-title", "--display-field-name")},
		{"card cover", "Gallery", with([]string{"view", "update", "card"}, "--cover-field-id=f", "--cover-mode=auto")},
		{"card invalid json", "Kanban", with([]string{"view", "update", "card"}, "--json=[]")},
		{"timebar wrong type", "Grid", with([]string{"view", "update", "timebar"}, "--start-field=f")},
		{"timebar invalid colors", "Gantt", with([]string{"view", "update", "timebar"}, "--color-configs={}")},
		{"timebar colors", "Gantt", with([]string{"view", "update", "timebar"}, "--color-configs=[]", "--official-holiday")},
		{"timebar invalid json", "Gantt", with([]string{"view", "update", "timebar"}, "--json=[]")},
		{"aggregate half pair", "Grid", with([]string{"view", "update", "aggregate"}, "--field-id=f")},
		{"aggregate typed clear", "Grid", with([]string{"view", "update", "aggregate"}, "--field-id=f", "--action=SUM", "--clear-field-id=x,y")},
		{"aggregate invalid json", "Grid", with([]string{"view", "update", "aggregate"}, "--json=[]")},
		{"width half pair", "Grid", with([]string{"view", "update", "field-widths"}, "--field-id=f")},
		{"width typed", "Grid", with([]string{"view", "update", "field-widths"}, "--field-id=f", "--width=120")},
		{"width invalid json", "Grid", with([]string{"view", "update", "field-widths"}, "--json=[]")},
		{"visible non-array", "Grid", with([]string{"view", "update", "visible-fields"}, "--json={}")},
		{"visible mixed array", "Grid", with([]string{"view", "update", "visible-fields"}, `--json=["f",1]`)},
		{"visible empty", "Grid", with([]string{"view", "update", "visible-fields"})},
		{"visible both", "Grid", with([]string{"view", "update", "visible-fields"}, "--field-ids=x", `--json=["f","g"]`)},
		{"filter missing json", "Grid", with([]string{"view", "update", "filter"})},
		{"filter invalid json", "Grid", with([]string{"view", "update", "filter"}, "--json={")},
		{"filter invalid shape", "Grid", with([]string{"view", "update", "filter"}, "--json=1")},
		{"filter valid object", "Grid", with([]string{"view", "update", "filter"}, `--json={"operator":"and","operands":[]}`)},
		{"sort valid", "Grid", with([]string{"view", "update", "sort"}, `--json=[{"fieldId":"f","direction":"asc"}]`)},
		{"group valid", "Grid", with([]string{"view", "update", "group"}, `--json=[{"fieldId":"f","direction":"asc"}]`)},
		{"name missing base", "Grid", []string{"view", "update", "name", "--table-id=t", "--view-id=view", "--name=n"}},
		{"frozen negative", "Grid", with([]string{"view", "update", "frozen-cols"}, "--count=-1")},
		{"frozen missing base", "Grid", []string{"view", "update", "frozen-cols", "--table-id=t", "--view-id=view", "--count=1"}},
		{"row height invalid", "Grid", with([]string{"view", "update", "row-height"}, "--cell-height=0")},
		{"row height missing base", "Grid", []string{"view", "update", "row-height", "--table-id=t", "--view-id=view", "--cell-height=32"}},
		{"fill missing json", "Grid", with([]string{"view", "update", "fill-color-rule"})},
		{"fill invalid json", "Grid", with([]string{"view", "update", "fill-color-rule"}, "--json={")},
		{"fill non-array", "Grid", with([]string{"view", "update", "fill-color-rule"}, "--json={}")},
		{"fill valid", "Grid", with([]string{"view", "update", "fill-color-rule"}, "--json=[]")},
		{"fill missing base", "Grid", []string{"view", "update", "fill-color-rule", "--table-id=t", "--view-id=view", "--json=[]"}},
	}
	for _, item := range scenarios {
		t.Run(item.name, func(t *testing.T) {
			if err := runAitableCoverageCommand(t, &aitableCommandCoverageCaller{viewType: item.viewType}, item.args...); err != nil {
				t.Logf("command returned: %v", err)
			}
		})
	}

	// Exercise the shared view preflight's base-ID and transport-error exits.
	_ = runAitableCoverageCommand(t, &aitableCommandCoverageCaller{}, "view", "update", "visible-fields", "--table-id=t", "--view-id=view", "--field-ids=f")
	_ = runAitableCoverageCommand(t, &aitableCommandCoverageCaller{err: fmt.Errorf("transport")}, with([]string{"view", "update", "card"}, "--no-cover")...)
}

func TestCrossPlatformCoverageAitableDeleteCancellationEdges(t *testing.T) {
	oldDeps, oldArgs, oldStdin := deps, os.Args, os.Stdin
	t.Cleanup(func() { deps, os.Args, os.Stdin = oldDeps, oldArgs, oldStdin })
	os.Args = []string{"dws", "aitable"}
	input, err := os.CreateTemp(t.TempDir(), "answers")
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = input.Close() })
	if _, err := input.WriteString(strings.Repeat("no\n", 20)); err != nil {
		t.Fatal(err)
	}
	if _, err := input.Seek(0, 0); err != nil {
		t.Fatal(err)
	}
	os.Stdin = input

	commands := [][]string{
		{"base", "delete", "--base-id=b"},
		{"table", "delete", "--base-id=b", "--table-id=t"},
		{"field", "delete", "--base-id=b", "--table-id=t", "--field-id=f"},
		{"record", "delete", "--base-id=b", "--table-id=t", "--record-ids=r"},
		{"view", "delete", "--base-id=b", "--table-id=t", "--view-id=v"},
		{"form", "delete", "--base-id=b", "--table-id=t", "--view-id=v"},
		{"workflow", "disable", "--base-id=b", "--workflow-id=w"},
		{"dashboard", "delete", "--base-id=b", "--dashboard-id=d"},
		{"chart", "delete", "--base-id=b", "--dashboard-id=d", "--chart-id=c"},
		{"advperm", "disable", "--base-id=b"},
		{"advperm", "role-delete", "--base-id=b", "--role-id=r"},
	}
	for _, args := range commands {
		_ = runAitableCoverageCommand(t, &aitableCommandCoverageCaller{}, args...)
	}
}