package service

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

	"github.com/spf13/viper"
	"gorm.io/gorm"

	"data-platform/internal/dataplatform/store"
	"data-platform/model"
)

func TestShouldSkipRevrecMainSyncDoesNotSkipNewOrderRevrecByType(t *testing.T) {
	revrec := &model.CloudRevrec{
		Sync:           0,
		Type:           0,
		AccountNumber:  "IBG-B-20260304-003837",
		AdjustTenantID: "1372813089209251856",
	}

	if shouldSkipRevrecMainSync(revrec) {
		t.Fatal("type=0 revrec should not be skipped when it belongs to a Salesforce account")
	}
}

func TestSelectLastMonthOrderBatchUsesStableCRMEligibleLimit(t *testing.T) {
	orders := []*model.CloudOrder{
		{ID: 30, Sync: 0, AdjustTenantID: "tenant-30", AccountNumber: "IBG-B-30"},
		{ID: 10, Sync: 0, AdjustTenantID: "1372813089209000010", AccountNumber: "1372813089209000010"},
		{ID: 20, Sync: 0, AdjustTenantID: "tenant-20", AccountNumber: "IBG-B-20"},
		{ID: 40, Sync: 1, AdjustTenantID: "tenant-40", AccountNumber: "IBG-B-40"},
	}

	selected, err := selectLastMonthOrderBatch(orders, model.SfReqBody{Type: model.Order, Limit: 2})
	if err != nil {
		t.Fatalf("selectLastMonthOrderBatch: %v", err)
	}
	got := cloudOrderIDs(selected)
	if len(got) != 2 || got[0] != 20 || got[1] != 30 {
		t.Fatalf("selected ids = %v, want [20 30]", got)
	}
}

func TestSelectLastMonthOrderBatchUsesExactIDsInStableOrder(t *testing.T) {
	orders := []*model.CloudOrder{
		{ID: 30, Sync: 0, AdjustTenantID: "tenant-30", AccountNumber: "IBG-B-30"},
		{ID: 10, Sync: 0, AdjustTenantID: "tenant-10", AccountNumber: "IBG-B-10"},
		{ID: 20, Sync: 0, AdjustTenantID: "tenant-20", AccountNumber: "IBG-B-20"},
	}

	selected, err := selectLastMonthOrderBatch(orders, model.SfReqBody{Type: model.Order, OrderIDs: []uint64{30, 10}})
	if err != nil {
		t.Fatalf("selectLastMonthOrderBatch: %v", err)
	}
	got := cloudOrderIDs(selected)
	if len(got) != 2 || got[0] != 10 || got[1] != 30 {
		t.Fatalf("selected ids = %v, want [10 30]", got)
	}
}

func TestSelectLastMonthOrderBatchRejectsUnsafeScopesBeforeProcessing(t *testing.T) {
	orders := []*model.CloudOrder{
		{ID: 10, Sync: 0, AdjustTenantID: "1372813089209000010", AccountNumber: "1372813089209000010"},
		{ID: 20, Sync: 0, AdjustTenantID: "tenant-20", AccountNumber: "IBG-B-20"},
	}

	tests := []struct {
		name string
		req  model.SfReqBody
	}{
		{name: "missing id", req: model.SfReqBody{Type: model.Order, OrderIDs: []uint64{99}}},
		{name: "ineligible id", req: model.SfReqBody{Type: model.Order, OrderIDs: []uint64{10}}},
		{name: "no eligible limited candidates", req: model.SfReqBody{Type: model.Order, Limit: 1}},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			input := orders
			if tt.name == "no eligible limited candidates" {
				input = orders[:1]
			}
			if _, err := selectLastMonthOrderBatch(input, tt.req); err == nil {
				t.Fatal("selectLastMonthOrderBatch() error = nil, want rejection")
			}
		})
	}
}

func TestSelectLastMonthOrderBatchDefaultPreservesFullBatchOrder(t *testing.T) {
	orders := []*model.CloudOrder{
		{ID: 30, Sync: 0, AdjustTenantID: "tenant-30", AccountNumber: "IBG-B-30"},
		{ID: 10, Sync: 0, AdjustTenantID: "1372813089209000010", AccountNumber: "1372813089209000010"},
	}

	selected, err := selectLastMonthOrderBatch(orders, model.SfReqBody{Type: model.Order})
	if err != nil {
		t.Fatalf("selectLastMonthOrderBatch: %v", err)
	}
	got := cloudOrderIDs(selected)
	if len(got) != 2 || got[0] != 30 || got[1] != 10 {
		t.Fatalf("selected ids = %v, want original order [30 10]", got)
	}
}

func TestProcessLastMonthOrderBatchUsesBoundedConcurrency(t *testing.T) {
	orders := make([]*model.CloudOrder, 8)
	for index := range orders {
		orders[index] = &model.CloudOrder{ID: uint64(index + 1)}
	}

	started := make(chan uint64, len(orders))
	release := make(chan struct{})
	done := make(chan []error, 1)
	var mu sync.Mutex
	processed := make(map[uint64]int, len(orders))

	go func() {
		done <- processLastMonthOrderBatch(
			context.Background(),
			orders,
			3,
			func(_ context.Context, order *model.CloudOrder) error {
				started <- order.ID
				<-release
				mu.Lock()
				processed[order.ID]++
				mu.Unlock()
				return nil
			},
		)
	}()

	for range 3 {
		<-started
	}
	select {
	case id := <-started:
		t.Fatalf("order %d started before a worker slot was released", id)
	case <-time.After(50 * time.Millisecond):
	}
	close(release)

	if errs := <-done; len(errs) != 0 {
		t.Fatalf("processLastMonthOrderBatch errors = %v, want none", errs)
	}
	if len(processed) != len(orders) {
		t.Fatalf("processed order count = %d, want %d", len(processed), len(orders))
	}
	for _, order := range orders {
		if processed[order.ID] != 1 {
			t.Fatalf("order %d processed %d times, want once", order.ID, processed[order.ID])
		}
	}
}

func TestProcessLastMonthOrderBatchStopsDispatchAfterCRMRateLimit(t *testing.T) {
	orders := make([]*model.CloudOrder, 100)
	for index := range orders {
		orders[index] = &model.CloudOrder{ID: uint64(index + 1)}
	}

	var attempted atomic.Int32
	errs := processLastMonthOrderBatch(
		context.Background(),
		orders,
		3,
		func(_ context.Context, order *model.CloudOrder) error {
			attempted.Add(1)
			if order.ID == 1 {
				return errCRMRequestLimitExceeded
			}
			time.Sleep(20 * time.Millisecond)
			return nil
		},
	)

	if attempted.Load() >= int32(len(orders)) {
		t.Fatalf("attempted %d orders after rate limit, want dispatch to stop", attempted.Load())
	}
	foundRateLimit := false
	for _, err := range errs {
		if errors.Is(err, errCRMRequestLimitExceeded) {
			foundRateLimit = true
		}
	}
	if !foundRateLimit {
		t.Fatalf("errors = %v, want CRM rate-limit sentinel", errs)
	}
}

func TestShouldSkipRevrecMainSyncSkipsNumericAccountWithoutSalesforceAccount(t *testing.T) {
	revrec := &model.CloudRevrec{
		Sync:           0,
		Type:           0,
		AccountNumber:  "1372813089209270492",
		AdjustTenantID: "1372813089209270492",
	}

	if !shouldSkipRevrecMainSync(revrec) {
		t.Fatal("numeric account revrec should be skipped because it has no Salesforce account")
	}
}

func TestSalesforceLastInvoiceMonthFinalizesRevrecLocallyWithoutOrderDependency(t *testing.T) {
	var externalRequests atomic.Int32
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		externalRequests.Add(1)
		http.Error(w, "external CRM must not be called", http.StatusInternalServerError)
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	revrecStore := &fakeCloudRevrecStore{records: []*model.CloudRevrec{{
		ID:                    41,
		Type:                  0,
		Date:                  "2026-07-01",
		BillingEndDate:        "2026-07-31",
		Status:                "Draft",
		AdjustedRevenueAmount: "123.45",
		BillMonth:             GetLastMonth(),
		AdjustTenantID:        "tenant-41",
		AccountNumber:         "IBG-B-41",
		Order:                 "2026_08__ON_DEMAND__IBG_B_41",
		OrderNumber:           "2026_08__ON_DEMAND__IBG_B_41",
	}}}
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		revrec: revrecStore,
		order:  &fakeCloudOrderStore{},
	}}

	err := sfs.SalesforceLastInvoiceMonth(context.Background(), model.SfReqBody{
		Type:  model.Revrec,
		Types: "revrec",
	})
	if err != nil {
		t.Fatalf("SalesforceLastInvoiceMonth: %v", err)
	}
	if got := externalRequests.Load(); got != 0 {
		t.Fatalf("external CRM requests = %d, want 0", got)
	}
	if len(revrecStore.updatedRecords) != 1 {
		t.Fatalf("local revrec updates = %d, want 1", len(revrecStore.updatedRecords))
	}
	got := revrecStore.updatedRecords[0]
	if got.Order != "2026_08__ON_DEMAND__IBG_B_41" || got.OrderNumber != "2026_08__ON_DEMAND__IBG_B_41" {
		t.Fatalf("order references changed = %q/%q, want original source references", got.Order, got.OrderNumber)
	}
	if got.Status != "Draft" || got.AdjustedRevenueAmount != "123.45" {
		t.Fatalf("business fields changed: status=%q amount=%q", got.Status, got.AdjustedRevenueAmount)
	}
	if got.RevrecID != "" || got.RevrecNumber != "" {
		t.Fatalf("fabricated revrec identity = %q/%q", got.RevrecID, got.RevrecNumber)
	}
	if got.Sync != 1 || got.SyncTime.IsZero() {
		t.Fatalf("local completion state = sync %d time %v, want sync=1 with sync_time", got.Sync, got.SyncTime)
	}
}

func TestSyncSingleSFFinalizesRevrecLocallyWithoutSalesforceCreate(t *testing.T) {
	var externalRequests atomic.Int32
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		externalRequests.Add(1)
		http.Error(w, "external CRM must not be called", http.StatusInternalServerError)
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	revrecStore := &fakeCloudRevrecStore{byID: model.CloudRevrec{
		ID:             42,
		Date:           "2026-07-01",
		BillingEndDate: "2026-07-31",
		BillMonth:      "2026-07",
		AdjustTenantID: "tenant-42",
		AccountNumber:  "IBG-B-42",
		OrderNumber:    "source-order-42",
	}}
	orderStore := &fakeCloudOrderStore{byRef: map[string]model.CloudOrder{
		"source-order-42": {
			NewOrderID:     "nexus-order-42",
			NewOrderNumber: "NEXUS-ORDER-42",
		},
	}}
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		revrec: revrecStore,
		order:  orderStore,
	}}

	result, err := sfs.SyncSingleSF(context.Background(), model.SfReqBody{
		Type:  model.Revrec,
		Types: "revrec",
		ID:    42,
	})
	if err != nil {
		t.Fatalf("SyncSingleSF: %v", err)
	}
	if result.Status != "synced" {
		t.Fatalf("result status = %q, want synced", result.Status)
	}
	if got := externalRequests.Load(); got != 0 {
		t.Fatalf("external CRM requests = %d, want 0", got)
	}
	if len(revrecStore.updatedRecords) != 1 || revrecStore.updatedRecords[0].Sync != 1 {
		t.Fatalf("local revrec updates = %+v, want one sync=1 update", revrecStore.updatedRecords)
	}
}

func TestSalesforceLastInvoiceMonthFinalizesCollectionLocallyWithoutSalesforceCreate(t *testing.T) {
	const pdfBody = "%PDF-local-collection"
	fileServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet || r.URL.Path != "/invoice.pdf" {
			t.Fatalf("unexpected invoice request: %s %s", r.Method, r.URL.Path)
		}
		_, _ = w.Write([]byte(pdfBody))
	}))
	defer fileServer.Close()

	var externalCRMRequests atomic.Int32
	crmServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		externalCRMRequests.Add(1)
		http.Error(w, "external CRM must not be called", http.StatusInternalServerError)
	}))
	defer crmServer.Close()
	restore := configureSalesforceRequestTest(t, crmServer, 1)
	defer restore()

	collectionStore := &fakeCloudCollectionStore{records: []*model.CloudCollection{{
		ID:                51,
		PayableAmount:     "500.00",
		CollectionStatus:  "Open",
		CollectionsAmount: "125.00",
		BillMonth:         GetLastMonth(),
		AdjustTenantID:    "tenant-51",
		AccountNumber:     "IBG-B-51",
		OrderNumber:       "source-order-51",
		Files:             fileServer.URL + "/invoice.pdf",
		CollectionID:      "existing-collection-51",
		CollectionNumber:  "COLLECTION-51",
	}}}
	orderStore := &fakeCloudOrderStore{byRef: map[string]model.CloudOrder{
		"source-order-51": {
			NewOrderID:     "nexus-order-51",
			NewOrderNumber: "NEXUS-ORDER-51",
		},
	}}
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		collection: collectionStore,
		order:      orderStore,
	}}

	err := sfs.SalesforceLastInvoiceMonth(context.Background(), model.SfReqBody{
		Type:  model.Collection,
		Types: "collection",
	})
	if err != nil {
		t.Fatalf("SalesforceLastInvoiceMonth: %v", err)
	}
	if got := externalCRMRequests.Load(); got != 0 {
		t.Fatalf("external CRM requests = %d, want 0", got)
	}
	if len(collectionStore.updatedRecords) != 1 {
		t.Fatalf("local collection updates = %d, want 1", len(collectionStore.updatedRecords))
	}
	got := collectionStore.updatedRecords[0]
	if got.Order != "nexus-order-51" || got.OrderNumber != "NEXUS-ORDER-51" {
		t.Fatalf("resolved order = %q/%q, want NexusCRM order identity", got.Order, got.OrderNumber)
	}
	if got.CollectionID != "existing-collection-51" || got.CollectionNumber != "COLLECTION-51" {
		t.Fatalf("collection identity changed = %q/%q", got.CollectionID, got.CollectionNumber)
	}
	if got.CollectionStatus != "Open" || got.PayableAmount != "500.00" || got.CollectionsAmount != "125.00" {
		t.Fatalf("business fields changed: %+v", got)
	}
	if got.FileContent != base64.StdEncoding.EncodeToString([]byte(pdfBody)) {
		t.Fatalf("file_content = %q, want downloaded PDF base64", got.FileContent)
	}
	if got.Sync != 1 || got.SyncTime.IsZero() {
		t.Fatalf("local completion state = sync %d time %v, want sync=1 with sync_time", got.Sync, got.SyncTime)
	}
}

func TestSyncSingleSFFinalizesCollectionLocallyWithoutSalesforceCreate(t *testing.T) {
	var externalRequests atomic.Int32
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		externalRequests.Add(1)
		http.Error(w, "external CRM must not be called", http.StatusInternalServerError)
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	collectionStore := &fakeCloudCollectionStore{byID: model.CloudCollection{
		ID:                52,
		PayableDate:       "2026-07-01",
		ActualBillingDate: "2026-07-01",
		CollectionsDate:   "2026-07-02",
		CollectedDate:     "2026-07-02",
		BillMonth:         "2026-07",
		AdjustTenantID:    "tenant-52",
		AccountNumber:     "IBG-B-52",
		OrderNumber:       "source-order-52",
	}}
	orderStore := &fakeCloudOrderStore{byRef: map[string]model.CloudOrder{
		"source-order-52": {
			NewOrderID:     "nexus-order-52",
			NewOrderNumber: "NEXUS-ORDER-52",
		},
	}}
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		collection: collectionStore,
		order:      orderStore,
	}}

	result, err := sfs.SyncSingleSF(context.Background(), model.SfReqBody{
		Type:  model.Collection,
		Types: "collection",
		ID:    52,
	})
	if err != nil {
		t.Fatalf("SyncSingleSF: %v", err)
	}
	if result.Status != "synced" {
		t.Fatalf("result status = %q, want synced", result.Status)
	}
	if got := externalRequests.Load(); got != 0 {
		t.Fatalf("external CRM requests = %d, want 0", got)
	}
	if len(collectionStore.updatedRecords) != 1 || collectionStore.updatedRecords[0].Sync != 1 {
		t.Fatalf("local collection updates = %+v, want one sync=1 update", collectionStore.updatedRecords)
	}
}

func TestSyncSalesforceFinalizesRevrecLocallyBeforeCollectionBoundary(t *testing.T) {
	var externalRequests atomic.Int32
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		externalRequests.Add(1)
		http.Error(w, "external CRM must not be called", http.StatusInternalServerError)
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	revrecStore := &fakeCloudRevrecStore{records: []*model.CloudRevrec{{
		ID:             61,
		BillMonth:      GetLastMonth(),
		AdjustTenantID: "1372813089209260061",
		AccountNumber:  "1372813089209260061",
	}}}
	collectionListErr := errors.New("collection list boundary")
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		order:      &fakeCloudOrderStore{},
		revrec:     revrecStore,
		collection: &fakeCloudCollectionStore{listErr: collectionListErr},
	}}

	err := sfs.SyncSalesforce(context.Background())
	if !errors.Is(err, collectionListErr) {
		t.Fatalf("SyncSalesforce error = %v, want collection list boundary", err)
	}
	if len(revrecStore.updatedRecords) != 1 || revrecStore.updatedRecords[0].Sync != 1 {
		t.Fatalf("local revrec updates before boundary = %+v, want one sync=1 update", revrecStore.updatedRecords)
	}
	if got := externalRequests.Load(); got != 0 {
		t.Fatalf("external CRM requests = %d, want 0", got)
	}
}

func TestShouldSkipRevrecMainSyncSkipsAlreadySyncedRevrec(t *testing.T) {
	revrec := &model.CloudRevrec{
		Sync:           1,
		Type:           0,
		AccountNumber:  "IBG-B-20260304-003837",
		AdjustTenantID: "1372813089209251856",
	}

	if !shouldSkipRevrecMainSync(revrec) {
		t.Fatal("already synced revrec should be skipped")
	}
}

func TestBuildRevrecPayloadEstimatedWritesOnlyEstimatedAmount(t *testing.T) {
	revrec := &model.CloudRevrec{
		Date:                   "2026-04-30",
		BillingEndDate:         "2026-04-30",
		EstimatedRevenueAmount: "123.45",
		ActualRevenueAmount:    "",
		AdjustedRevenueAmount:  "123.45",
		AdjustedLakeAmount:     "7.89",
		AdjustedByocAmount:     "3.36",
		RevenueRecognitionType: "estimated",
		ExchangeRateToUse:      "1",
		CurrencyIsoCode:        "USD",
	}

	payload := buildRevrecPayload(revrec)
	body, err := json.Marshal(payload)
	if err != nil {
		t.Fatalf("marshal payload: %v", err)
	}
	bodyText := string(body)

	if !strings.Contains(bodyText, `"Estimated_Revenue_Amount__c":"123.45"`) {
		t.Fatalf("estimated payload = %s, want Estimated_Revenue_Amount__c", bodyText)
	}
	if strings.Contains(bodyText, `"Amount__c"`) {
		t.Fatalf("estimated payload = %s, must not write actual Amount__c", bodyText)
	}
	if !strings.Contains(bodyText, `"CurrencyIsoCode":"USD"`) {
		t.Fatalf("estimated payload = %s, want CurrencyIsoCode", bodyText)
	}
	if !strings.Contains(bodyText, `"Exchange_Rate_to_Use__c":"1"`) {
		t.Fatalf("estimated payload = %s, want exchange rate for USD formula", bodyText)
	}
	if !strings.Contains(bodyText, `"TiDB_Cloud_Lake_Amount_Raw__c":"7.89"`) {
		t.Fatalf("estimated payload = %s, want lake amount", bodyText)
	}
	if !strings.Contains(bodyText, `"TiDB_Cloud_BYOC_Amount_Raw__c":"3.36"`) {
		t.Fatalf("estimated payload = %s, want byoc amount", bodyText)
	}
}

func TestBuildRevrecPayloadActualWritesOnlyActualAmount(t *testing.T) {
	revrec := &model.CloudRevrec{
		Date:                         "2026-05-15",
		BillingEndDate:               "2026-05-15",
		BillMonth:                    "2026-04",
		EstimatedRevenueAmount:       "123.45",
		ActualRevenueAmount:          "120.00",
		AdjustedRevenueAmount:        "120.00",
		AdjustedLakeAmount:           "211.46",
		AdjustedByocAmount:           "3336.00",
		RevenueRecognitionType:       "actual",
		ActualRevenueRecognitionDate: "2026-05-15",
		ExchangeRateToUse:            "1",
		CurrencyIsoCode:              "USD",
	}

	payload := buildRevrecPayload(revrec)
	body, err := json.Marshal(payload)
	if err != nil {
		t.Fatalf("marshal payload: %v", err)
	}
	bodyText := string(body)

	if !strings.Contains(bodyText, `"Amount__c":"120.00"`) {
		t.Fatalf("actual payload = %s, want actual Amount__c", bodyText)
	}
	if strings.Contains(bodyText, `"Estimated_Revenue_Amount__c"`) {
		t.Fatalf("actual payload = %s, must not overwrite estimated amount", bodyText)
	}
	if !strings.Contains(bodyText, `"CurrencyIsoCode":"USD"`) {
		t.Fatalf("actual payload = %s, want CurrencyIsoCode", bodyText)
	}
	if !strings.Contains(bodyText, `"Billing_End_Date__c":"2026-04-30"`) {
		t.Fatalf("actual payload = %s, must keep billing end at bill month end", bodyText)
	}
	if !strings.Contains(bodyText, `"Exchange_Rate_to_Use__c":"1"`) {
		t.Fatalf("actual payload = %s, want exchange rate for formulas", bodyText)
	}
	if !strings.Contains(bodyText, `"TiDB_Cloud_Lake_Amount_Raw__c":"211.46"`) {
		t.Fatalf("actual payload = %s, want lake amount", bodyText)
	}
	if !strings.Contains(bodyText, `"TiDB_Cloud_BYOC_Amount_Raw__c":"3336.00"`) {
		t.Fatalf("actual payload = %s, want byoc amount", bodyText)
	}
}

func TestGetRevenueByOrderAndBillMonthUsesBillingEndDate(t *testing.T) {
	var gotQuery string
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gotQuery = r.URL.Query().Get("q")
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"a0T-existing","Name":"R-existing","LastModifiedDate":"2026-05-07T04:20:54.000+0000"}]}`))
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	id, name, err := getRevenueByOrderAndBillMonth(context.Background(), "801-existing", "2026-04")
	if err != nil {
		t.Fatalf("get existing revenue: %v", err)
	}
	if id != "a0T-existing" || name != "R-existing" {
		t.Fatalf("existing revenue = %q/%q, want a0T-existing/R-existing", id, name)
	}
	if !strings.Contains(gotQuery, "Order__c = '801-existing'") {
		t.Fatalf("query = %q, want Order__c filter", gotQuery)
	}
	if !strings.Contains(gotQuery, "Billing_End_Date__c = 2026-04-30") {
		t.Fatalf("query = %q, want bill month end billing filter", gotQuery)
	}
}

func TestGetRevenueByOrderAndBillMonthReturnsEmptyWhenNotFound(t *testing.T) {
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte(`{"totalSize":0,"done":true,"records":[]}`))
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	id, name, err := getRevenueByOrderAndBillMonth(context.Background(), "801-missing", "2026-04")
	if err != nil {
		t.Fatalf("get missing revenue: %v", err)
	}
	if id != "" || name != "" {
		t.Fatalf("missing revenue = %q/%q, want empty", id, name)
	}
}

func TestSfRevrecUpdatesWhenRevrecIDExists(t *testing.T) {
	var seenPatch bool
	var seenPost bool
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodPost {
			seenPost = true
		}
		if r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Revenue__c/a0T-existing" {
			seenPatch = true
			w.WriteHeader(http.StatusNoContent)
			return
		}
		http.Error(w, "unexpected request "+r.Method+" "+r.URL.Path, http.StatusBadRequest)
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	revrecStore := &fakeCloudRevrecStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{revrec: revrecStore}}
	revrec := &model.CloudRevrec{
		BillMonth:                    "2026-04",
		Date:                         "2026-05-18",
		BillingEndDate:               "2026-04-30",
		RevrecID:                     "a0T-existing",
		ActualRevenueAmount:          "120.00",
		AdjustedRevenueAmount:        "120.00",
		ActualRevenueRecognitionDate: "2026-05-18",
		RevenueRecognitionType:       "actual",
		CurrencyIsoCode:              "USD",
		ExchangeRateToUse:            "1",
	}

	if err := sfs.sfRevrec(context.Background(), revrec); err != nil {
		t.Fatalf("sfRevrec: %v", err)
	}
	if !seenPatch {
		t.Fatal("sfRevrec should PATCH existing Revenue__c when revrec_id is present")
	}
	if seenPost {
		t.Fatal("sfRevrec must not POST a duplicate Revenue__c when revrec_id is present")
	}
	if !revrecStore.updated {
		t.Fatal("sfRevrec should mark local revrec synced after update")
	}
}

func TestUpdateRevrecRejectsEmptyRevrecID(t *testing.T) {
	sfs := &salesforceService{store: &fakeSalesforceFactory{revrec: &fakeCloudRevrecStore{}}}
	revrec := &model.CloudRevrec{
		BillMonth:                    "2026-04",
		Date:                         "2026-05-18",
		BillingEndDate:               "2026-04-30",
		ActualRevenueAmount:          "120.00",
		ActualRevenueRecognitionDate: "2026-05-18",
		RevenueRecognitionType:       "actual",
	}

	err := sfs.updateRevrec(context.Background(), revrec)

	if err == nil || !strings.Contains(err.Error(), "without salesforce revrec id") {
		t.Fatalf("updateRevrec error = %v, want missing revrec id guard", err)
	}
}

func TestSfRevrecUpdatesExistingSalesforceRevenueByOrderAndBillMonth(t *testing.T) {
	var seenPatch bool
	var seenPost bool
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query":
			query := r.URL.Query().Get("q")
			if !strings.Contains(query, "Order__c = '801-existing'") || !strings.Contains(query, "Billing_End_Date__c = 2026-04-30") {
				http.Error(w, "bad lookup query: "+query, http.StatusBadRequest)
				return
			}
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"a0T-existing","Name":"R-existing","LastModifiedDate":"2026-05-07T04:20:54.000+0000"}]}`))
		case r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Revenue__c/a0T-existing":
			seenPatch = true
			w.WriteHeader(http.StatusNoContent)
		case r.Method == http.MethodPost:
			seenPost = true
			http.Error(w, "must not create duplicate", http.StatusBadRequest)
		default:
			http.Error(w, "unexpected request "+r.Method+" "+r.URL.Path, http.StatusBadRequest)
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	revrecStore := &fakeCloudRevrecStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{revrec: revrecStore}}
	revrec := &model.CloudRevrec{
		BillMonth:                    "2026-04",
		Date:                         "2026-05-18",
		BillingEndDate:               "2026-04-30",
		Type:                         1,
		Order:                        "801-existing",
		ActualRevenueAmount:          "120.00",
		AdjustedRevenueAmount:        "120.00",
		ActualRevenueRecognitionDate: "2026-05-18",
		RevenueRecognitionType:       "actual",
		CurrencyIsoCode:              "USD",
		ExchangeRateToUse:            "1",
	}

	if err := sfs.sfRevrec(context.Background(), revrec); err != nil {
		t.Fatalf("sfRevrec: %v", err)
	}
	if !seenPatch {
		t.Fatal("sfRevrec should PATCH existing Revenue__c found by order and bill month")
	}
	if seenPost {
		t.Fatal("sfRevrec must not POST when Salesforce already has Revenue__c for the order and bill month")
	}
	if revrec.RevrecID != "a0T-existing" || revrec.RevrecNumber != "R-existing" {
		t.Fatalf("revrec identity = %q/%q, want a0T-existing/R-existing", revrec.RevrecID, revrec.RevrecNumber)
	}
	if !revrecStore.updated {
		t.Fatal("sfRevrec should save the found Salesforce identity locally after update")
	}
}

func TestPrepareRevrecOrderUsesRevrecOrderNumberBeforeTenantFallback(t *testing.T) {
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{
		byRef: map[string]model.CloudOrder{
			"2026_04__ON_DEMAND__IBG_B_20260511_003983": {
				NewOrderID:     "801-correct",
				NewOrderNumber: "SO-correct",
			},
		},
		byTenant: model.CloudOrder{
			NewOrderID:     "801-old",
			NewOrderNumber: "SO-old",
		},
	}}}
	revrec := &model.CloudRevrec{
		Type:           0,
		BillMonth:      "2026-04",
		AdjustTenantID: "1372813089209321651",
		AccountNumber:  "IBG-B-20260511-003983",
		OrderNumber:    "2026_04__ON_DEMAND__IBG_B_20260511_003983",
		Order:          "2026_04__ON_DEMAND__IBG_B_20260511_003983",
	}

	if err := sfs.prepareRevrecOrderForSalesforce(context.Background(), revrec); err != nil {
		t.Fatalf("prepare revrec order: %v", err)
	}
	if revrec.Order != "801-correct" || revrec.OrderNumber != "SO-correct" {
		t.Fatalf("resolved order = %q/%q, want 801-correct/SO-correct", revrec.Order, revrec.OrderNumber)
	}
}

func TestPrepareRevrecOrderResolvesGeneratedPlaceholderByTenantAccount(t *testing.T) {
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{
		byTenantAccount: map[string]model.CloudOrder{
			"2026-05|1372813089209231180|IBG-B-20250603-002996": {
				NewOrderID:     "801RC00001YcSIYYA3",
				NewOrderNumber: "JP-OF-26060230",
			},
		},
		byTenant: model.CloudOrder{
			NewOrderID:     "801-wrong-tenant-only",
			NewOrderNumber: "JP-OF-wrong",
		},
	}}}
	revrec := &model.CloudRevrec{
		Type:           0,
		BillMonth:      "2026-05",
		AdjustTenantID: "1372813089209231180",
		AccountNumber:  "IBG-B-20250603-002996",
		OrderNumber:    "2026_05__ON_DEMAND__IBG_B_20250603_002996",
		Order:          "2026_05__ON_DEMAND__IBG_B_20250603_002996",
	}

	if err := sfs.prepareRevrecOrderForSalesforce(context.Background(), revrec); err != nil {
		t.Fatalf("prepare revrec order: %v", err)
	}
	if revrec.Order != "801RC00001YcSIYYA3" || revrec.OrderNumber != "JP-OF-26060230" {
		t.Fatalf("resolved order = %q/%q, want 801RC00001YcSIYYA3/JP-OF-26060230", revrec.Order, revrec.OrderNumber)
	}
}

func TestPrepareRevrecOrderDoesNotUseTenantOnlyFallbackWhenAccountPresent(t *testing.T) {
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{
		byTenant: model.CloudOrder{
			NewOrderID:     "801-wrong-tenant-only",
			NewOrderNumber: "JP-OF-wrong",
		},
	}}}
	revrec := &model.CloudRevrec{
		Type:           0,
		BillMonth:      "2026-05",
		AdjustTenantID: "1372813089209231180",
		AccountNumber:  "IBG-B-20250603-002996",
		OrderNumber:    "2026_05__ON_DEMAND__IBG_B_20250603_002996",
		Order:          "2026_05__ON_DEMAND__IBG_B_20250603_002996",
	}

	err := sfs.prepareRevrecOrderForSalesforce(context.Background(), revrec)
	if err == nil || !strings.Contains(err.Error(), "account IBG-B-20250603-002996") {
		t.Fatalf("prepare revrec order error = %v, want account-specific lookup failure", err)
	}
	if revrec.Order == "801-wrong-tenant-only" || revrec.OrderNumber == "JP-OF-wrong" {
		t.Fatal("tenant-only fallback must not be used when account number is present")
	}
}

func TestPrepareRevrecOrderRejectsUnsyncedOrder(t *testing.T) {
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{
		byRef: map[string]model.CloudOrder{
			"2026_04__ON_DEMAND__IBG_B_20260511_003983": {
				NewOrderNumber: "SO-unsynced",
			},
		},
	}}}
	revrec := &model.CloudRevrec{
		Type:           0,
		BillMonth:      "2026-04",
		AdjustTenantID: "1372813089209321651",
		AccountNumber:  "IBG-B-20260511-003983",
		OrderNumber:    "2026_04__ON_DEMAND__IBG_B_20260511_003983",
	}

	err := sfs.prepareRevrecOrderForSalesforce(context.Background(), revrec)
	if err == nil || !strings.Contains(err.Error(), "is not synced") {
		t.Fatalf("prepare revrec order error = %v, want unsynced order error", err)
	}
}

func TestCreateOrderPayloadUsesSalesforceCompatibleOrderFields(t *testing.T) {
	seenPost := false
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			seenPost = true
			var payload map[string]any
			if err := json.Unmarshal(body, &payload); err != nil {
				t.Fatalf("unmarshal order payload: %v body=%s", err, string(body))
			}
			if _, ok := payload["accountId"]; ok {
				t.Fatalf("order payload must use AccountId, got lowercase accountId: %s", string(body))
			}
			if got := payload["AccountId"]; got != "001-test" {
				t.Fatalf("AccountId = %v, want 001-test; body=%s", got, string(body))
			}
			if got := payload["Order_End_Date__c"]; got != "2026-07-23" {
				t.Fatalf("Order_End_Date__c = %v, want 2026-07-23; body=%s", got, string(body))
			}
			if _, ok := payload["TotalAmount"]; ok {
				t.Fatalf("TotalAmount is a NexusCRM rollup and must be omitted: %s", string(body))
			}
			if got := payload["PingCAP_RevRec_Entity__c"]; got != "PingCAP Pte. Ltd." {
				t.Fatalf("PingCAP_RevRec_Entity__c = %v, want PingCAP Pte. Ltd.; body=%s", got, string(body))
			}
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"801-new","Name":"HK-OF-26062302"}`))
		default:
			t.Fatalf("unexpected Salesforce request: %s %s body=%s", r.Method, r.URL.Path, string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	sfs := &salesforceService{}
	id, name, err := sfs.createOrder(context.Background(), &model.CloudOrder{
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		Tax:            "0",
		NetFee:         "123.45",
		AdjustTenantID: "tenant-1",
		RevrecEntity:   "PingCAP Pte. Ltd.",
	})
	if err != nil {
		t.Fatalf("createOrder: %v", err)
	}
	if !seenPost {
		t.Fatal("createOrder should POST an Order")
	}
	if id != "801-new" || name != "HK-OF-26062302" {
		t.Fatalf("created order identity = %q/%q, want 801-new/HK-OF-26062302", id, name)
	}
}

type orderItemTestAPI struct {
	t           *testing.T
	mu          sync.Mutex
	created     bool
	postCount   int
	orderID     string
	itemID      string
	accountID   string
	serviceDate string
	endDate     string
	netFee      string
}

func newOrderItemTestAPI(t *testing.T, orderID, accountID, serviceDate, endDate, netFee string) *orderItemTestAPI {
	return &orderItemTestAPI{
		t:           t,
		orderID:     orderID,
		itemID:      "802-new",
		accountID:   accountID,
		serviceDate: serviceDate,
		endDate:     endDate,
		netFee:      netFee,
	}
}

func (api *orderItemTestAPI) writeJSON(w http.ResponseWriter, status int, value interface{}) {
	api.t.Helper()
	body, err := json.Marshal(value)
	if err != nil {
		api.t.Fatalf("marshal test response: %v", err)
	}
	w.WriteHeader(status)
	_, _ = w.Write(body)
}

func (api *orderItemTestAPI) record() nexusCRMOrderItemRecord {
	return nexusCRMOrderItemRecord{
		ID:               api.itemID,
		OrderID:          api.orderID,
		PricebookEntryID: "01u-default",
		Quantity:         json.Number("1"),
		UnitPrice:        json.Number(api.netFee),
		ServiceDate:      api.serviceDate,
		EndDate:          api.endDate,
		NetFee:           json.Number(api.netFee),
		AccountID:        api.accountID,
	}
}

func (api *orderItemTestAPI) handle(w http.ResponseWriter, r *http.Request, body []byte) bool {
	api.t.Helper()
	if strings.Contains(r.URL.Path, "Order_Product__c") {
		api.t.Fatalf("legacy Order_Product__c endpoint must not be called: %s %s", r.Method, r.URL.Path)
	}
	if r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" {
		query := r.URL.Query().Get("q")
		switch {
		case strings.Contains(query, "FROM PricebookEntry"):
			api.writeJSON(w, http.StatusOK, nexusCRMPricebookEntryQuery{
				TotalSize: 1,
				Done:      true,
				Records:   []nexusCRMPricebookEntryRecord{{ID: "01u-default"}},
			})
			return true
		case strings.Contains(query, "FROM Order WHERE"):
			api.writeJSON(w, http.StatusOK, nexusCRMOrderScopeQuery{
				TotalSize: 1,
				Done:      true,
				Records: []nexusCRMOrderScopeRecord{{
					ID:              api.orderID,
					Pricebook2ID:    defaultPriceBook,
					CurrencyIsoCode: defaultCurrency,
				}},
			})
			return true
		case strings.Contains(query, "FROM OrderItem"):
			api.mu.Lock()
			defer api.mu.Unlock()
			result := nexusCRMOrderItemQuery{Done: true}
			if api.created {
				result.TotalSize = 1
				result.Records = []nexusCRMOrderItemRecord{api.record()}
			} else {
				result.Records = []nexusCRMOrderItemRecord{}
			}
			api.writeJSON(w, http.StatusOK, result)
			return true
		}
	}
	if r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/OrderItem" {
		if strings.Contains(string(body), "OrderProduct__c") || strings.Contains(string(body), "Order__c") {
			api.t.Fatalf("standard OrderItem payload must not contain legacy correlation fields: %s", string(body))
		}
		var request model.CreatedOrderItemReq
		if err := json.Unmarshal(body, &request); err != nil {
			api.t.Fatalf("decode OrderItem request: %v", err)
		}
		if request.OrderID != api.orderID || request.PricebookEntryID != "01u-default" ||
			request.Quantity != json.Number("1") || request.UnitPrice != json.Number(api.netFee) ||
			request.ServiceDate != api.serviceDate || request.EndDate != api.endDate ||
			request.NetFee != json.Number(api.netFee) || request.AccountID != api.accountID {
			api.t.Fatalf("OrderItem request = %+v, want standard fields for order %s", request, api.orderID)
		}
		api.mu.Lock()
		api.created = true
		api.postCount++
		api.mu.Unlock()
		api.writeJSON(w, http.StatusCreated, map[string]interface{}{"id": api.itemID, "success": true})
		return true
	}
	if r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/OrderItem/"+api.itemID {
		api.writeJSON(w, http.StatusOK, api.record())
		return true
	}
	return false
}

func TestOrderPayloadSourceAggregatesOnlyMatchingMonthTenantAndSourceRef(t *testing.T) {
	order := model.CloudOrder{
		ID:             10,
		BillMonth:      "2026-07",
		AdjustTenantID: "tenant-a",
		FakeNumber:     "source-1",
		NetFee:         "10.25",
	}
	orderStore := &fakeCloudOrderStore{byScopedRef: map[string][]model.CloudOrder{
		"2026-07|tenant-a|source-1": {
			order,
			{ID: 11, BillMonth: "2026-07", AdjustTenantID: "tenant-a", FakeNumber: "source-1", NetFee: "2.75"},
		},
		"2026-07|tenant-b|source-1": {
			{ID: 12, BillMonth: "2026-07", AdjustTenantID: "tenant-b", FakeNumber: "source-1", NetFee: "99.00"},
		},
	}}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}

	got, err := sfs.orderPayloadSource(context.Background(), order)
	if err != nil {
		t.Fatalf("orderPayloadSource: %v", err)
	}
	if got.NetFee != "13.00" {
		t.Fatalf("aggregated net fee = %q, want 13.00", got.NetFee)
	}
}

func TestFindSyncedOrderBySourceRefDoesNotReuseAnotherTenant(t *testing.T) {
	orderStore := &fakeCloudOrderStore{byRef: map[string]model.CloudOrder{
		"source-1": {
			ID:             99,
			BillMonth:      "2026-07",
			AdjustTenantID: "tenant-b",
			FakeNumber:     "source-1",
			NewOrderID:     "801-wrong-tenant",
		},
	}}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}
	order := &model.CloudOrder{ID: 10, BillMonth: "2026-07", AdjustTenantID: "tenant-a", FakeNumber: "source-1"}

	_, found, err := sfs.findSyncedOrderBySourceRef(context.Background(), order)
	if err != nil {
		t.Fatalf("findSyncedOrderBySourceRef: %v", err)
	}
	if found {
		t.Fatal("another tenant's CRM order must not be reused")
	}
}

func TestFindSyncedOrderBySourceRefSkipsCurrentUnsyncedRow(t *testing.T) {
	current := model.CloudOrder{ID: 10, BillMonth: "2026-07", AdjustTenantID: "tenant-a", FakeNumber: "source-1"}
	orderStore := &fakeCloudOrderStore{byScopedRef: map[string][]model.CloudOrder{
		"2026-07|tenant-a|source-1": {
			current,
			{ID: 11, BillMonth: "2026-07", AdjustTenantID: "tenant-a", FakeNumber: "source-1", NewOrderID: "801-existing"},
		},
	}}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}

	existing, found, err := sfs.findSyncedOrderBySourceRef(context.Background(), &current)
	if err != nil {
		t.Fatalf("findSyncedOrderBySourceRef: %v", err)
	}
	if !found || existing.NewOrderID != "801-existing" {
		t.Fatalf("existing = %#v, found = %t, want the synced sibling", existing, found)
	}
}

func TestSfOrderCreatesOrderItemAndActivatesOrder(t *testing.T) {
	seenOrderPost := false
	seenActivationPatch := false
	orderItemAPI := newOrderItemTestAPI(t, "801-new", "001-test", "2026-06-23", "2026-07-23", "1.00")
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if orderItemAPI.handle(w, r, body) {
			return
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			seenOrderPost = true
			if !strings.Contains(string(body), `"CurrencyIsoCode":"USD"`) {
				t.Fatalf("order body = %s, want CurrencyIsoCode=USD", string(body))
			}
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"801-new","Name":"HK-OF-26062302"}`))
		case r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			seenActivationPatch = true
			if !strings.Contains(string(body), `"Status":"Activated"`) {
				t.Fatalf("activation body = %s, want Status=Activated", string(body))
			}
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected Salesforce request: %s %s body=%s", r.Method, r.URL.Path, string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	orderStore := &fakeCloudOrderStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}
	order := &model.CloudOrder{
		AccountID:            "001-test",
		OrderStartDate:       "2026-06-23",
		OrderEndDate:         "2026-07-23",
		Tax:                  "0",
		AdjustTenantID:       "tenant-1",
		NetFee:               "1.00",
		NewOrderNumber:       "source-order-ref",
		IsNewSalesforceOrder: true,
	}
	result, err := sfs.sfOrder(context.Background(), order)
	if err != nil {
		t.Fatalf("sfOrder: %v", err)
	}
	if result.Status != "synced" || result.ActivationStatus != "activated" {
		t.Fatalf("result = %+v, want synced/activated", result)
	}
	if result.OrderID != "801-new" || result.OrderNumber != "HK-OF-26062302" || result.OrderItemID != "802-new" {
		t.Fatalf("result identity = %+v, want order/item ids and CRM order number", result)
	}
	if !seenOrderPost || orderItemAPI.postCount != 1 || !seenActivationPatch {
		t.Fatalf("seen order/item/activation = %v/%d/%v, want true/1/true", seenOrderPost, orderItemAPI.postCount, seenActivationPatch)
	}
	if !orderStore.updated || orderStore.updatedOrder.Sync != 1 {
		t.Fatalf("updated order = %+v, want sync=1 persisted", orderStore.updatedOrder)
	}
	if order.NewOrderID != "801-new" || order.NewOrderNumber != "HK-OF-26062302" {
		t.Fatalf("order identity = %q/%q, want 801-new/HK-OF-26062302", order.NewOrderID, order.NewOrderNumber)
	}
	if order.FakeNumber != "source-order-ref" {
		t.Fatalf("fake number = %q, want source-order-ref", order.FakeNumber)
	}
}

func TestSfOrderCanDeferActivationAfterOrderItemReadback(t *testing.T) {
	seenActivationPatch := false
	orderItemAPI := newOrderItemTestAPI(t, "801-new", "001-test", "2026-06-23", "2026-07-23", "1.00")
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if orderItemAPI.handle(w, r, body) {
			return
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"801-new","Name":"HK-OF-26062302"}`))
		case r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			seenActivationPatch = true
			t.Fatalf("deferred activation must not PATCH the Order")
		default:
			t.Fatalf("unexpected Salesforce request: %s %s body=%s", r.Method, r.URL.Path, string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	orderStore := &fakeCloudOrderStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}
	order := &model.CloudOrder{
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		Tax:            "0",
		AdjustTenantID: "tenant-1",
		NetFee:         "1.00",
		NewOrderNumber: "source-order-ref",
	}
	result, err := sfs.sfOrderWithActivation(context.Background(), order, true)
	if err != nil {
		t.Fatalf("sfOrderWithActivation: %v", err)
	}
	if result.Status != "created" || result.ActivationStatus != "deferred" || result.ReadyStatus != "order_item_ready" {
		t.Fatalf("result = %+v, want created/deferred/order_item_ready", result)
	}
	if result.OrderID != "801-new" || result.OrderNumber != "HK-OF-26062302" || result.OrderItemID != "802-new" {
		t.Fatalf("result identity = %+v, want order/item ids and CRM order number", result)
	}
	if result.ActivationAttempts != 0 || seenActivationPatch {
		t.Fatalf("activation attempts/patch = %d/%t, want 0/false", result.ActivationAttempts, seenActivationPatch)
	}
	if !orderStore.updated || orderStore.updatedOrder.Sync != 0 {
		t.Fatalf("deferred order = %+v, want persisted identity with sync=0", orderStore.updatedOrder)
	}
}

func TestEnsureOrderItemCreatesStandardObjectAndReadsBack(t *testing.T) {
	created := false
	createCount := 0
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		switch {
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(r.URL.Query().Get("q"), "FROM Order WHERE"):
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"801-new","Pricebook2Id":"01s5g000001cOA9AAM","CurrencyIsoCode":"USD"}]}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(r.URL.Query().Get("q"), "FROM PricebookEntry"):
			if !strings.Contains(r.URL.Query().Get("q"), "CurrencyIsoCode = 'USD'") {
				t.Fatalf("PricebookEntry query must be scoped to USD: %s", r.URL.Query().Get("q"))
			}
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"01u-default"}]}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(r.URL.Query().Get("q"), "FROM OrderItem"):
			w.WriteHeader(http.StatusOK)
			if !created {
				_, _ = w.Write([]byte(`{"totalSize":0,"done":true,"records":[]}`))
				return
			}
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"802-new","OrderId":"801-new","PricebookEntryId":"01u-default","Quantity":1,"UnitPrice":123.45,"ServiceDate":"2026-06-23","EndDate":"2026-07-23","Net_fees__c":123.45,"Account__c":"001-test","IsDeleted":false}]}`))
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/OrderItem":
			if strings.Contains(string(body), "OrderProduct__c") || strings.Contains(string(body), "Order__c") {
				t.Fatalf("standard OrderItem payload must not contain legacy correlation fields: %s", string(body))
			}
			for _, want := range []string{
				`"OrderId":"801-new"`,
				`"PricebookEntryId":"01u-default"`,
				`"Quantity":1`,
				`"UnitPrice":123.45`,
				`"ServiceDate":"2026-06-23"`,
				`"EndDate":"2026-07-23"`,
				`"Net_fees__c":123.45`,
				`"Account__c":"001-test"`,
			} {
				if !strings.Contains(string(body), want) {
					t.Fatalf("OrderItem body = %s, want %s", string(body), want)
				}
			}
			created = true
			createCount++
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"802-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/OrderItem/802-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"802-new","OrderId":"801-new","PricebookEntryId":"01u-default","Quantity":1,"UnitPrice":123.45,"ServiceDate":"2026-06-23","EndDate":"2026-07-23","Net_fees__c":123.45,"Account__c":"001-test","IsDeleted":false}`))
		case strings.Contains(r.URL.Path, "Order_Product__c"):
			t.Fatalf("legacy Order_Product__c endpoint must not be called: %s %s", r.Method, r.URL.Path)
		default:
			t.Fatalf("unexpected NexusCRM request: %s %s body=%s", r.Method, r.URL.String(), string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{}}}
	orderItemID, err := sfs.ensureOrderItem(context.Background(), &model.CloudOrder{
		NewOrderID:     "801-new",
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		NetFee:         "123.45",
	})
	if err != nil {
		t.Fatalf("ensureOrderItem: %v", err)
	}
	if orderItemID != "802-new" {
		t.Fatalf("OrderItem ID = %q, want 802-new", orderItemID)
	}
	retriedOrderItemID, err := sfs.ensureOrderItem(context.Background(), &model.CloudOrder{
		NewOrderID:     "801-new",
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		NetFee:         "123.45",
	})
	if err != nil {
		t.Fatalf("retry ensureOrderItem: %v", err)
	}
	if retriedOrderItemID != "802-new" || createCount != 1 {
		t.Fatalf("retry OrderItem ID/count = %q/%d, want 802-new/1", retriedOrderItemID, createCount)
	}
}

func TestEnsureOrderItemRejectsMismatchedExistingRow(t *testing.T) {
	orderItemAPI := newOrderItemTestAPI(t, "801-existing", "001-test", "2026-06-23", "2026-07-23", "999.00")
	orderItemAPI.created = true
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if !orderItemAPI.handle(w, r, body) {
			t.Fatalf("unexpected NexusCRM request: %s %s", r.Method, r.URL.String())
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{}}}
	_, err := sfs.ensureOrderItem(context.Background(), &model.CloudOrder{
		NewOrderID:     "801-existing",
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		NetFee:         "123.45",
	})
	if err == nil || !strings.Contains(err.Error(), "readback mismatch") {
		t.Fatalf("ensureOrderItem error = %v, want mismatched existing row rejection", err)
	}
	if orderItemAPI.postCount != 0 {
		t.Fatalf("OrderItem POST count = %d, want 0 for mismatched existing row", orderItemAPI.postCount)
	}
}

func TestEnsureOrderItemRejectsDuplicateRows(t *testing.T) {
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		query := r.URL.Query().Get("q")
		switch {
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(query, "FROM Order WHERE"):
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"801-existing","Pricebook2Id":"01s5g000001cOA9AAM","CurrencyIsoCode":"USD"}]}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(query, "FROM PricebookEntry"):
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"01u-default"}]}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(query, "FROM OrderItem"):
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":2,"done":true,"records":[{"Id":"802-one"},{"Id":"802-two"}]}`))
		case strings.Contains(r.URL.Path, "Order_Product__c"):
			t.Fatalf("legacy Order_Product__c endpoint must not be called: %s %s", r.Method, r.URL.Path)
		default:
			t.Fatalf("unexpected NexusCRM request: %s %s", r.Method, r.URL.String())
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{}}}
	_, err := sfs.ensureOrderItem(context.Background(), &model.CloudOrder{
		NewOrderID:     "801-existing",
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		NetFee:         "123.45",
	})
	if err == nil || !strings.Contains(err.Error(), "found 2 active NexusCRM OrderItems") {
		t.Fatalf("ensureOrderItem error = %v, want duplicate rejection", err)
	}
}

func TestSfOrderKeepsSyncRetryableWhenOrderItemCreateFails(t *testing.T) {
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		query := r.URL.Query().Get("q")
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"801-new","Name":"HK-OF-26062302"}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(query, "FROM Order WHERE"):
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"801-new","Pricebook2Id":"01s5g000001cOA9AAM","CurrencyIsoCode":"USD"}]}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(query, "FROM PricebookEntry"):
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":1,"done":true,"records":[{"Id":"01u-default"}]}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/query" && strings.Contains(query, "FROM OrderItem"):
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"totalSize":0,"done":true,"records":[]}`))
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/OrderItem":
			http.Error(w, "OrderItem validation failed", http.StatusBadRequest)
		case strings.Contains(r.URL.Path, "Order_Product__c"):
			t.Fatalf("legacy Order_Product__c endpoint must not be called: %s %s", r.Method, r.URL.Path)
		default:
			t.Fatalf("unexpected NexusCRM request: %s %s", r.Method, r.URL.String())
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	orderStore := &fakeCloudOrderStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}
	result, err := sfs.sfOrder(context.Background(), &model.CloudOrder{
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		Tax:            "0",
		AdjustTenantID: "tenant-1",
		NetFee:         "1.00",
		NewOrderNumber: "source-order-ref",
	})
	if err == nil {
		t.Fatal("sfOrder should return the OrderItem creation error")
	}
	if result == nil || result.OrderID != "801-new" {
		t.Fatalf("result = %+v, want persisted NexusCRM Order identity", result)
	}
	if !orderStore.updated || orderStore.updatedOrder.NewOrderID != "801-new" || orderStore.updatedOrder.Sync != 0 {
		t.Fatalf("failed OrderItem state = %+v, want identity persisted with sync=0", orderStore.updatedOrder)
	}
}

func TestSfOrderReturnsProcessingWhenActivationNotReady(t *testing.T) {
	var activationAttempts int
	orderItemAPI := newOrderItemTestAPI(t, "801-new", "001-test", "2026-06-23", "2026-07-23", "1.00")
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if orderItemAPI.handle(w, r, body) {
			return
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"801-new","Name":"HK-OF-26062302"}`))
		case r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			activationAttempts++
			http.Error(w, "crm flow fields are not ready", http.StatusBadRequest)
		default:
			t.Fatalf("unexpected Salesforce request: %s %s", r.Method, r.URL.Path)
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()
	restoreActivation := configureOrderActivationRetryTest(2, 0)
	defer restoreActivation()

	orderStore := &fakeCloudOrderStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}
	result, err := sfs.sfOrder(context.Background(), &model.CloudOrder{
		AccountID:      "001-test",
		OrderStartDate: "2026-06-23",
		OrderEndDate:   "2026-07-23",
		Tax:            "0",
		AdjustTenantID: "tenant-1",
		NetFee:         "1.00",
		NewOrderNumber: "source-order-ref",
	})
	if err != nil {
		t.Fatalf("sfOrder should return processing result instead of hard error: %v", err)
	}
	if result.Status != "processing" || result.ActivationStatus != "pending" || result.ReadyStatus != "pending" {
		t.Fatalf("result = %+v, want processing/pending", result)
	}
	if result.OrderID != "801-new" || result.OrderNumber != "HK-OF-26062302" || result.OrderItemID != "802-new" {
		t.Fatalf("result identity = %+v, want created CRM identity", result)
	}
	if activationAttempts != 2 || result.ActivationAttempts != 2 {
		t.Fatalf("activation attempts = server:%d result:%d, want 2", activationAttempts, result.ActivationAttempts)
	}
	if !orderStore.updated || orderStore.updatedOrder.Sync != 0 {
		t.Fatalf("activation-pending order = %+v, want persisted identity with sync=0", orderStore.updatedOrder)
	}
}

func TestSyncSingleSFReturnsOrderIdentityAndActivationResult(t *testing.T) {
	orderItemAPI := newOrderItemTestAPI(t, "801-new", "001-test", "2026-06-23", "2026-07-23", "1.00")
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if orderItemAPI.handle(w, r, body) {
			return
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"801-new","Name":"SG-26-00042"}`))
		case r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected Salesforce request: %s %s", r.Method, r.URL.Path)
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{
		byID: model.CloudOrder{
			ID:             42,
			AccountID:      "001-test",
			OrderStartDate: "2026-06-23",
			OrderEndDate:   "2026-07-23",
			Tax:            "0",
			AdjustTenantID: "tenant-1",
			NetFee:         "1.00",
			NewOrderNumber: "source-order-ref",
		},
	}}}

	result, err := sfs.SyncSingleSF(context.Background(), model.SfReqBody{Type: model.Order, Types: "order", ID: 42})
	if err != nil {
		t.Fatalf("SyncSingleSF: %v", err)
	}
	if result.Status != "synced" || result.OrderID != "801-new" || result.OrderNumber != "SG-26-00042" {
		t.Fatalf("result = %+v, want synced CRM order identity", result)
	}
	if result.OrderNumberSource != "crm_readback" || result.ActivationStatus != "activated" {
		t.Fatalf("result = %+v, want CRM readback source and activated status", result)
	}
}

func TestSyncSingleSFConcurrentSameSourceDoesNotCreateDuplicateOrder(t *testing.T) {
	var postCount atomic.Int32
	firstPostStarted := make(chan struct{})
	releaseFirstPost := make(chan struct{})
	orderItemAPI := newOrderItemTestAPI(t, "801-new", "001-test", "2026-06-23", "2026-07-23", "1.00")
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if orderItemAPI.handle(w, r, body) {
			return
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			if postCount.Add(1) == 1 {
				close(firstPostStarted)
				<-releaseFirstPost
			}
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Id":"801-new","Name":"HK-OF-26062302"}`))
		case r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected Salesforce request: %s %s", r.Method, r.URL.Path)
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	orderStore := &fakeCloudOrderStore{
		byID: model.CloudOrder{
			ID:             77,
			AccountID:      "001-test",
			OrderStartDate: "2026-06-23",
			OrderEndDate:   "2026-07-23",
			Tax:            "0",
			AdjustTenantID: "tenant-1",
			AccountNumber:  "acct-1",
			NetFee:         "1.00",
			NewOrderNumber: "source-order-ref",
		},
	}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}

	type callResult struct {
		result *model.SfSyncResult
		err    error
	}
	firstDone := make(chan callResult, 1)
	go func() {
		result, err := sfs.SyncSingleSF(context.Background(), model.SfReqBody{Type: model.Order, Types: "order", ID: 77})
		firstDone <- callResult{result: result, err: err}
	}()

	<-firstPostStarted
	secondResult, secondErr := sfs.SyncSingleSF(context.Background(), model.SfReqBody{Type: model.Order, Types: "order", ID: 77})
	close(releaseFirstPost)
	firstResult := <-firstDone

	if firstResult.err != nil {
		t.Fatalf("first SyncSingleSF: %v", firstResult.err)
	}
	if secondErr != nil {
		t.Fatalf("second SyncSingleSF should return processing, not error: %v", secondErr)
	}
	if firstResult.result.Status != "synced" {
		t.Fatalf("first result = %+v, want synced", firstResult.result)
	}
	if secondResult.Status != "processing" {
		t.Fatalf("second result = %+v, want processing while source ref is locked", secondResult)
	}
	if postCount.Load() != 1 {
		t.Fatalf("Salesforce order POST count = %d, want 1", postCount.Load())
	}
}

func TestSfOrderUpdatesExistingSalesforceOrderWhenOrderIDExists(t *testing.T) {
	seenPatch := false
	seenActivation := false
	seenPost := false
	orderItemAPI := newOrderItemTestAPI(t, "801-existing", "001-test", "2026-05-01", "2026-05-31", "456.78")
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if orderItemAPI.handle(w, r, body) {
			return
		}
		switch {
		case r.Method == http.MethodPatch && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-existing":
			if strings.Contains(string(body), `"Status":"Activated"`) {
				seenActivation = true
				w.WriteHeader(http.StatusNoContent)
				return
			}
			seenPatch = true
			if !strings.Contains(string(body), `"Tax__c":"10"`) {
				t.Fatalf("patch body = %s, want Tax__c", string(body))
			}
			if strings.Contains(string(body), `"TotalAmount"`) {
				t.Fatalf("patch body = %s, TotalAmount is a read-only NexusCRM rollup", string(body))
			}
			if !strings.Contains(string(body), `"Product_Family__c":"TiDB Cloud"`) {
				t.Fatalf("patch body = %s, want Product_Family__c", string(body))
			}
			if !strings.Contains(string(body), `"PingCAP_RevRec_Entity__c":"PingCAP Kabushiki-Kaisha"`) {
				t.Fatalf("patch body = %s, want PingCAP_RevRec_Entity__c", string(body))
			}
			w.WriteHeader(http.StatusNoContent)
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			seenPost = true
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		default:
			t.Fatalf("unexpected Salesforce request: %s %s body=%s", r.Method, r.URL.Path, string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	orderStore := &fakeCloudOrderStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{order: orderStore}}
	order := &model.CloudOrder{
		NewOrderID:     "801-existing",
		NewOrderNumber: "JP-OF-26050748",
		AccountID:      "001-test",
		OrderStartDate: "2026-05-01",
		OrderEndDate:   "2026-05-31",
		Tax:            "10",
		NetFee:         "456.78",
		RevrecEntity:   "PingCAP Kabushiki-Kaisha",
		Sync:           0,
	}

	if _, err := sfs.sfOrder(context.Background(), order); err != nil {
		t.Fatalf("sfOrder: %v", err)
	}
	if !seenPatch {
		t.Fatal("existing Salesforce order should be patched")
	}
	if !seenActivation {
		t.Fatal("existing Salesforce order should be activated after its OrderItem is ready")
	}
	if seenPost {
		t.Fatal("existing Salesforce order must not be created again")
	}
	if orderItemAPI.postCount != 1 {
		t.Fatalf("OrderItem POST count = %d, want 1", orderItemAPI.postCount)
	}
	if !orderStore.updated || orderStore.updatedOrder.Sync != 1 {
		t.Fatalf("updated order = %+v, want sync=1 persisted", orderStore.updatedOrder)
	}
}

func TestCreateOrderPayloadUsesNexusCRMCompatibleAccountId(t *testing.T) {
	var createBody string
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/order":
			createBody = string(body)
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"801-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Order/801-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Name":"SO-001"}`))
		default:
			t.Fatalf("unexpected Salesforce request: %s %s body=%s", r.Method, r.URL.Path, string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	sfs := &salesforceService{}
	id, name, err := sfs.createOrder(context.Background(), &model.CloudOrder{
		AccountID:      "001-account",
		OrderStartDate: "2026-04-01",
		OrderEndDate:   "2026-04-30",
		Tax:            "10",
	})
	if err != nil {
		t.Fatalf("createOrder: %v", err)
	}
	if id != "801-new" || name != "SO-001" {
		t.Fatalf("created order = %q/%q, want 801-new/SO-001", id, name)
	}
	if !strings.Contains(createBody, `"AccountId":"001-account"`) {
		t.Fatalf("create order body = %s, want AccountId for NexusCRM/Salesforce compatibility", createBody)
	}
	if strings.Contains(createBody, `"accountId"`) {
		t.Fatalf("create order body = %s, must not use lowercase accountId", createBody)
	}
}

func TestCreateCollectionUsesResolvedOrderAndNexusCRMSObjectShape(t *testing.T) {
	var createBody string
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/Invoice_Collection__c":
			createBody = string(body)
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"a1C-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Invoice_Collection__c/a1C-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Name":"IC-001"}`))
		default:
			t.Fatalf("unexpected Salesforce request: %s %s body=%s", r.Method, r.URL.Path, string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	sfs := &salesforceService{store: &fakeSalesforceFactory{order: &fakeCloudOrderStore{
		byRef: map[string]model.CloudOrder{
			"source-order": {
				NewOrderID:     "801-resolved",
				NewOrderNumber: "SO-001",
			},
		},
	}}}
	id, name, fileContent, err := sfs.createCollection(context.Background(), &model.CloudCollection{
		Type:              0,
		BillMonth:         "2026-04",
		AdjustTenantID:    "tenant-1",
		AccountNumber:     "IBG-B-1",
		Order:             "source-order",
		OrderNumber:       "source-order",
		PayableAmount:     "100.00",
		InvoiceNumber:     "INV-001",
		PayableDate:       "2026-04-10",
		ActualBillingDate: "2026-04-10",
		CollectionsDate:   "2026-04-12",
		CollectionStatus:  "Received",
		CollectionsAmount: "100.00",
	})
	if err != nil {
		t.Fatalf("createCollection: %v", err)
	}
	if id != "a1C-new" || name != "IC-001" {
		t.Fatalf("created collection = %q/%q, want a1C-new/IC-001", id, name)
	}
	if fileContent != nil {
		t.Fatalf("fileContent = %v, want nil without invoice PDF", fileContent)
	}
	for _, want := range []string{
		`"Order__c":"801-resolved"`,
		`"Payable_Amount__c":"100.00"`,
		`"Invoice_Number__c":"INV-001"`,
		`"CollectionsStatus__c":"Received"`,
		`"Invoice_Status__c":"Issued"`,
	} {
		if !strings.Contains(createBody, want) {
			t.Fatalf("create collection body = %s, want %s", createBody, want)
		}
	}
}

func TestSfCollectionHonorsCallerDeadlineWhileDownloadingInvoice(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		time.Sleep(200 * time.Millisecond)
		_, _ = w.Write([]byte("late invoice"))
	}))
	defer server.Close()

	collectionStore := &fakeCloudCollectionStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		collection: collectionStore,
		order:      &fakeCloudOrderStore{byTenant: model.CloudOrder{NewOrderID: "801-order"}},
	}}
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)
	defer cancel()

	startedAt := time.Now()
	err := sfs.sfCollection(ctx, &model.CloudCollection{
		BillMonth:      "2026-05",
		AdjustTenantID: "tenant-1",
		InvoiceNumber:  "INV-001",
		Files:          server.URL + "/invoice.pdf",
	})

	if err == nil {
		t.Fatal("sfCollection should return the caller deadline error")
	}
	if elapsed := time.Since(startedAt); elapsed > 150*time.Millisecond {
		t.Fatalf("sfCollection returned after %s, want it to honour the 30ms deadline", elapsed)
	}
	if collectionStore.updated {
		t.Fatal("timed-out collection must remain retryable")
	}
}

func TestSfCollectionAppliesDownloadTimeoutWithoutCallerDeadline(t *testing.T) {
	oldTimeout := collectionFileDownloadTimeout
	collectionFileDownloadTimeout = 30 * time.Millisecond
	t.Cleanup(func() {
		collectionFileDownloadTimeout = oldTimeout
	})

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		time.Sleep(200 * time.Millisecond)
		_, _ = w.Write([]byte("late invoice"))
	}))
	defer server.Close()

	collectionStore := &fakeCloudCollectionStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		collection: collectionStore,
		order:      &fakeCloudOrderStore{byTenant: model.CloudOrder{NewOrderID: "801-order"}},
	}}
	startedAt := time.Now()
	err := sfs.sfCollection(context.Background(), &model.CloudCollection{
		BillMonth:      "2026-05",
		AdjustTenantID: "tenant-1",
		InvoiceNumber:  "INV-001",
		Files:          server.URL + "/invoice.pdf",
	})

	if err == nil {
		t.Fatal("sfCollection should apply its download timeout")
	}
	if elapsed := time.Since(startedAt); elapsed > 150*time.Millisecond {
		t.Fatalf("sfCollection returned after %s, want the configured 30ms timeout", elapsed)
	}
	if collectionStore.updated {
		t.Fatal("timed-out collection must remain retryable")
	}
}

func TestSfCollectionRejectsOversizedInvoice(t *testing.T) {
	const maxInvoiceBytes = 20 << 20
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		_, _ = io.WriteString(w, strings.Repeat("x", maxInvoiceBytes+1))
	}))
	defer server.Close()

	collectionStore := &fakeCloudCollectionStore{}
	sfs := &salesforceService{store: &fakeSalesforceFactory{
		collection: collectionStore,
		order:      &fakeCloudOrderStore{byTenant: model.CloudOrder{NewOrderID: "801-order"}},
	}}
	err := sfs.sfCollection(context.Background(), &model.CloudCollection{
		BillMonth:      "2026-05",
		AdjustTenantID: "tenant-1",
		InvoiceNumber:  "INV-001",
		Files:          server.URL + "/invoice.pdf",
	})

	if err == nil || !strings.Contains(err.Error(), "byte limit") {
		t.Fatalf("sfCollection error = %v, want oversized invoice rejection", err)
	}
	if collectionStore.updated {
		t.Fatal("oversized collection must remain retryable")
	}
}

func TestSchedulePublicCollectionPayloadKeepsCurrencyIsoCode(t *testing.T) {
	var createBody string
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		switch {
		case r.Method == http.MethodPost && r.URL.Path == "/services/data/v59.0/sobjects/Invoice_Collection__c":
			createBody = string(body)
			w.WriteHeader(http.StatusCreated)
			_, _ = w.Write([]byte(`{"id":"a1C-new","success":true}`))
		case r.Method == http.MethodGet && r.URL.Path == "/services/data/v59.0/sobjects/Invoice_Collection__c/a1C-new":
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write([]byte(`{"Name":"IC-001"}`))
		default:
			t.Fatalf("unexpected Salesforce request: %s %s body=%s", r.Method, r.URL.Path, string(body))
		}
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	id, name, err := createCollection(context.Background(), &model.PublicCollection{
		OrderID:           "801-resolved",
		PayableAmount:     "100.00",
		PayableDate:       "2026-04-10",
		ActualBillingDate: "2026-04-10",
		CollectionsDate:   "2026-04-12",
		CollectionsAmount: "100.00",
		CollectionStatus:  "collected",
		InvoiceNumber:     "INV-001",
		CurrencyISOCode:   "USD",
		ExchangeRateToUse: "1",
	}, public, create)
	if err != nil {
		t.Fatalf("createCollection: %v", err)
	}
	if id != "a1C-new" || name != "IC-001" {
		t.Fatalf("created collection = %q/%q, want a1C-new/IC-001", id, name)
	}
	for _, want := range []string{
		`"Order__c":"801-resolved"`,
		`"Collections_Amount__c":"100.00"`,
		`"CurrencyIsoCode":"USD"`,
		`"Exchange_Rate_to_Use__c":"1"`,
	} {
		if !strings.Contains(createBody, want) {
			t.Fatalf("schedule collection body = %s, want %s", createBody, want)
		}
	}
}

func TestSendRequestRetriesWithFreshBody(t *testing.T) {
	const requestBody = `{"payload":true}`
	attempts := 0
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		attempts++
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if got := r.Header.Get("Authorization"); got != "Bearer test-token" {
			t.Fatalf("authorization header = %q", got)
		}
		if got := r.Header.Get("Content-Type"); got != "application/json" {
			t.Fatalf("content type = %q", got)
		}

		if attempts == 1 {
			if string(body) != requestBody {
				t.Fatalf("first attempt body = %q", string(body))
			}
			http.Error(w, "temporary salesforce edge failure", http.StatusInternalServerError)

			return
		}

		if string(body) != requestBody {
			http.Error(w, "retry body was not preserved", http.StatusBadRequest)

			return
		}
		w.WriteHeader(http.StatusCreated)
		_, _ = w.Write([]byte(`{"success":true}`))
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 2)
	defer restore()

	resp, err := sendRequest(context.Background(), "/sobjects/Order_Product__c", http.MethodPost, nil, []byte(requestBody))
	if err != nil {
		t.Fatalf("sendRequest should retry successfully: %v", err)
	}
	if attempts != 2 {
		t.Fatalf("attempts = %d, want 2", attempts)
	}
	if string(resp) != `{"success":true}` {
		t.Fatalf("response = %q", string(resp))
	}
}

func TestSendRequestUsesNexusCRMWhenConfigured(t *testing.T) {
	const requestBody = `{"payload":true}`
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if got := r.URL.Path; got != "/services/data/v63.0/sobjects/Order" {
			t.Fatalf("path = %q, want NexusCRM v63 Order path", got)
		}
		if got := r.Header.Get("Authorization"); got != "Bearer nexus-token" {
			t.Fatalf("authorization header = %q", got)
		}
		body, err := io.ReadAll(r.Body)
		if err != nil {
			t.Fatalf("read request body: %v", err)
		}
		if string(body) != requestBody {
			t.Fatalf("body = %q, want %q", string(body), requestBody)
		}

		w.WriteHeader(http.StatusCreated)
		_, _ = w.Write([]byte(`{"id":"nexus-order-id"}`))
	}))
	defer server.Close()
	restore := configureNexusCRMRequestTest(t, server, 1)
	defer restore()

	resp, err := sendRequestTo(context.Background(), targetNexusCRM, "/sobjects/Order", http.MethodPost, nil, []byte(requestBody))
	if err != nil {
		t.Fatalf("sendRequestTo should use NexusCRM successfully: %v", err)
	}
	if string(resp) != `{"id":"nexus-order-id"}` {
		t.Fatalf("response = %q", string(resp))
	}
}

func TestSendRequestReturnsRateLimitSentinelWithoutRetry(t *testing.T) {
	var attempts atomic.Int32
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		attempts.Add(1)
		w.WriteHeader(http.StatusTooManyRequests)
		_, _ = w.Write([]byte(`{"errorCode":"REQUEST_LIMIT_EXCEEDED","message":"Hourly API request limit exceeded"}`))
	}))
	defer server.Close()
	restore := configureNexusCRMRequestTest(t, server, 2)
	defer restore()

	_, err := sendRequestTo(context.Background(), targetNexusCRM, "/sobjects/Order", http.MethodPost, nil, []byte(`{"payload":true}`))
	if !errors.Is(err, errCRMRequestLimitExceeded) {
		t.Fatalf("error = %v, want CRM request-limit sentinel", err)
	}
	if attempts.Load() != 1 {
		t.Fatalf("attempts = %d, want one request after rate limit", attempts.Load())
	}
}

type fakeSalesforceFactory struct {
	revrec     store.CloudRevrecStore
	order      store.CloudOrderStore
	collection store.CloudCollectionStore
}

func (f *fakeSalesforceFactory) GetDB() *gorm.DB { return nil }
func (f *fakeSalesforceFactory) WebView() store.WebViewStore {
	return nil
}
func (f *fakeSalesforceFactory) CloudOrder() store.CloudOrderStore {
	return f.order
}
func (f *fakeSalesforceFactory) CloudRevrec() store.CloudRevrecStore {
	return f.revrec
}
func (f *fakeSalesforceFactory) CloudCollection() store.CloudCollectionStore {
	return f.collection
}
func (f *fakeSalesforceFactory) BqAccount() store.BqAccountStore {
	return nil
}
func (f *fakeSalesforceFactory) BqOrder() store.BqOrderStore {
	return nil
}
func (f *fakeSalesforceFactory) AuditLog() store.AuditLogStore {
	return nil
}
func (f *fakeSalesforceFactory) Salesforce() store.SalesforceStore {
	return nil
}
func (f *fakeSalesforceFactory) Common() store.CommonStore {
	return nil
}
func (f *fakeSalesforceFactory) ARTable() store.ARTableStore {
	return nil
}
func (f *fakeSalesforceFactory) MarketplaceCollection() store.MarketplaceCollectionStore {
	return nil
}
func (f *fakeSalesforceFactory) PublicCollection() store.PublicCollectionStore {
	return nil
}
func (f *fakeSalesforceFactory) InvoiceRewrite() store.InvoiceRewriteStore {
	return nil
}
func (f *fakeSalesforceFactory) NSRevRec() store.NSRevrecStore {
	return nil
}
func (f *fakeSalesforceFactory) ExamService() store.ExamServiceStore {
	return nil
}

type fakeCloudRevrecStore struct {
	updated        bool
	records        []*model.CloudRevrec
	updatedRecords []model.CloudRevrec
	updateErr      error
	byID           model.CloudRevrec
}

type fakeCloudCollectionStore struct {
	updated        bool
	records        []*model.CloudCollection
	updatedRecords []model.CloudCollection
	updateErr      error
	listErr        error
	byID           model.CloudCollection
}

func (s *fakeCloudCollectionStore) List(_ context.Context) ([]model.CloudCollection, error) {
	return nil, nil
}
func (s *fakeCloudCollectionStore) ListByMonth(_ context.Context, _ string, _ int) ([]*model.CloudCollection, error) {
	return s.records, s.listErr
}
func (s *fakeCloudCollectionStore) GetByID(_ context.Context, _ uint64) (model.CloudCollection, error) {
	return s.byID, nil
}
func (s *fakeCloudCollectionStore) DeleteAndSave(_ context.Context, records []model.CloudCollection) ([]model.CloudCollection, error) {
	return records, nil
}
func (s *fakeCloudCollectionStore) Update(_ context.Context, record *model.CloudCollection) error {
	s.updated = true
	if record != nil {
		s.updatedRecords = append(s.updatedRecords, *record)
	}
	return s.updateErr
}
func (s *fakeCloudCollectionStore) ListUncollected(_ context.Context) ([]*model.CloudCollection, error) {
	return nil, nil
}
func (s *fakeCloudCollectionStore) UpdateFields(_ context.Context, _ uint64, _ map[string]interface{}) error {
	return nil
}

func (s *fakeCloudRevrecStore) List(_ context.Context) ([]model.CloudRevrec, error) {
	return nil, nil
}
func (s *fakeCloudRevrecStore) ListByMonth(_ context.Context, _ string, _ int) ([]*model.CloudRevrec, error) {
	return s.records, nil
}
func (s *fakeCloudRevrecStore) DeleteAndSave(_ context.Context, records []model.CloudRevrec) ([]model.CloudRevrec, error) {
	return records, nil
}
func (s *fakeCloudRevrecStore) Update(_ context.Context, record *model.CloudRevrec) error {
	s.updated = true
	if record != nil {
		s.updatedRecords = append(s.updatedRecords, *record)
	}
	return s.updateErr
}
func (s *fakeCloudRevrecStore) GetByOrderID(_ context.Context, _ string) (model.CloudRevrec, error) {
	return model.CloudRevrec{}, nil
}
func (s *fakeCloudRevrecStore) GetByID(_ context.Context, _ uint64) (model.CloudRevrec, error) {
	return s.byID, nil
}
func (s *fakeCloudRevrecStore) UpdateRevrecs(_ []model.CloudRevrec) error {
	return nil
}
func (s *fakeCloudRevrecStore) GetByAdjustID(_ context.Context, _, _ string) (model.CloudRevrec, error) {
	return model.CloudRevrec{}, nil
}

type fakeCloudOrderStore struct {
	mu              sync.Mutex
	byRef           map[string]model.CloudOrder
	byScopedRef     map[string][]model.CloudOrder
	byTenantAccount map[string]model.CloudOrder
	byTenant        model.CloudOrder
	byID            model.CloudOrder
	locked          bool
	lockAttempts    int
	updated         bool
	updatedOrder    model.CloudOrder
}

func (s *fakeCloudOrderStore) List(_ context.Context) ([]model.CloudOrder, error) {
	return nil, nil
}
func (s *fakeCloudOrderStore) ListByMonth(_ context.Context, _ string, _ int) ([]*model.CloudOrder, error) {
	return nil, nil
}
func (s *fakeCloudOrderStore) ListByCondition(_ context.Context, _ uint64, _, _, _, _ string, _, _, _ int) ([]*model.CloudOrder, int64, error) {
	return nil, 0, nil
}
func (s *fakeCloudOrderStore) DeleteAndSave(_ context.Context, records []model.CloudOrder) ([]model.CloudOrder, error) {
	return records, nil
}
func (s *fakeCloudOrderStore) GetByFakeNumber(_ context.Context, fakeNumber string) (model.CloudOrder, error) {
	if s.byRef != nil {
		if order, ok := s.byRef[fakeNumber]; ok {
			return order, nil
		}
	}
	return model.CloudOrder{}, gorm.ErrRecordNotFound
}
func (s *fakeCloudOrderStore) GetBySourceRef(_ context.Context, billMonth, adjustTenantID, sourceRef string) (model.CloudOrder, error) {
	key := billMonth + "|" + adjustTenantID + "|" + sourceRef
	if records := s.byScopedRef[key]; len(records) > 0 {
		return records[0], nil
	}
	if order, ok := s.byRef[sourceRef]; ok && order.BillMonth == billMonth && order.AdjustTenantID == adjustTenantID {
		return order, nil
	}
	return model.CloudOrder{}, gorm.ErrRecordNotFound
}
func (s *fakeCloudOrderStore) ListBySourceRef(_ context.Context, billMonth, adjustTenantID, sourceRef string) ([]model.CloudOrder, error) {
	key := billMonth + "|" + adjustTenantID + "|" + sourceRef
	if records := s.byScopedRef[key]; len(records) > 0 {
		return records, nil
	}
	if order, ok := s.byRef[sourceRef]; ok && order.BillMonth == billMonth && order.AdjustTenantID == adjustTenantID {
		return []model.CloudOrder{order}, nil
	}
	return []model.CloudOrder{s.byID}, nil
}
func (s *fakeCloudOrderStore) GetByAdjustID(_ context.Context, _, _ string) (model.CloudOrder, error) {
	if s.byTenant.ID != 0 || s.byTenant.NewOrderID != "" || s.byTenant.NewOrderNumber != "" {
		return s.byTenant, nil
	}
	return model.CloudOrder{}, gorm.ErrRecordNotFound
}
func (s *fakeCloudOrderStore) GetByAdjustIDAndAccount(_ context.Context, adjustTenantID, billMonth, accountNumber string) (model.CloudOrder, error) {
	if s.byTenantAccount != nil {
		if order, ok := s.byTenantAccount[billMonth+"|"+adjustTenantID+"|"+accountNumber]; ok {
			return order, nil
		}
	}
	return model.CloudOrder{}, gorm.ErrRecordNotFound
}
func (s *fakeCloudOrderStore) GetByID(_ context.Context, _ uint64) (model.CloudOrder, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.byID.ID != 0 || s.byID.NewOrderID != "" || s.byID.NewOrderNumber != "" {
		return s.byID, nil
	}
	return model.CloudOrder{}, nil
}
func (s *fakeCloudOrderStore) TryLockByID(_ context.Context, _ uint64) (bool, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.lockAttempts++
	if s.locked {
		return false, nil
	}
	s.locked = true
	return true, nil
}
func (s *fakeCloudOrderStore) UnlockByID(_ context.Context, _ uint64) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.locked = false
	if s.byID.ID != 0 {
		s.byID.RowLock = false
	}
	return nil
}
func (s *fakeCloudOrderStore) Update(_ context.Context, order *model.CloudOrder) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.updated = true
	if order != nil {
		s.updatedOrder = *order
		if s.byID.ID == order.ID || s.byID.ID == 0 {
			s.byID = *order
		}
	}
	return nil
}
func (s *fakeCloudOrderStore) Delete(_ context.Context, _ uint64) error {
	return nil
}

func TestSendRequestReturnsErrorOnNon2xx(t *testing.T) {
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusBadRequest)
		_, _ = w.Write([]byte("<html>bad request</html>"))
	}))
	defer server.Close()
	restore := configureSalesforceRequestTest(t, server, 1)
	defer restore()

	_, err := sendRequest(context.Background(), "/sobjects/Order_Product__c", http.MethodPost, nil, []byte(`{"payload":true}`))
	if err == nil {
		t.Fatal("sendRequest should return an error for non-2xx responses")
	}
	if got := err.Error(); !strings.Contains(got, "code:400") || !strings.Contains(got, "<html>bad request</html>") {
		t.Fatalf("error = %q, want status code and body", got)
	}
}

func configureSalesforceRequestTest(t *testing.T, server *httptest.Server, attempts int) func() {
	t.Helper()

	oldClient := salesforceHTTPClient
	oldAttempts := salesforceRequestMaxAttempt
	oldDelay := salesforceRetryDelay
	oldDomain := viper.GetString("sf.domain")
	oldNexusDomain := viper.GetString("nexuscrm.domain")
	oldNexusCRMBaseURL := viper.GetString("nexuscrm.base_url")

	tokenCache.mutex.Lock()
	oldTokens := tokenCache.tokens
	tokenCache.tokens = map[string]*TokenInfo{
		"salesforce": {
			Token:  "test-token",
			Expiry: time.Now().Add(time.Hour),
		},
		// Order now targets NexusCRM; point it at the same mock server.
		"nexuscrm": {
			Token:  "test-token",
			Expiry: time.Now().Add(time.Hour),
		},
	}
	tokenCache.mutex.Unlock()

	salesforceHTTPClient = server.Client()
	salesforceRequestMaxAttempt = attempts
	salesforceRetryDelay = 0
	host := strings.TrimPrefix(server.URL, "https://")
	viper.Set("sf.domain", host)
	viper.Set("nexuscrm.domain", host)
	viper.Set("nexuscrm.base_url", "")

	return func() {
		salesforceHTTPClient = oldClient
		salesforceRequestMaxAttempt = oldAttempts
		salesforceRetryDelay = oldDelay
		viper.Set("sf.domain", oldDomain)
		viper.Set("nexuscrm.domain", oldNexusDomain)
		viper.Set("nexuscrm.base_url", oldNexusCRMBaseURL)
		tokenCache.mutex.Lock()
		tokenCache.tokens = oldTokens
		tokenCache.mutex.Unlock()
	}
}

func configureNexusCRMRequestTest(t *testing.T, server *httptest.Server, attempts int) func() {
	t.Helper()

	oldClient := salesforceHTTPClient
	oldAttempts := salesforceRequestMaxAttempt
	oldDelay := salesforceRetryDelay
	oldBaseURL := viper.GetString("nexuscrm.base_url")
	oldAPIVersion := viper.GetString("nexuscrm.api_version")

	tokenCache.mutex.Lock()
	oldTokens := tokenCache.tokens
	tokenCache.tokens = map[string]*TokenInfo{
		"nexuscrm": {
			Token:  "nexus-token",
			Expiry: time.Now().Add(time.Hour),
		},
	}
	tokenCache.mutex.Unlock()

	salesforceHTTPClient = server.Client()
	salesforceRequestMaxAttempt = attempts
	salesforceRetryDelay = 0
	viper.Set("nexuscrm.base_url", server.URL)
	viper.Set("nexuscrm.api_version", "v63.0")

	return func() {
		salesforceHTTPClient = oldClient
		salesforceRequestMaxAttempt = oldAttempts
		salesforceRetryDelay = oldDelay
		viper.Set("nexuscrm.base_url", oldBaseURL)
		viper.Set("nexuscrm.api_version", oldAPIVersion)
		tokenCache.mutex.Lock()
		tokenCache.tokens = oldTokens
		tokenCache.mutex.Unlock()
	}
}

func configureOrderActivationRetryTest(attempts int, delay time.Duration) func() {
	oldAttempts := orderActivationMaxAttempt
	oldDelay := orderActivationRetryDelay
	orderActivationMaxAttempt = attempts
	orderActivationRetryDelay = delay
	return func() {
		orderActivationMaxAttempt = oldAttempts
		orderActivationRetryDelay = oldDelay
	}
}