dice_test.go

package jsonstat

import (
	"errors"
	"slices"
	"testing"
)

// This file tests [Dataset.Dice], the single subsetting operation. Coverage:
//   - nil receiver
//   - empty/nil filter → deep clone
//   - keep-categories in default mode
//   - WithDropFilter(true) → remove-categories
//   - unknown dimension ID → ErrDimensionNotFound
//   - unknown category ID → ErrCategoryNotFound
//   - value store correctness after subset (dense and sparse sources)
//   - status store correctness after subset (array and object sources)
//   - preservation of dense/sparse value form
//   - multi-dimension filter
//   - filter that empties a dimension → N()==0

// --------------------------------------------------------------------------
// Receiver / filter edge cases
// --------------------------------------------------------------------------

func TestDiceNilReceiver(t *testing.T) {
	var ds *Dataset
	out, err := ds.Dice(nil)
	if err == nil {
		t.Fatalf("Dice on nil receiver: want error, got nil")
	}
	if !errors.Is(err, ErrDatasetNotFound) {
		t.Fatalf("err = %v, want wrapping ErrDatasetNotFound", err)
	}
	if out != nil {
		t.Fatalf("out = %v, want nil", out)
	}
}

func TestDiceEmptyFilterDeepClones(t *testing.T) {
	src := statusDS(t) // 6 cells, dense values, array status.
	out, err := src.Dice(nil)
	if err != nil {
		t.Fatalf("Dice(nil): %v", err)
	}
	if out == src {
		t.Fatalf("Dice(nil) returned the same pointer as src; want a clone")
	}
	if out.N() != src.N() {
		t.Fatalf("N = %d, want %d (deep clone should preserve N)", out.N(), src.N())
	}
	if !slices.Equal(out.Size, src.Size) {
		t.Fatalf("Size = %v, want %v", out.Size, src.Size)
	}
	// Mutating the clone must not affect the source.
	out.Label = "mutated-clone-label"
	if src.Label == "mutated-clone-label" {
		t.Fatalf("clone shares Label string with source")
	}
	if out.Label != "mutated-clone-label" {
		t.Fatalf("clone label not set")
	}
	// Empty (non-nil) filter behaves the same.
	out2, err := src.Dice(Filter{})
	if err != nil {
		t.Fatalf("Dice(Filter{}): %v", err)
	}
	if out2.N() != src.N() {
		t.Fatalf("Filter{}: N = %d, want %d", out2.N(), src.N())
	}
}

// --------------------------------------------------------------------------
// Keep-categories
// --------------------------------------------------------------------------

func TestDiceKeepCategories(t *testing.T) {
	src := statusDS(t)
	// status-array.json: dims metric(1) geo(2) time(3); values:
	// 0=POP/ES/2020, 1=POP/ES/2021, 2=POP/ES/2022(null), 3=POP/FR/2020,
	// 4=POP/FR/2021, 5=POP/FR/2022. Keep only geo=FR (drop ES).
	out, err := src.Dice(Filter{"geo": {"FR"}})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	// New cube: metric(1) × geo(1) × time(3) = 3 cells.
	if out.N() != 3 {
		t.Fatalf("N = %d, want 3", out.N())
	}
	if got := out.Size; !slices.Equal(got, []int{1, 1, 3}) {
		t.Fatalf("Size = %v, want [1 1 3]", got)
	}
	// geo dim should now contain only FR.
	geo, err := out.Dimension("geo")
	if err != nil {
		t.Fatalf("Dimension(geo): %v", err)
	}
	if len(geo.Categories) != 1 || geo.Categories[0].ID != "FR" {
		t.Fatalf("geo categories = %+v, want [FR]", geo.Categories)
	}
	// Original source values for FR were [3]=67.4M, [4]=67.5M, [5]=67.8M.
	want := []float64{67400000, 67500000, 67800000}
	for i, w := range want {
		c, err := out.CellByFlat(i)
		if err != nil {
			t.Fatalf("CellByFlat(%d): %v", i, err)
		}
		if c.Value != w {
			t.Errorf("flat %d value = %v, want %v", i, c.Value, w)
		}
		if c.Missing {
			t.Errorf("flat %d: Missing=true, want false", i)
		}
	}
	// Status preserves array form; the kept cells had statuses [a, p, p].
	wantStatus := []string{"a", "p", "p"}
	for i, w := range wantStatus {
		if got := out.status.at(i); got != w {
			t.Errorf("status.at(%d) = %q, want %q", i, got, w)
		}
	}
	if got := out.StatusFormat(); got != "array" {
		t.Errorf("StatusFormat = %q, want array (form preserved)", got)
	}
}

func TestDiceKeepCategoriesReordersToOriginalOrder(t *testing.T) {
	src := statusDS(t)
	// Ask for FR first, then ES — the output must still be in original order
	// (ES, FR), not in request order.
	out, err := src.Dice(Filter{"geo": {"FR", "ES"}})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	geo, _ := out.Dimension("geo")
	if len(geo.Categories) != 2 {
		t.Fatalf("geo categories len = %d, want 2", len(geo.Categories))
	}
	if geo.Categories[0].ID != "ES" || geo.Categories[1].ID != "FR" {
		t.Fatalf("geo order = [%s,%s], want [ES,FR]",
			geo.Categories[0].ID, geo.Categories[1].ID)
	}
}

// --------------------------------------------------------------------------
// Drop-categories
// --------------------------------------------------------------------------

func TestDiceDropCategories(t *testing.T) {
	src := statusDS(t)
	// Drop ES → keep FR.
	out, err := src.Dice(Filter{"geo": {"ES"}}, WithDropFilter(true))
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	if out.N() != 3 {
		t.Fatalf("N = %d, want 3", out.N())
	}
	geo, _ := out.Dimension("geo")
	if len(geo.Categories) != 1 || geo.Categories[0].ID != "FR" {
		t.Fatalf("geo categories = %+v, want [FR]", geo.Categories)
	}
	// Same value mapping as the keep-FR test.
	want := []float64{67400000, 67500000, 67800000}
	for i, w := range want {
		c, err := out.CellByFlat(i)
		if err != nil {
			t.Fatalf("CellByFlat(%d): %v", i, err)
		}
		if c.Value != w {
			t.Errorf("flat %d value = %v, want %v", i, c.Value, w)
		}
	}
}

// --------------------------------------------------------------------------
// Error paths
// --------------------------------------------------------------------------

func TestDiceFilterForUnknownDimensionIDIsIgnored(t *testing.T) {
	// A filter entry for a dimension ID not in d.ID is silently ignored:
	// resolveDiceFilter walks d.ID and only acts on keys it finds there. This
	// is the documented behaviour: dimensions absent from the filter are left
	// untouched, and "absent from the filter" includes "unknown to the cube".
	src := statusDS(t)
	out, err := src.Dice(Filter{"nope": {"x"}})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	if out.N() != src.N() {
		t.Errorf("N = %d, want %d (unknown dim should be ignored)", out.N(), src.N())
	}
}

func TestDiceNilDimensionInMapTriggersError(t *testing.T) {
	// The defensive ErrDimensionNotFound branch fires when a dimension ID
	// listed in d.ID has a nil entry in d.Dimensions. This is not reachable
	// through the normal public API (Decode/Builder always populate the
	// map) but is exercised here for coverage of the guard.
	src := statusDS(t)
	// Surgically null-out the geo entry while keeping "geo" in ID.
	delete(src.Dimensions, "geo")
	_, err := src.Dice(Filter{"geo": {"ES"}})
	if !errors.Is(err, ErrDimensionNotFound) {
		t.Fatalf("err = %v, want wrapping ErrDimensionNotFound", err)
	}
}

func TestDiceUnknownCategory(t *testing.T) {
	src := statusDS(t)
	_, err := src.Dice(Filter{"geo": {"DE"}}) // DE not in status-array.json.
	if !errors.Is(err, ErrCategoryNotFound) {
		t.Fatalf("err = %v, want wrapping ErrCategoryNotFound", err)
	}
}

// --------------------------------------------------------------------------
// Multi-dimension filter
// --------------------------------------------------------------------------

func TestDiceMultipleDimensions(t *testing.T) {
	src := statusDS(t)
	// Keep geo=FR AND time in {2020, 2022} → 2 cells.
	out, err := src.Dice(Filter{
		"geo":  {"FR"},
		"time": {"2020", "2022"},
	})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	// metric(1) × geo(1) × time(2) = 2.
	if out.N() != 2 {
		t.Fatalf("N = %d, want 2", out.N())
	}
	// New flat order: [POP/FR/2020, POP/FR/2022] → [67.4M, 67.8M].
	c0, _ := out.CellByFlat(0)
	if c0.Value != 67400000 {
		t.Errorf("flat 0 = %v, want 67400000", c0.Value)
	}
	c1, _ := out.CellByFlat(1)
	if c1.Value != 67800000 {
		t.Errorf("flat 1 = %v, want 67800000", c1.Value)
	}
}

// --------------------------------------------------------------------------
// Emptying a dimension
// --------------------------------------------------------------------------

func TestDiceEmptyingADimensionYieldsZeroN(t *testing.T) {
	src := statusDS(t)
	// Drop every geo category → empty cube.
	out, err := src.Dice(Filter{"geo": {"ES", "FR"}}, WithDropFilter(true))
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	if out.N() != 0 {
		t.Fatalf("N = %d, want 0", out.N())
	}
	// The dimension still exists, just with 0 categories.
	geo, err := out.Dimension("geo")
	if err != nil {
		t.Fatalf("Dimension(geo): %v", err)
	}
	if len(geo.Categories) != 0 {
		t.Fatalf("geo categories len = %d, want 0", len(geo.Categories))
	}
}

// --------------------------------------------------------------------------
// Value form preservation
// --------------------------------------------------------------------------

func TestDicePreservesDenseForm(t *testing.T) {
	src := statusDS(t) // dense.
	out, err := src.Dice(Filter{"time": {"2020"}})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	if got := out.ValueFormat(); got != "dense" {
		t.Errorf("ValueFormat = %q, want dense", got)
	}
}

func TestDicePreservesSparseForm(t *testing.T) {
	src := mustDataset(t, "sparse.json") // sparse values.
	if got := src.ValueFormat(); got != "sparse" {
		t.Fatalf("fixture sanity: ValueFormat = %q, want sparse", got)
	}
	out, err := src.Dice(Filter{})
	if err != nil {
		t.Fatalf("Dice(Filter{}): %v", err)
	}
	if got := out.ValueFormat(); got != "sparse" {
		t.Errorf("ValueFormat = %q, want sparse", got)
	}
	// A sparse clone should preserve every key/value the source had.
	for flat, v := range src.values.sparse_ {
		got, present := out.values.at(flat)
		if !present {
			t.Errorf("sparse value at %d: missing in clone", flat)
			continue
		}
		if got != v {
			t.Errorf("sparse value at %d: got %v, want %v", flat, got, v)
		}
	}
}

// --------------------------------------------------------------------------
// Missing cells survive a Dice
// --------------------------------------------------------------------------

func TestDicePreservesMissingCells(t *testing.T) {
	src := statusDS(t) // cell 2 (POP/ES/2022) is missing.
	out, err := src.Dice(Filter{"geo": {"ES"}})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	// New cube: metric(1) × geo(1) × time(3) = 3 cells.
	// ES values: [0]=47M, [1]=47.3M, [2]=null (missing).
	c2, err := out.CellByFlat(2)
	if err != nil {
		t.Fatalf("CellByFlat(2): %v", err)
	}
	if !c2.Missing {
		t.Errorf("flat 2 (POP/ES/2022): Missing=false, want true")
	}
	if c2.Value != 0 {
		t.Errorf("flat 2 value = %v, want 0 for missing cell", c2.Value)
	}
}

// --------------------------------------------------------------------------
// Status object form is preserved (oecd.json)
// --------------------------------------------------------------------------

func TestDicePreservesStatusObjectForm(t *testing.T) {
	src := oecdDS(t) // status in object form.
	if got := src.StatusFormat(); got != "object" {
		t.Fatalf("fixture sanity: StatusFormat = %q, want object", got)
	}
	// Keep the first concept only ("UNR"), keeping the cube small.
	out, err := src.Dice(Filter{"concept": {"UNR"}})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	if got := out.StatusFormat(); got != "object" {
		t.Errorf("StatusFormat = %q, want object (form preserved)", got)
	}
}

// --------------------------------------------------------------------------
// Receiver is not mutated
// --------------------------------------------------------------------------

func TestDiceDoesNotMutateReceiver(t *testing.T) {
	src := statusDS(t)
	origN := src.N()
	origGeo, _ := src.Dimension("geo")
	origGeoLen := len(origGeo.Categories)
	_, err := src.Dice(Filter{"geo": {"FR"}})
	if err != nil {
		t.Fatalf("Dice: %v", err)
	}
	if src.N() != origN {
		t.Errorf("receiver N mutated: got %d, want %d", src.N(), origN)
	}
	geo, _ := src.Dimension("geo")
	if len(geo.Categories) != origGeoLen {
		t.Errorf("receiver geo categories mutated: got %d, want %d",
			len(geo.Categories), origGeoLen)
	}
}