package reports_test

import (
	"context"
	"errors"
	"testing"

	"ruben/inventory2/consts"
	"ruben/inventory2/domains/accounts"
	"ruben/inventory2/domains/reports"
	"ruben/inventory2/internal/testdb"
)

// createAmazonListing creates a listing with the given base count in
// shopID and registers its cleanup. Must be called after
// setupAmazonMockShop, so cleanup order (LIFO) deletes the listing before
// the shop it belongs to.
func createAmazonListing(t *testing.T, acctStore *accounts.Store, acctID int64, shopID string, baseCount int64) (listingID string) {
	t.Helper()
	ctx := context.Background()

	pool := testdb.Pool(t)

	listing, err := acctStore.CreateMockListing(ctx, accounts.MockListing{
		AccountShopListingIDs: accounts.AccountShopListingIDs{
			AccountShopIDs: accounts.AccountShopIDs{
				AccountIDs: accounts.AccountIDs{AccountID: acctID},
				Platform:   accounts.Amazon,
				ShopID:     shopID,
			},
		},
		SKU:         "test-sku",
		Name:        "Test Listing",
		Description: "a listing created for a test",
		Count:       baseCount,
	})
	if err != nil {
		t.Fatalf("CreateMockListing() error = %v", err)
	}

	t.Cleanup(func() {
		pool.Exec(context.Background(), `
			DELETE FROM mock.shop_amazon_listings WHERE shop_id = $1 AND listing_id = $2
		`, shopID, listing.ListingID)
	})

	return listing.ListingID
}

// TestGetListingCountsOverTime exercises the actual running-count logic,
// which lives in a recursive SQL view (mock.shop_amazon_listing_counts,
// built on mock.shop_amazon_listing_event_sequence) rather than in Go: it
// starts from the listing's base count and walks mock.raw_shop_events in
// order, applying each as a delta (sale/refund) or an absolute reset
// (inventory-reset). Uses the real SaveNewMock* methods to write those
// events, the same entry points the simulate-sale/refund/inventory UI
// uses, rather than hand-rolling the JSON payload shape.
func TestGetListingCountsOverTime(t *testing.T) {
	pool := testdb.Pool(t)
	acctStore := accounts.NewStore(testdb.Logger(), pool)
	reportsStore := reports.NewStore(testdb.Logger(), pool, acctStore)
	ctx := context.Background()

	acctID, shopID := setupAmazonMockShop(t, pool, acctStore)
	listingID := createAmazonListing(t, acctStore, acctID, shopID, 100)

	if _, err := acctStore.SaveNewMockSale(ctx, acctID, accounts.Amazon, shopID, listingID, 10); err != nil {
		t.Fatalf("SaveNewMockSale() error = %v", err)
	}
	if _, err := acctStore.SaveNewMockRefund(ctx, acctID, accounts.Amazon, shopID, listingID, 5); err != nil {
		t.Fatalf("SaveNewMockRefund() error = %v", err)
	}
	if _, err := acctStore.SaveNewMockInventoryReset(ctx, acctID, accounts.Amazon, shopID, listingID, 50); err != nil {
		t.Fatalf("SaveNewMockInventoryReset() error = %v", err)
	}

	got, err := reportsStore.GetListingCountsOverTime(ctx, acctID, accounts.Amazon, shopID, listingID)
	if err != nil {
		t.Fatalf("GetListingCountsOverTime() error = %v", err)
	}

	wantCounts := []int64{100, 110, 105, 50}
	if len(got) != len(wantCounts) {
		t.Fatalf("GetListingCountsOverTime() returned %d rows, want %d: %+v", len(got), len(wantCounts), got)
	}

	if got[0].EventTimestamp != nil {
		t.Errorf("got[0].EventTimestamp = %v, want nil (the base count row)", got[0].EventTimestamp)
	}
	for i, row := range got {
		if row.Count != wantCounts[i] {
			t.Errorf("got[%d].Count = %d, want %d (full sequence: %+v)", i, row.Count, wantCounts[i], got)
		}
	}
	for i := 1; i < len(got); i++ {
		if got[i].EventTimestamp == nil {
			t.Errorf("got[%d].EventTimestamp = nil, want set (only the base row should be nil)", i)
		}
	}
}

func TestGetListingCountsOverTime_UnknownListing(t *testing.T) {
	pool := testdb.Pool(t)
	acctStore := accounts.NewStore(testdb.Logger(), pool)
	reportsStore := reports.NewStore(testdb.Logger(), pool, acctStore)
	ctx := context.Background()

	acctID, shopID := setupAmazonMockShop(t, pool, acctStore)

	_, err := reportsStore.GetListingCountsOverTime(ctx, acctID, accounts.Amazon, shopID, "no-such-listing")
	if !errors.Is(err, consts.ErrNotFound) {
		t.Fatalf("GetListingCountsOverTime() error = %v, want %v", err, consts.ErrNotFound)
	}
}

func TestGetListingCountsReport(t *testing.T) {
	pool := testdb.Pool(t)
	acctStore := accounts.NewStore(testdb.Logger(), pool)
	reportsStore := reports.NewStore(testdb.Logger(), pool, acctStore)
	ctx := context.Background()

	acctID, shopID := setupAmazonMockShop(t, pool, acctStore)
	listingID := createAmazonListing(t, acctStore, acctID, shopID, 100)

	if _, err := acctStore.SaveNewMockSale(ctx, acctID, accounts.Amazon, shopID, listingID, 10); err != nil {
		t.Fatalf("SaveNewMockSale() error = %v", err)
	}
	if _, err := acctStore.SaveNewMockInventoryReset(ctx, acctID, accounts.Amazon, shopID, listingID, 20); err != nil {
		t.Fatalf("SaveNewMockInventoryReset() error = %v", err)
	}

	report, err := reportsStore.GetListingCountsReport(ctx, acctID, accounts.Amazon, shopID, listingID)
	if err != nil {
		t.Fatalf("GetListingCountsReport() error = %v", err)
	}

	if report.AccountID != acctID || report.Platform != accounts.Amazon || report.ShopID != shopID || report.ListingID != listingID {
		t.Errorf("report identity = %+v, want AccountID=%d Platform=%s ShopID=%s ListingID=%s",
			report, acctID, accounts.Amazon, shopID, listingID)
	}

	// counts over the sequence: 100 (base) -> 110 (sale +10) -> 20 (reset)
	if got := report.MaxCount().Count; got != 110 {
		t.Errorf("MaxCount().Count = %d, want 110", got)
	}
	if got := report.MinCount().Count; got != 20 {
		t.Errorf("MinCount().Count = %d, want 20", got)
	}
}