package sfcrmappservice

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"sort"
	"strings"
	"sync/atomic"
	"testing"
	"time"

	catalogsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/catalog/consumerv1"
	commonsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/commonv1"
	permissionsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/effectivepermissionsv1"
	querysemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/queryv1"
	reportsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/reportv1"
)

func TestAnalyticsDescribeUsesOneRevisionBoundRuntimeRead(t *testing.T) {
	var reportCalls atomic.Uint64
	permissions := validPermissionResponse(17, 4)
	permissions.SystemPermissions = analyticsTestSystemPermissions()
	config := permissionMetadataServiceConfig(
		func(_ context.Context, _ string, request permissionsemantic.Request) (permissionsemantic.Response, error) {
			if request.TargetPrincipalID != "" || request.MinCatalogRevision != nil ||
				request.Selection == nil ||
				len(request.Selection.Sections) != 1 ||
				request.Selection.Sections[0] != permissionsemantic.SectionSystemPermissions ||
				len(request.Selection.ResourceTypes) != 0 {
				t.Fatalf("effective-permission request = %#v", request)
			}
			return permissions, nil
		},
		func(context.Context, catalogsemantic.GetRequest) (catalogsemantic.AppMetadataView, error) {
			return catalogsemantic.AppMetadataView{}, nil
		},
	)
	config.RuntimeReadReport = func(ctx context.Context, bearer string, request reportsemantic.Request) (reportsemantic.Response, error) {
		reportCalls.Add(1)
		if bearer != "user-secret" || request.ReportID != "report-1" || request.Limit != 1 ||
			request.MinCatalogRevision == nil || *request.MinCatalogRevision != 17 {
			t.Fatalf("Runtime report request bearer=%q request=%#v", bearer, request)
		}
		if _, ok := ctx.Deadline(); !ok {
			t.Fatal("Runtime report request has no deadline")
		}
		return reportsemantic.Response{
			CanonicalResult: analyticsCanonicalReportPayload(t),
			Receipts:        analyticsReportReceipts(),
		}, nil
	}
	installAnalyticsTestMetadata(t, &config)
	service, err := NewService(config)
	if err != nil {
		t.Fatal(err)
	}
	request := httptest.NewRequest(http.MethodGet, "/services/data/v63.0/analytics/reports/report-1/describe", nil)
	request.Header.Set("Authorization", "Bearer user-secret")
	recorder := httptest.NewRecorder()
	service.ServeHTTP(recorder, request)
	if recorder.Code != http.StatusOK || reportCalls.Load() != 1 {
		t.Fatalf("status=%d calls=%d body=%s", recorder.Code, reportCalls.Load(), recorder.Body.String())
	}
	var response struct {
		ReportMetadata map[string]any `json:"reportMetadata"`
	}
	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
		t.Fatal(err)
	}
	reportType, ok := response.ReportMetadata["reportType"].(map[string]any)
	if !ok || reportType["type"] != "OpportunityList" || reportType["label"] != "Opportunity" || response.ReportMetadata["sourceObject"] != "Opportunity" {
		t.Fatalf("reportMetadata = %#v", response.ReportMetadata)
	}
}

func TestAnalyticsSavedReportGetAndPostUseSameRuntimeRead(t *testing.T) {
	permissions := validPermissionResponse(17, 4)
	permissions.SystemPermissions = analyticsTestSystemPermissions()
	var reportCalls atomic.Uint64
	config := permissionMetadataServiceConfig(
		func(context.Context, string, permissionsemantic.Request) (permissionsemantic.Response, error) {
			return permissions, nil
		},
		func(context.Context, catalogsemantic.GetRequest) (catalogsemantic.AppMetadataView, error) {
			return catalogsemantic.AppMetadataView{}, nil
		},
	)
	config.RuntimeReadReport = func(_ context.Context, bearer string, request reportsemantic.Request) (reportsemantic.Response, error) {
		reportCalls.Add(1)
		if bearer != "user-secret" || request.ReportID != "report-1" || request.Limit != reportsemantic.MaxRows ||
			request.MinCatalogRevision == nil || *request.MinCatalogRevision != 17 {
			t.Fatalf("Runtime report bearer=%q request=%#v", bearer, request)
		}
		return reportsemantic.Response{CanonicalResult: analyticsCanonicalReportPayload(t), Receipts: analyticsReportReceipts()}, nil
	}
	installAnalyticsTestMetadata(t, &config)
	service, err := NewService(config)
	if err != nil {
		t.Fatal(err)
	}
	for _, method := range []string{http.MethodGet, http.MethodPost} {
		request := httptest.NewRequest(method, "/services/data/v63.0/analytics/reports/report-1", nil)
		request.Header.Set("Authorization", "Bearer user-secret")
		recorder := httptest.NewRecorder()
		service.ServeHTTP(recorder, request)
		if recorder.Code != http.StatusOK {
			t.Fatalf("%s saved report status=%d body=%s", method, recorder.Code, recorder.Body.String())
		}
	}
	if reportCalls.Load() != 2 {
		t.Fatalf("saved report Runtime calls = %d", reportCalls.Load())
	}
}

func TestAnalyticsRejectsUnsavedAndMutationSurfacesLocally(t *testing.T) {
	var reportCalls atomic.Uint64
	permissions := validPermissionResponse(17, 4)
	permissions.SystemPermissions = analyticsTestSystemPermissions()
	config := permissionMetadataServiceConfig(
		func(context.Context, string, permissionsemantic.Request) (permissionsemantic.Response, error) {
			return permissions, nil
		},
		func(context.Context, catalogsemantic.GetRequest) (catalogsemantic.AppMetadataView, error) {
			return catalogsemantic.AppMetadataView{}, nil
		},
	)
	config.RuntimeReadReport = func(context.Context, string, reportsemantic.Request) (reportsemantic.Response, error) {
		reportCalls.Add(1)
		return reportsemantic.Response{}, nil
	}
	installAnalyticsTestMetadata(t, &config)
	service, err := NewService(config)
	if err != nil {
		t.Fatal(err)
	}
	for _, test := range []struct {
		method string
		path   string
		body   string
		status int
	}{
		{http.MethodPost, "/services/data/v63.0/analytics/report-execution", `{"reportId":"report-1","reportMetadata":{"detailColumns":["Id"]}}`, http.StatusBadRequest},
		{http.MethodPost, "/services/data/v63.0/analytics/report-execution", `{"reportId":"report-1","unexpected":true}`, http.StatusBadRequest},
		{http.MethodGet, "/services/data/v63.0/analytics/reports/report-1", `{}`, http.StatusBadRequest},
		{http.MethodPost, "/services/data/v63.0/analytics/reports/report-1", `{}`, http.StatusBadRequest},
		{http.MethodPost, "/services/data/v63.0/analytics/reports/report-1", `{"reportMetadata":{"detailColumns":["Id"]}}`, http.StatusBadRequest},
		{http.MethodPut, "/services/data/v63.0/analytics/dashboards/dashboard-1", `{}`, http.StatusBadRequest},
		{http.MethodPost, "/services/data/v63.0/analytics/dashboards/dashboard-1/refresh", `{}`, http.StatusBadRequest},
		{http.MethodGet, "/services/data/v63.0/analytics/dashboards/dashboard-1/status?runningUser=viewer&startDate=2026-01-01", "", http.StatusBadRequest},
		{http.MethodGet, "/services/data/v63.0/analytics/dashboards/dashboard-1/status?runningUser=viewer&runningUser=viewer", "", http.StatusBadRequest},
		{http.MethodGet, "/services/data/v63.0/analytics/dashboards/dashboard-1?startDate=2026-01-01", "", http.StatusBadRequest},
		{http.MethodGet, "/services/data/v63.0/analytics/dashboards/dashboard-1?endDate=", "", http.StatusBadRequest},
		{http.MethodPut, "/services/data/v63.0/analytics/dashboards/dashboard-1?startDate=2026-01-01", "", http.StatusBadRequest},
		{http.MethodPut, "/services/data/v63.0/analytics/dashboards/dashboard-1?startDate=&startDate=", "", http.StatusBadRequest},
	} {
		request := httptest.NewRequest(test.method, test.path, strings.NewReader(test.body))
		request.Header.Set("Authorization", "Bearer user-secret")
		recorder := httptest.NewRecorder()
		service.ServeHTTP(recorder, request)
		if recorder.Code != test.status {
			t.Fatalf("%s %s status=%d body=%s", test.method, test.path, recorder.Code, recorder.Body.String())
		}
	}
	if reportCalls.Load() != 0 {
		t.Fatalf("unsupported analytics surfaces made %d Runtime calls", reportCalls.Load())
	}
}

func analyticsTestSystemPermissions() []permissionsemantic.PermissionGrant {
	return []permissionsemantic.PermissionGrant{
		{PermissionID: "ModifyAllData", Granted: false},
		{PermissionID: analyticsPermissionRunReports, Granted: true},
		{PermissionID: "ViewSetup", Granted: true},
	}
}

func analyticsTestObjectSpecs() map[string]searchObjectSpec {
	objects := []searchObjectSpec{
		{
			APIName: "Opportunity", Label: "Opportunity",
			Fields: []searchFieldSpec{
				{APIName: "Id", Label: "Opportunity ID", Type: "string"},
				{APIName: "Name", Label: "Opportunity Name", Type: "string"},
				{APIName: "Amount", Label: "Amount", Type: "currency"},
				{APIName: "OwnerId", Label: "Owner", Type: "reference"},
				{APIName: "StageName", Label: "Stage", Type: "picklist"},
				{APIName: "CloseDate", Label: "Close Date", Type: "date"},
			},
		},
		{
			APIName: "Issue", Label: "Issue",
			Fields: []searchFieldSpec{
				{APIName: "Status", Label: "Status", Type: "picklist"},
				{APIName: "Points", Label: "Points", Type: "double"},
			},
		},
	}
	result := make(map[string]searchObjectSpec, len(objects))
	for _, object := range objects {
		result[strings.ToLower(object.APIName)] = object
	}
	return result
}

func installAnalyticsTestMetadata(t *testing.T, config *ServiceConfig) {
	t.Helper()
	objects := make([]searchObjectSpec, 0, len(analyticsTestObjectSpecs()))
	for _, object := range analyticsTestObjectSpecs() {
		objects = append(objects, object)
	}
	sort.Slice(objects, func(left, right int) bool {
		return objects[left].APIName < objects[right].APIName
	})
	view := searchTestView(t, objects)
	view.Receipts.SecurityEpoch = 4
	config.RuntimeGetAppMetadataViewV3 = func(
		_ context.Context,
		request catalogsemantic.GetRequest,
	) (catalogsemantic.AppMetadataViewV3, error) {
		if request.MinCatalogRevision == nil || *request.MinCatalogRevision != 17 {
			t.Fatalf("analytics AppMetadata request = %#v", request)
		}
		return view, nil
	}
}

func mustProjectCanonicalReport(
	t *testing.T,
	document canonicalReportDocument,
) map[string]any {
	t.Helper()
	result, err := projectCanonicalReport(document, analyticsTestObjectSpecs())
	if err != nil {
		t.Fatal(err)
	}
	return result
}

func mustProjectCanonicalReportDefinition(
	t *testing.T,
	document canonicalReportDocument,
) map[string]any {
	t.Helper()
	result, err := projectCanonicalReportDefinition(document, analyticsTestObjectSpecs())
	if err != nil {
		t.Fatal(err)
	}
	return result
}

func TestAnalyticsConstructionHasNoPartialOrLegacyFallback(t *testing.T) {
	config := permissionMetadataServiceConfig(nil, nil)
	config.RuntimeReadReport = func(context.Context, string, reportsemantic.Request) (reportsemantic.Response, error) {
		return reportsemantic.Response{}, nil
	}
	if service, err := NewService(config); err == nil || service != nil {
		t.Fatalf("NewService(partial analytics) = %#v, %v; want fail closed", service, err)
	}
}

func TestDashboardStatusComposesQueryAndReportAtOneAuthority(t *testing.T) {
	permissions := validPermissionResponse(17, 4)
	permissions.SystemPermissions = analyticsTestSystemPermissions()
	var queryCalls, reportCalls atomic.Uint64
	config := permissionMetadataServiceConfig(
		func(context.Context, string, permissionsemantic.Request) (permissionsemantic.Response, error) {
			return permissions, nil
		},
		func(context.Context, catalogsemantic.GetRequest) (catalogsemantic.AppMetadataView, error) {
			return catalogsemantic.AppMetadataView{}, nil
		},
	)
	config.RuntimeQuery = func(_ context.Context, bearer string, request querysemantic.Request) (querysemantic.Response, error) {
		queryCalls.Add(1)
		if bearer != "user-secret" || request.MinCatalogRevision == nil || *request.MinCatalogRevision != 17 {
			t.Fatalf("Runtime query bearer=%q request=%#v", bearer, request)
		}
		switch request.ObjectID {
		case analyticsDashboardObject:
			return analyticsQueryResponse(analyticsQueryRecord(analyticsDashboardObject,
				"Id", "dashboard-id", "Name", "Pipeline", "DeveloperName", "pipeline",
				"Description", "Open pipeline", "LayoutType", "Grid", "DashboardType", "SpecifiedUser",
				"RunningUserId", "viewer",
			)), nil
		case analyticsComponentObject:
			return analyticsQueryResponse(
				analyticsQueryRecord(analyticsComponentObject,
					"Id", "component-1", "DashboardId", "dashboard-id", "ReportId", "report-1",
					"Type", "Bar", "Title", "Pipeline", "Config", `{"showValues":true}`,
				),
				analyticsQueryRecord(analyticsComponentObject,
					"Id", "component-2", "DashboardId", "dashboard-id", "ReportId", "stale-report",
					"Type", "RichText", "Title", "Notes", "Config", `{"text":"Current pipeline"}`,
				),
			), nil
		default:
			t.Fatalf("unexpected Runtime query %#v", request)
			return querysemantic.Response{}, nil
		}
	}
	config.RuntimeReadReport = func(_ context.Context, bearer string, request reportsemantic.Request) (reportsemantic.Response, error) {
		reportCalls.Add(1)
		if bearer != "user-secret" || request.ReportID != "report-1" || request.MinCatalogRevision == nil || *request.MinCatalogRevision != 17 {
			t.Fatalf("Runtime report bearer=%q request=%#v", bearer, request)
		}
		return reportsemantic.Response{CanonicalResult: analyticsCanonicalReportPayload(t), Receipts: analyticsReportReceipts()}, nil
	}
	installAnalyticsTestMetadata(t, &config)
	service, err := NewService(config)
	if err != nil {
		t.Fatal(err)
	}
	request := httptest.NewRequest(http.MethodGet, "/services/data/v63.0/analytics/dashboards/pipeline/status", nil)
	request.Header.Set("Authorization", "Bearer user-secret")
	recorder := httptest.NewRecorder()
	service.ServeHTTP(recorder, request)
	if recorder.Code != http.StatusOK || queryCalls.Load() != 2 || reportCalls.Load() != 1 {
		t.Fatalf("status=%d queryCalls=%d reportCalls=%d body=%s", recorder.Code, queryCalls.Load(), reportCalls.Load(), recorder.Body.String())
	}
	var response struct {
		Status            string `json:"status"`
		DashboardMetadata struct {
			Components []struct {
				Title  string         `json:"title"`
				Config map[string]any `json:"config"`
			} `json:"components"`
		} `json:"dashboardMetadata"`
		ComponentData map[string]map[string]any `json:"componentData"`
	}
	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
		t.Fatal(err)
	}
	if response.Status != "Success" || len(response.ComponentData) != 1 || response.ComponentData["component-1"]["factMap"] == nil {
		t.Fatalf("dashboard status = %#v", response)
	}
	if _, exists := response.ComponentData["component-2"]; exists {
		t.Fatalf("display-only dashboard component was executed: %#v", response.ComponentData)
	}
	if len(response.DashboardMetadata.Components) != 2 || response.DashboardMetadata.Components[0].Title != "Pipeline" ||
		response.DashboardMetadata.Components[0].Config["showValues"] != true {
		t.Fatalf("dashboard component metadata = %#v", response.DashboardMetadata.Components)
	}
	if !analyticsDashboardDisplayOnly("Image") || analyticsDashboardDisplayOnly("Report") {
		t.Fatal("dashboard display-only component classification is incorrect")
	}
}

func TestDashboardPrevalidatesEveryComponentBeforeReportExecution(t *testing.T) {
	var reportCalls atomic.Uint64
	components := []querysemantic.Record{}
	client := RuntimeAnalyticsClient{
		query: func(_ context.Context, _ string, request querysemantic.Request) (querysemantic.Response, error) {
			switch request.ObjectID {
			case analyticsDashboardObject:
				return analyticsQueryResponse(analyticsQueryRecord(analyticsDashboardObject,
					"Id", "dashboard-id", "Name", "Pipeline", "DeveloperName", "pipeline",
				)), nil
			case analyticsComponentObject:
				return analyticsQueryResponse(components...), nil
			default:
				t.Fatalf("unexpected Runtime query %#v", request)
				return querysemantic.Response{}, nil
			}
		},
		readReport: func(context.Context, string, reportsemantic.Request) (reportsemantic.Response, error) {
			reportCalls.Add(1)
			return reportsemantic.Response{}, nil
		},
	}
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	valid := analyticsQueryRecord(analyticsComponentObject,
		"Id", "component-1", "DashboardId", "dashboard-id", "ReportId", "report-1", "Type", "Bar",
	)
	for _, test := range []struct {
		name       string
		components []querysemantic.Record
	}{
		{name: "missing report", components: []querysemantic.Record{valid, analyticsQueryRecord(analyticsComponentObject,
			"Id", "component-2", "DashboardId", "dashboard-id", "ReportId", "", "Type", "Table",
		)}},
		{name: "duplicate id", components: []querysemantic.Record{valid, analyticsQueryRecord(analyticsComponentObject,
			"Id", "component-1", "DashboardId", "dashboard-id", "ReportId", "report-2", "Type", "Table",
		)}},
		{name: "foreign dashboard", components: []querysemantic.Record{valid, analyticsQueryRecord(analyticsComponentObject,
			"Id", "component-2", "DashboardId", "other-dashboard", "ReportId", "report-2", "Type", "Table",
		)}},
	} {
		components = test.components
		if _, err := client.runDashboard(ctx, "user-secret", "pipeline", analyticsReportReceipts(), "", "", ""); !errors.Is(err, errAnalyticsAuthority) {
			t.Fatalf("%s runDashboard error = %v, want authority failure", test.name, err)
		}
	}
	if reportCalls.Load() != 0 {
		t.Fatalf("ReportRead calls = %d, want zero before complete dashboard validation", reportCalls.Load())
	}
}

func TestDashboardFailsClosedOnTruncatedComponentPage(t *testing.T) {
	client := RuntimeAnalyticsClient{
		query: func(_ context.Context, _ string, request querysemantic.Request) (querysemantic.Response, error) {
			switch request.ObjectID {
			case analyticsDashboardObject:
				return analyticsQueryResponse(analyticsQueryRecord(
					analyticsDashboardObject,
					"Id", "dashboard-id", "Name", "Pipeline", "DeveloperName", "pipeline",
				)), nil
			case analyticsComponentObject:
				records := make([]querysemantic.Record, analyticsDashboardMaxParts)
				for index := range records {
					records[index] = analyticsQueryRecord(
						analyticsComponentObject,
						"Id", fmt.Sprintf("component-%03d", index), "DashboardId", "dashboard-id", "ReportId", "report-1", "Type", "Bar",
					)
				}
				response := analyticsQueryResponse(records...)
				response.TotalSize = uint64(analyticsDashboardMaxParts) + 1
				response.Done = false
				return response, nil
			default:
				t.Fatalf("unexpected Runtime query %#v", request)
				return querysemantic.Response{}, nil
			}
		},
	}
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	if _, err := client.dashboard(
		ctx, "user-secret", "pipeline", analyticsReportReceipts(),
	); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("truncated component page error = %v, want authority failure", err)
	}
}

func analyticsQueryResponse(records ...querysemantic.Record) querysemantic.Response {
	return querysemantic.Response{
		TotalSize: uint64(len(records)), Done: true, Records: records,
		Receipts: querysemantic.Receipts{
			ProtocolVersion: "1.0", CapabilityVersion: querysemantic.CapabilityName,
			CatalogRevision: 17, SchemaGeneration: 8, EngineGeneration: 9, SecurityEpoch: 4,
		},
	}
}

func analyticsQueryRecord(object string, fields ...string) querysemantic.Record {
	result := querysemantic.Record{ObjectID: object, Fields: make([]querysemantic.Field, 0, len(fields)/2)}
	for index := 0; index < len(fields); index += 2 {
		value := fields[index+1]
		result.Fields = append(result.Fields, querysemantic.Field{
			Name: fields[index], Value: querysemantic.Value{Kind: querysemantic.ValueString, String: &value},
		})
	}
	sort.Slice(result.Fields, func(left, right int) bool {
		return result.Fields[left].Name < result.Fields[right].Name
	})
	return result
}

func TestReportDescribeProjectsOnlyExactImmutableDefinition(t *testing.T) {
	document, err := decodeCanonicalReport(analyticsCanonicalReportPayload(t), "report-1")
	if err != nil {
		t.Fatal(err)
	}
	metadata := mustProjectCanonicalReportDefinition(t, document)
	reportType, ok := metadata["reportType"].(map[string]any)
	if !ok || reportType["type"] != "OpportunityList" || reportType["label"] != "Opportunity" ||
		metadata["sourceObject"] != "Opportunity" || metadata["sourceRef"] != "OpportunityList" || metadata["reportFormat"] != "SUMMARY" ||
		metadata["scope"] != "myTeam" || metadata["definitionVersion"] != "7" {
		t.Fatalf("report metadata = %#v", metadata)
	}
	columns, ok := metadata["detailColumns"].([]string)
	if !ok || len(columns) != 2 || columns[1] != "Amount" {
		t.Fatalf("authored columns = %#v", metadata["detailColumns"])
	}
	grouping, ok := metadata["groupingsDown"].([]map[string]any)
	if !ok || len(grouping) != 1 || grouping[0]["name"] != "StageName" {
		t.Fatalf("authored grouping = %#v", metadata["groupingsDown"])
	}
	filters, ok := metadata["reportFilters"].([]map[string]any)
	if !ok || len(filters) != 1 || filters[0]["operator"] != "equals" {
		t.Fatalf("authored filters = %#v", metadata["reportFilters"])
	}
	dateFilter, ok := metadata["standardDateFilter"].(map[string]any)
	if !ok || dateFilter["column"] != "CloseDate" || dateFilter["durationValue"] != "THIS_QUARTER" {
		t.Fatalf("authored date filter = %#v", metadata["standardDateFilter"])
	}
	if _, exposed := metadata["reportBooleanFilter"]; exposed {
		t.Fatalf("describe exposed an unconsumed filter-logic surface: %#v", metadata)
	}
}

func TestReportExecutionKeepsEngineProjectionSeparateFromDefinition(t *testing.T) {
	document, err := decodeCanonicalReport(analyticsCanonicalReportPayload(t), "report-1")
	if err != nil {
		t.Fatal(err)
	}
	result := mustProjectCanonicalReport(t, document)
	metadata, ok := result["reportMetadata"].(map[string]any)
	if !ok {
		t.Fatalf("reportMetadata = %#v", result["reportMetadata"])
	}
	columns, ok := metadata["detailColumns"].([]string)
	if !ok || len(columns) != 2 || columns[1] != "Amount__physical" {
		t.Fatalf("execution columns = %#v", metadata["detailColumns"])
	}
	if columns[1] == document.Definition.Columns[1] {
		t.Fatalf("execution projection reused authored definition columns: %#v", columns)
	}
	reportType, ok := metadata["reportType"].(map[string]any)
	if !ok || reportType["type"] != "OpportunityList" || reportType["label"] != "Opportunity" || metadata["sourceObject"] != "Opportunity" {
		t.Fatalf("execution report source = %#v", metadata)
	}
	if metadata["sourceRef"] != "OpportunityList" || metadata["scope"] != "myTeam" {
		t.Fatalf("execution report immutable definition metadata = %#v", metadata)
	}
	filters, ok := metadata["reportFilters"].([]map[string]any)
	dateFilter, dateOK := metadata["standardDateFilter"].(map[string]any)
	if !ok || len(filters) != 1 || filters[0]["column"] != "StageName" ||
		!dateOK || dateFilter["column"] != "CloseDate" || dateFilter["durationValue"] != "THIS_QUARTER" {
		t.Fatalf("execution report filters = %#v date=%#v", filters, dateFilter)
	}
	extended := metadata["reportExtendedMetadata"].(map[string]any)
	detail := extended["detailColumnInfo"].(map[string]any)
	grouping := extended["groupingColumnInfo"].(map[string]any)
	aggregates := extended["aggregateColumnInfo"].(map[string]any)
	if detail["Name"].(map[string]any)["label"] != "Opportunity Name" ||
		detail["Amount__physical"].(map[string]any)["dataType"] != "currency" ||
		grouping["StageName__physical"].(map[string]any)["dataType"] != "string" ||
		aggregates["s!Amount__physical"].(map[string]any)["dataType"] != "currency" {
		t.Fatalf("revision-bound analytics field metadata = %#v", extended)
	}
}

func TestAnalyticsFieldMetadataPreservesLegacyScalarTypes(t *testing.T) {
	for _, test := range []struct {
		field searchFieldSpec
		want  string
	}{
		{field: searchFieldSpec{Type: "datetime"}, want: "date"},
		{field: searchFieldSpec{Type: "currency"}, want: "currency"},
		{field: searchFieldSpec{Type: "percent"}, want: "percent"},
		{field: searchFieldSpec{Type: "boolean"}, want: "boolean"},
		{field: searchFieldSpec{Type: "integer"}, want: "int"},
		{field: searchFieldSpec{Type: "double"}, want: "double"},
		{field: searchFieldSpec{Type: "formula", ReturnType: "percent"}, want: "percent"},
		{field: searchFieldSpec{Type: "rollupsummary", ReturnType: "integer"}, want: "int"},
		{field: searchFieldSpec{Type: "rich_text"}, want: "string"},
		{field: searchFieldSpec{Type: "location"}, want: "string"},
		{field: searchFieldSpec{Type: "future_text_alias"}, want: "string"},
	} {
		if got := analyticsFieldDataType(test.field); got != test.want {
			t.Fatalf("analyticsFieldDataType(%#v) = %q, want %q", test.field, got, test.want)
		}
	}
	if validAnalyticsFieldTypeAuthority(searchFieldSpec{Type: "formula"}) ||
		validAnalyticsFieldTypeAuthority(searchFieldSpec{Type: "rollupsummary"}) {
		t.Fatal("computed field without immutable returnType authority was accepted")
	}
}

func TestAnalyticsMetadataUsesOneImmutableRuntimeAuthority(t *testing.T) {
	objects := make([]searchObjectSpec, 0, len(analyticsTestObjectSpecs()))
	for _, object := range analyticsTestObjectSpecs() {
		objects = append(objects, object)
	}
	view := searchTestView(t, objects)
	view.Receipts.SecurityEpoch = 4
	client := RuntimeAnalyticsClient{appMetadata: func(
		_ context.Context,
		request catalogsemantic.GetRequest,
	) (catalogsemantic.AppMetadataViewV3, error) {
		if request.MinCatalogRevision == nil || *request.MinCatalogRevision != 17 {
			t.Fatalf("analytics AppMetadata request = %#v", request)
		}
		return view, nil
	}}
	if metadata, err := client.analyticsObjectSpecs(context.Background(), analyticsReportReceipts()); err != nil || len(metadata) != len(objects) {
		t.Fatalf("analytics metadata = %#v, %v", metadata, err)
	}
	view.Receipts.SecurityEpoch++
	if _, err := client.analyticsObjectSpecs(context.Background(), analyticsReportReceipts()); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("mixed analytics metadata authority error = %v", err)
	}
}

func TestTabularReportNormalizesZeroTotalCountFromReturnedRows(t *testing.T) {
	document := canonicalReportDocument{
		ReportID: "report-1", Name: "Pipeline", DisplayMode: "TABULAR",
		Definition: canonicalReportDefinition{
			SourceObject: "Opportunity", Columns: []string{"Name"},
		},
		Columns: []string{"Name"}, Rows: []map[string]any{{"Name": "Deal"}},
	}
	result := mustProjectCanonicalReport(t, document)
	fact := result["factMap"].(map[string]any)["T!T"].(map[string]any)
	aggregates := fact["aggregates"].([]map[string]any)
	if len(aggregates) != 1 || aggregates[0]["value"] != 1 || result["allData"] != true {
		t.Fatalf("zero-total tabular projection = %#v", result)
	}
}

func TestTabularReportInferredColumnsPreserveMetadataAndHideCarrierFields(t *testing.T) {
	document := canonicalReportDocument{
		ReportID: "report-1", Name: "Accounts", DisplayMode: "TABULAR",
		Definition: canonicalReportDefinition{SourceObject: "Opportunity"},
		Rows: []map[string]any{{
			"Name": "Visible Opportunity", "attributes": map[string]any{"type": "Opportunity"},
			"_metadata": map[string]any{"internal": true}, "__primary_id__": "opp-1",
		}},
	}
	result := mustProjectCanonicalReport(t, document)
	metadata := result["reportMetadata"].(map[string]any)
	columns := metadata["detailColumns"].([]string)
	detail := metadata["reportExtendedMetadata"].(map[string]any)["detailColumnInfo"].(map[string]any)
	rows := result["factMap"].(map[string]any)["T!T"].(map[string]any)["rows"].([]map[string]any)
	if len(columns) != 1 || columns[0] != "Name" || len(detail) != 1 ||
		detail["Name"].(map[string]any)["label"] != "Opportunity Name" ||
		len(rows) != 1 || len(rows[0]["dataCells"].([]map[string]any)) != 1 {
		t.Fatalf("inferred report projection = %#v", result)
	}
}

func TestReportSourceProjectionPreservesEstablishedSalesforceNormalization(t *testing.T) {
	for _, test := range []struct {
		definition                 canonicalReportDefinition
		wantSourceObject, wantType string
	}{
		{definition: canonicalReportDefinition{SourceObject: "Opportunity"}, wantSourceObject: "Opportunity", wantType: "OpportunityList"},
		{definition: canonicalReportDefinition{SourceObject: "Opportunity", SourceRef: "Opportunity"}, wantSourceObject: "Opportunity", wantType: "OpportunityList"},
		{definition: canonicalReportDefinition{SourceObject: "OpportunityReport"}, wantSourceObject: "Opportunity", wantType: "OpportunityReport"},
	} {
		sourceObject, sourceRef := analyticsReportSource(test.definition)
		if sourceObject != test.wantSourceObject || sourceRef != test.wantType {
			t.Fatalf("analyticsReportSource(%#v) = %q, %q; want %q, %q", test.definition, sourceObject, sourceRef, test.wantSourceObject, test.wantType)
		}
	}
}

func TestReportExecutionPreservesAggregatedAndDeduplicatedSummarySemantics(t *testing.T) {
	aggregated := canonicalReportDocument{
		ReportID: "summary", Name: "Summary", DisplayMode: "SUMMARY",
		Definition: canonicalReportDefinition{SourceObject: "Issue", Grouping: []string{"Status"}},
		Grouping:   []string{"Status"},
		Rows:       []map[string]any{{"name": "Open", "val": 12.0}, {"name": "Won", "val": 8.0}},
	}
	result := mustProjectCanonicalReport(t, aggregated)
	groupingEnvelope := result["groupingsDown"].(map[string]any)
	groupings := groupingEnvelope["groupings"].([]map[string]any)
	if len(groupings) != 2 || groupings[0]["label"] != "Open" || groupings[1]["label"] != "Won" {
		t.Fatalf("pre-aggregated groupings = %#v", groupings)
	}
	factMap := result["factMap"].(map[string]any)
	grand := factMap["T!T"].(map[string]any)["aggregates"].([]map[string]any)
	if len(grand) != 1 || grand[0]["value"] != 20 {
		t.Fatalf("pre-aggregated grand total = %#v", grand)
	}
	preAggregatedSum := canonicalReportDocument{
		ReportID: "summary", Name: "Summary", DisplayMode: "SUMMARY", TotalCount: 1,
		Definition: canonicalReportDefinition{
			SourceObject: "Issue", Grouping: []string{"Status"},
			Aggregates: []canonicalReportAggregate{{Field: "Points", Type: "SUM"}},
		},
		Grouping: []string{"Status"}, Aggregates: []canonicalReportAggregate{{Field: "Points", Type: "SUM"}},
		Rows: []map[string]any{{"name": "Open", "val": json.Number("3.25")}},
	}
	if !validCanonicalPreAggregatedSummary(preAggregatedSum) {
		t.Fatalf("established pre-aggregated SUM shape was rejected: %#v", preAggregatedSum)
	}
	preAggregatedResult := mustProjectCanonicalReport(t, preAggregatedSum)
	preAggregatedMetadata := preAggregatedResult["reportMetadata"].(map[string]any)
	preAggregatedGrand := preAggregatedResult["factMap"].(map[string]any)["T!T"].(map[string]any)["aggregates"].([]map[string]any)
	if keys := preAggregatedMetadata["aggregates"].([]string); len(keys) != 1 || keys[0] != "s!Points" ||
		len(preAggregatedGrand) != 1 || preAggregatedGrand[0]["value"] != json.Number("3.25") {
		t.Fatalf("pre-aggregated SUM metadata=%#v grand=%#v", preAggregatedMetadata, preAggregatedGrand)
	}
	preAggregatedGroup := preAggregatedResult["factMap"].(map[string]any)["0!T"].(map[string]any)["aggregates"].([]map[string]any)
	if len(preAggregatedGroup) != 1 || preAggregatedGroup[0]["value"] != json.Number("3.25") {
		t.Fatalf("pre-aggregated SUM group=%#v", preAggregatedGroup)
	}

	raw := []map[string]any{
		{"Amount": 10.0, "__primary_id__": "one"},
		{"Amount": 10.0, "__primary_id__": "one"},
		{"Amount": 5.0, "__primary_id__": "two"},
	}
	values := analyticsAggregateValues(raw,
		[]canonicalReportAggregate{{Field: "Amount", Type: "SUM"}},
		map[string]string{"Amount": "__primary_id__"},
	)
	if len(values) != 2 || values[0]["value"] != 3 || values[1]["value"] != json.Number("15") {
		t.Fatalf("deduplicated aggregates = %#v", values)
	}

	ordered := canonicalReportDocument{
		DisplayMode: "SUMMARY", Grouping: []string{"StageName"}, TotalCount: 3,
		Definition: canonicalReportDefinition{
			SourceObject: "Opportunity", Grouping: []string{"StageName"},
			Aggregates: []canonicalReportAggregate{
				{Field: "Amount", Type: "SUM"},
				{Type: "RowCount"},
			},
		},
		Aggregates: []canonicalReportAggregate{
			{Field: "Amount", Type: "SUM"},
			{Type: "RowCount"},
		},
		Rows: raw, AggregateDedupColumn: map[string]string{"Amount": "__primary_id__"},
	}
	orderedResult := mustProjectCanonicalReport(t, ordered)
	orderedMetadata := orderedResult["reportMetadata"].(map[string]any)
	keys := orderedMetadata["aggregates"].([]string)
	orderedGrand := orderedResult["factMap"].(map[string]any)["T!T"].(map[string]any)["aggregates"].([]map[string]any)
	if len(keys) != 2 || keys[0] != "s!Amount" || keys[1] != "RowCount" ||
		len(orderedGrand) != 2 || orderedGrand[0]["value"] != json.Number("15") || orderedGrand[1]["value"] != 3 {
		t.Fatalf("ordered aggregate keys=%#v values=%#v", keys, orderedGrand)
	}

	countRows := []map[string]any{
		{"Id": "row-1", "__primary_id__": "row-1"},
		{"Id": "row-1", "__primary_id__": "row-1"},
		{"Id": "row-2", "__primary_id__": "row-2"},
		{"Id": nil, "__primary_id__": "row-3"},
	}
	counts := analyticsAggregateValues(
		countRows,
		[]canonicalReportAggregate{{Field: "Id", Type: "COUNT"}},
		map[string]string{"Id": "__primary_id__"},
	)
	if len(counts) != 2 || counts[0]["value"] != 4 || counts[1]["value"] != 2 {
		t.Fatalf("COUNT(Id) aggregates = %#v", counts)
	}
	blankIdentityCounts := analyticsAggregateValues(
		[]map[string]any{{"Id": "row-1"}, {"Id": "row-2"}},
		[]canonicalReportAggregate{{Field: "Id", Type: "COUNT"}},
		map[string]string{"Id": "__primary_id__"},
	)
	if len(blankIdentityCounts) != 2 || blankIdentityCounts[1]["value"] != 2 {
		t.Fatalf("blank dedup identities were collapsed: %#v", blankIdentityCounts)
	}
	extended, err := analyticsExtendedMetadata(
		"Opportunity", nil, nil, nil, nil,
		[]canonicalReportAggregate{
			{Type: "RowCount"}, {Field: "Id", Type: "COUNT"}, {Field: "OwnerId", Type: "COUNT"},
		},
		[]canonicalReportAggregate{
			{Type: "RowCount"}, {Field: "Id", Type: "COUNT"}, {Field: "OwnerId", Type: "COUNT"},
		},
		analyticsTestObjectSpecs(),
	)
	if err != nil {
		t.Fatal(err)
	}
	aggregateInfo := extended["aggregateColumnInfo"].(map[string]any)
	rowCountInfo := aggregateInfo["RowCount"].(map[string]any)
	countInfo := aggregateInfo["c!Id"].(map[string]any)
	ownerCountInfo := aggregateInfo["c!OwnerId"].(map[string]any)
	if rowCountInfo["label"] != "Record Count" || rowCountInfo["dataType"] != "int" ||
		countInfo["dataType"] != "int" || ownerCountInfo["dataType"] != "int" || len(aggregateInfo) != 3 {
		t.Fatalf("aggregate extended metadata = %#v", aggregateInfo)
	}

	precise := analyticsAggregateValues(
		[]map[string]any{{"Amount": json.Number("9007199254740993.01")}, {"Amount": json.Number("0.02")}},
		[]canonicalReportAggregate{{Field: "Amount", Type: "SUM"}}, nil,
	)
	if len(precise) != 2 || precise[1]["value"] != json.Number("9007199254740993.03") {
		t.Fatalf("high-precision aggregate = %#v", precise)
	}
	if _, ok := analyticsNumber("1/3"); ok {
		t.Fatal("non-JSON rational input was accepted as a canonical number")
	}
}

func TestReportReadFailsClosedOnMissingDefinitionOrMixedAuthority(t *testing.T) {
	withoutDefinition, err := json.Marshal(map[string]any{
		"aggregates": []any{}, "columns": []string{"Id"},
		"definitionDigest":  "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
		"definitionVersion": "1", "displayMode": "TABULAR", "grouping": []any{},
		"name": "Old result", "reportId": "report-1", "rows": []any{},
		"schema": "nexuscrm.report-result/v1", "totalCount": 0,
	})
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(withoutDefinition, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("missing definition error = %v, want authority failure", err)
	}

	var invalidDedup map[string]any
	if err := json.Unmarshal(analyticsCanonicalReportPayload(t), &invalidDedup); err != nil {
		t.Fatal(err)
	}
	invalidDedup["aggregateDedupColumn"] = map[string]string{"NotAnAggregate": "__primary_id__"}
	invalidDedupPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(invalidDedupPayload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("unowned aggregate dedup error = %v, want authority failure", err)
	}
	invalidDedup["aggregateDedupColumn"] = map[string]string{"Amount__physical": "__primary_id__"}
	for _, identity := range []any{nil, "", 17} {
		rows := invalidDedup["rows"].([]any)
		row := rows[0].(map[string]any)
		if identity == nil {
			delete(row, "__primary_id__")
		} else {
			row["__primary_id__"] = identity
		}
		payload, marshalErr := json.Marshal(invalidDedup)
		if marshalErr != nil {
			t.Fatal(marshalErr)
		}
		if _, decodeErr := decodeCanonicalReport(payload, "report-1"); !errors.Is(decodeErr, errAnalyticsAuthority) {
			t.Fatalf("dedup identity %#v error = %v, want authority failure", identity, decodeErr)
		}
	}
	invalidDedup["rows"].([]any)[0].(map[string]any)["__primary_id__"] = "opp-1"
	validDedupPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(validDedupPayload, "report-1"); err != nil {
		t.Fatalf("valid dedup identity payload = %v", err)
	}
	invalidDedup["aggregateDedupColumn"] = map[string]string{}
	invalidDedup["totalCount"] = 0
	invalidDedup["rows"] = append(invalidDedup["rows"].([]any), map[string]any{
		"Amount__physical": 7, "Name": "Second deal", "StageName__physical": "Open",
	})
	zeroTotalPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(zeroTotalPayload, "report-1"); err != nil {
		t.Fatalf("unknown total with a returned page = %v", err)
	}
	invalidDedup["totalCount"] = 1
	contradictoryTotalPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(contradictoryTotalPayload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("contradictory total error = %v, want authority failure", err)
	}
	invalidDedup["totalCount"] = 2
	validPagedTotalPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(validPagedTotalPayload, "report-1"); err != nil {
		t.Fatalf("valid paged total payload = %v", err)
	}
	invalidDedup["rows"].([]any)[0].(map[string]any)["Amount__physical"] = "not-a-number"
	invalidNumericPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(invalidNumericPayload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("invalid aggregate number error = %v, want authority failure", err)
	}
	invalidDedup["rows"].([]any)[0].(map[string]any)["Amount__physical"] = "3.25"
	exactDecimalPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(exactDecimalPayload, "report-1"); err != nil {
		t.Fatalf("exact DECIMAL string payload = %v", err)
	}
	invalidDedup["rows"].([]any)[0].(map[string]any)["Amount__physical"] = nil
	nullNumericPayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(nullNumericPayload, "report-1"); err != nil {
		t.Fatalf("null aggregate value payload = %v", err)
	}
	invalidDedup["aggregates"] = []map[string]any{{"field": "Amount__physical", "type": "MEDIAN"}}
	unsupportedAggregatePayload, err := json.Marshal(invalidDedup)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(unsupportedAggregatePayload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("unsupported aggregate error = %v, want authority failure", err)
	}
	for _, aggregate := range []map[string]any{
		{"field": "", "type": "COUNT"},
		{"field": "Amount__physical", "type": "SUM "},
		{"field": "", "type": "rowcount"},
	} {
		invalidDedup["aggregates"] = []map[string]any{aggregate}
		payload, marshalErr := json.Marshal(invalidDedup)
		if marshalErr != nil {
			t.Fatal(marshalErr)
		}
		if _, decodeErr := decodeCanonicalReport(payload, "report-1"); !errors.Is(decodeErr, errAnalyticsAuthority) {
			t.Fatalf("non-canonical aggregate %#v error = %v, want authority failure", aggregate, decodeErr)
		}
	}

	var unsupportedPreAggregated map[string]any
	if err := json.Unmarshal(analyticsCanonicalReportPayload(t), &unsupportedPreAggregated); err != nil {
		t.Fatal(err)
	}
	unsupportedPreAggregated["columns"] = []any{}
	unsupportedPreAggregated["grouping"] = []string{"StageName"}
	unsupportedPreAggregated["rows"] = []map[string]any{{"name": "Open", "val": 12}, {"name": "Won", "val": 8}}
	unsupportedPayload, err := json.Marshal(unsupportedPreAggregated)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(unsupportedPayload, "report-1"); err != nil {
		t.Fatalf("established pre-aggregated aggregate payload = %v", err)
	}
	unsupportedPreAggregated["rows"] = []map[string]any{{"name": 1, "val": 12}}
	numericGroupPayload, err := json.Marshal(unsupportedPreAggregated)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(numericGroupPayload, "report-1"); err != nil {
		t.Fatalf("numeric group key payload = %v", err)
	}
	unsupportedPreAggregated["grouping"] = []string{"StageName", "OwnerId"}
	unsupportedPreAggregated["definition"].(map[string]any)["grouping"] = []string{"StageName", "OwnerId"}
	multiGroupMarkerPayload, err := json.Marshal(unsupportedPreAggregated)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(multiGroupMarkerPayload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("multi-group marker error = %v, want authority failure", err)
	}
	unsupportedPreAggregated["grouping"] = []string{"StageName"}
	unsupportedPreAggregated["definition"].(map[string]any)["grouping"] = []string{"StageName"}
	unsupportedPreAggregated["aggregates"] = []map[string]any{{"field": "Amount__physical", "type": "COUNT"}}
	unsupportedPreAggregated["definition"].(map[string]any)["aggregates"] = []map[string]any{{"field": "Amount", "type": "COUNT"}}
	unsupportedPreAggregated["rows"] = []map[string]any{{"name": "Open", "val": 1.5}}
	decimalCountPayload, err := json.Marshal(unsupportedPreAggregated)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(decimalCountPayload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("decimal pre-aggregated COUNT error = %v, want authority failure", err)
	}
	unsupportedPreAggregated["aggregates"] = []any{}
	unsupportedPreAggregated["definition"].(map[string]any)["aggregates"] = []any{}
	unsupportedPreAggregated["rows"] = []map[string]any{{"name": "Open", "val": 12}, {"name": "Won", "val": 8}}
	unsupportedPreAggregated["totalCount"] = 0
	validPreAggregatedPayload, err := json.Marshal(unsupportedPreAggregated)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(validPreAggregatedPayload, "report-1"); err != nil {
		t.Fatalf("valid row-count pre-aggregated payload = %v", err)
	}
	unsupportedPreAggregated["rows"] = []map[string]any{{"name": "Open", "val": 12}, {"name": "Won"}}
	malformedPayload, err := json.Marshal(unsupportedPreAggregated)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := decodeCanonicalReport(malformedPayload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("mixed pre-aggregated row error = %v, want authority failure", err)
	}

	expected := analyticsReportReceipts()
	actual := expected
	actual.SecurityEpoch++
	client := &RuntimeAnalyticsClient{readReport: func(context.Context, string, reportsemantic.Request) (reportsemantic.Response, error) {
		return reportsemantic.Response{CanonicalResult: analyticsCanonicalReportPayload(t), Receipts: actual}, nil
	}}
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	if _, err := client.readSavedReportDocument(ctx, "Bearer end-user", "report-1", expected, []byte("{}"), 1); !errors.Is(err, errAnalyticsAuthority) {
		t.Fatalf("mixed authority error = %v, want authority failure", err)
	}
	canonical := string(analyticsCanonicalReportPayload(t))
	duplicateKey := strings.Replace(canonical, `"totalCount":1`, `"totalCount":1,"totalCount":2`, 1)
	if duplicateKey == canonical {
		t.Fatal("test payload did not acquire a duplicate JSON key")
	}
	client.readReport = func(context.Context, string, reportsemantic.Request) (reportsemantic.Response, error) {
		return reportsemantic.Response{CanonicalResult: []byte(duplicateKey), Receipts: expected}, nil
	}
	if _, err := client.readSavedReportDocument(ctx, "Bearer end-user", "report-1", expected, []byte("{}"), 1); err == nil {
		t.Fatal("duplicate-key canonical ReportRead payload was accepted")
	}
}

func TestReportReadFailsClosedOnUnsupportedDisplayModes(t *testing.T) {
	for _, test := range []struct {
		name       string
		execution  string
		definition string
	}{
		{name: "unknown execution", execution: "CUSTOM", definition: "SUMMARY"},
		{name: "matrix execution", execution: "MATRIX", definition: "MATRIX"},
		{name: "matrix immutable definition", execution: "SUMMARY", definition: "MATRIX"},
	} {
		t.Run(test.name, func(t *testing.T) {
			var document map[string]any
			if err := json.Unmarshal(analyticsCanonicalReportPayload(t), &document); err != nil {
				t.Fatal(err)
			}
			document["displayMode"] = test.execution
			document["definition"].(map[string]any)["displayMode"] = test.definition
			payload, err := json.Marshal(document)
			if err != nil {
				t.Fatal(err)
			}
			if _, err := decodeCanonicalReport(payload, "report-1"); !errors.Is(err, errAnalyticsAuthority) {
				t.Fatalf("display modes %q/%q error = %v, want authority failure", test.execution, test.definition, err)
			}
		})
	}
}

func TestAnalyticsListRoutesPreserveSalesforceLimit(t *testing.T) {
	permissions := validPermissionResponse(17, 4)
	permissions.SystemPermissions = analyticsTestSystemPermissions()
	config := permissionMetadataServiceConfig(
		func(context.Context, string, permissionsemantic.Request) (permissionsemantic.Response, error) {
			return permissions, nil
		},
		func(context.Context, catalogsemantic.GetRequest) (catalogsemantic.AppMetadataView, error) {
			return catalogsemantic.AppMetadataView{}, nil
		},
	)
	var limits []uint32
	var totalSizeUnknown bool
	config.RuntimeQuery = func(_ context.Context, _ string, request querysemantic.Request) (querysemantic.Response, error) {
		limits = append(limits, request.Limit)
		response := analyticsQueryResponse()
		response.TotalSize = 7
		response.TotalSizeUnknown = totalSizeUnknown
		return response, nil
	}
	config.RuntimeReadReport = func(context.Context, string, reportsemantic.Request) (reportsemantic.Response, error) {
		return reportsemantic.Response{}, nil
	}
	installAnalyticsTestMetadata(t, &config)
	service, err := NewService(config)
	if err != nil {
		t.Fatal(err)
	}
	for _, path := range []string{
		"/services/data/v63.0/analytics/reports?limit=1",
		"/services/data/v63.0/analytics/dashboards?limit=2000",
	} {
		request := httptest.NewRequest(http.MethodGet, path, nil)
		request.Header.Set("Authorization", "Bearer user-secret")
		recorder := httptest.NewRecorder()
		service.ServeHTTP(recorder, request)
		if recorder.Code != http.StatusOK {
			t.Fatalf("GET %s status=%d body=%s", path, recorder.Code, recorder.Body.String())
		}
		var response map[string]any
		if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
			t.Fatal(err)
		}
		if response["totalSize"] != float64(7) {
			t.Fatalf("GET %s totalSize = %#v", path, response["totalSize"])
		}
	}
	if len(limits) != 2 || limits[0] != 1 || limits[1] != 2000 {
		t.Fatalf("Runtime list limits = %#v", limits)
	}
	totalSizeUnknown = true
	request := httptest.NewRequest(http.MethodGet, "/services/data/v63.0/analytics/reports?limit=1", nil)
	request.Header.Set("Authorization", "Bearer user-secret")
	recorder := httptest.NewRecorder()
	service.ServeHTTP(recorder, request)
	if recorder.Code != http.StatusServiceUnavailable {
		t.Fatalf("unknown total size status=%d body=%s", recorder.Code, recorder.Body.String())
	}
	for raw, want := range map[string]uint32{"": 200, "0": 200, "2001": 200, "invalid": 200} {
		if got := analyticsListLimit(raw); got != want {
			t.Fatalf("analyticsListLimit(%q) = %d, want %d", raw, got, want)
		}
	}
}

func TestAnalyticsRunningUserDefaultsViewerAndRejectsExplicitOtherUser(t *testing.T) {
	if user, ok := analyticsRunningUser(""); !ok || user != "viewer" {
		t.Fatalf("default running user = %q, %v", user, ok)
	}
	if _, ok := analyticsRunningUser("other-user"); ok {
		t.Fatal("explicit non-viewer running user was accepted")
	}
}

func TestAnalyticsReadPropagatesRequestDeadline(t *testing.T) {
	permissions := validPermissionResponse(17, 4)
	permissions.SystemPermissions = analyticsTestSystemPermissions()
	var sawDeadline atomic.Bool
	config := permissionMetadataServiceConfig(
		func(context.Context, string, permissionsemantic.Request) (permissionsemantic.Response, error) {
			return permissions, nil
		},
		func(context.Context, catalogsemantic.GetRequest) (catalogsemantic.AppMetadataView, error) {
			return catalogsemantic.AppMetadataView{}, nil
		},
	)
	config.RequestTimeout = 20 * time.Millisecond
	config.RuntimeReadReport = func(ctx context.Context, _ string, _ reportsemantic.Request) (reportsemantic.Response, error) {
		<-ctx.Done()
		sawDeadline.Store(errors.Is(ctx.Err(), context.DeadlineExceeded))
		return reportsemantic.Response{}, &commonsemantic.Failure{Category: commonsemantic.FailureDeadlineExceeded}
	}
	installAnalyticsTestMetadata(t, &config)
	service, err := NewService(config)
	if err != nil {
		t.Fatal(err)
	}
	request := httptest.NewRequest(http.MethodGet, "/services/data/v63.0/analytics/reports/report-1", nil)
	request.Header.Set("Authorization", "Bearer user-secret")
	recorder := httptest.NewRecorder()
	service.ServeHTTP(recorder, request)
	if recorder.Code != http.StatusGatewayTimeout || !sawDeadline.Load() {
		t.Fatalf("status=%d sawDeadline=%v body=%s", recorder.Code, sawDeadline.Load(), recorder.Body.String())
	}
}

func analyticsReportReceipts() commonsemantic.Receipts {
	return commonsemantic.Receipts{
		ProtocolVersion: "1.0", CapabilityVersion: reportsemantic.CapabilityName,
		CatalogRevision: 17, SchemaGeneration: 8, EngineGeneration: 9, SecurityEpoch: 4,
	}
}

func analyticsCanonicalReportPayload(t *testing.T) []byte {
	t.Helper()
	payload, err := json.Marshal(map[string]any{
		"aggregates": []map[string]any{{"field": "Amount__physical", "type": "SUM"}},
		"columns":    []string{"Name", "Amount__physical"},
		"definition": map[string]any{
			"aggregates": []map[string]any{{"field": "Amount", "type": "SUM"}},
			"columns":    []string{"Name", "Amount"},
			"dateFilter": map[string]any{
				"column": "CloseDate", "durationValue": "THIS_QUARTER", "endDate": "", "startDate": "",
			},
			"displayMode": "SUMMARY",
			"filters":     []map[string]any{{"column": "StageName", "operator": "equals", "value": "Open"}},
			"grouping":    []string{"StageName"}, "scope": "myTeam",
			"sourceObject": "Opportunity", "sourceRef": "OpportunityList",
		},
		"definitionDigest":  "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
		"definitionVersion": "7", "displayMode": "SUMMARY",
		"grouping": []string{"StageName__physical"}, "name": "Pipeline", "reportId": "report-1",
		"rows":   []map[string]any{{"Amount__physical": 42, "Name": "Deal", "StageName__physical": "Open"}},
		"schema": "nexuscrm.report-result/v1", "totalCount": 1,
	})
	if err != nil {
		t.Fatal(err)
	}
	return payload
}