package db

import (
	"database/sql"
	"strings"
	"testing"
)

// setupValidationDB creates an in-memory DB with a complete test hierarchy.
//
//	dataset (structured):  ds_valtest00001
//	dataset (unstructured): ds_valtest00002
//	dataset (inactive):    ds_valtest00003
//	location in ds1:       loc_valtest0001
//	location in ds2:       loc_valtest0002
//	location (inactive):   loc_valtest0003  (in ds1)
//	cluster in loc1:       cl_valtest00001
//	cluster (inactive):    cl_valtest00002  (in loc1)
//	pattern:               pat_valtest0001
//	pattern (inactive):    pat_valtest0002
func setupValidationDB(t *testing.T) *sql.DB {
	t.Helper()
	database := SetupTestDB(t)

	InsertTestDatasetWithType(t, database, "ds_valtest00001", "Val Structured", "structured")
	InsertTestDatasetWithType(t, database, "ds_valtest00002", "Val Unstructured", "unstructured")
	InsertTestDatasetWithType(t, database, "ds_valtest00003", "Val Inactive", "structured")
	mustExec(t, database, "UPDATE dataset SET active = false WHERE id = 'ds_valtest00003'")

	InsertTestLocation(t, database, "loc_valtest0001", "ds_valtest00001", "Loc Active")
	InsertTestLocation(t, database, "loc_valtest0002", "ds_valtest00002", "Loc Unstructured")
	InsertTestLocation(t, database, "loc_valtest0003", "ds_valtest00001", "Loc Inactive")
	mustExec(t, database, "UPDATE location SET active = false WHERE id = 'loc_valtest0003'")

	InsertTestCluster(t, database, "cl_valtest00001", "ds_valtest00001", "loc_valtest0001", "Cl Active")
	InsertTestCluster(t, database, "cl_valtest00002", "ds_valtest00001", "loc_valtest0001", "Cl Inactive")
	mustExec(t, database, "UPDATE cluster SET active = false WHERE id = 'cl_valtest00002'")

	InsertTestPattern(t, database, "pat_valtest0001", 300, 600)
	InsertTestPattern(t, database, "pat_valtest0002", 60, 60)
	mustExec(t, database, "UPDATE cyclic_recording_pattern SET active = false WHERE id = 'pat_valtest0002'")

	return database
}

func mustExec(t *testing.T, database *sql.DB, query string) {
	t.Helper()
	if _, err := database.Exec(query); err != nil {
		t.Fatalf("exec %q: %v", query, err)
	}
}

// --- GetDatasetType ---

func TestGetDatasetType(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("existing structured dataset", func(t *testing.T) {
		dtype, exists, err := GetDatasetType(db, "ds_valtest00001")
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if !exists {
			t.Error("expected exists=true")
		}
		if dtype != "structured" {
			t.Errorf("got %q, want structured", dtype)
		}
	})

	t.Run("existing unstructured dataset", func(t *testing.T) {
		dtype, exists, err := GetDatasetType(db, "ds_valtest00002")
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if !exists {
			t.Error("expected exists=true")
		}
		if dtype != "unstructured" {
			t.Errorf("got %q, want unstructured", dtype)
		}
	})

	t.Run("nonexistent dataset", func(t *testing.T) {
		_, exists, err := GetDatasetType(db, "ds_nonexist00")
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if exists {
			t.Error("expected exists=false for nonexistent dataset")
		}
	})
}

// --- ValidateDatasetTypeForImport ---

func TestValidateDatasetTypeForImport(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("structured dataset passes", func(t *testing.T) {
		if err := ValidateDatasetTypeForImport(db, "ds_valtest00001"); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	})

	t.Run("unstructured dataset fails", func(t *testing.T) {
		err := ValidateDatasetTypeForImport(db, "ds_valtest00002")
		if err == nil || !strings.Contains(err.Error(), "only support 'structured'") {
			t.Errorf("expected structured-only error, got: %v", err)
		}
	})

	t.Run("nonexistent dataset fails", func(t *testing.T) {
		err := ValidateDatasetTypeForImport(db, "ds_nonexist00")
		if err == nil || !strings.Contains(err.Error(), "not found") {
			t.Errorf("expected not-found error, got: %v", err)
		}
	})
}

// --- ValidateDatasetTypeUnstructured ---

func TestValidateDatasetTypeUnstructured(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("unstructured dataset passes", func(t *testing.T) {
		if err := ValidateDatasetTypeUnstructured(db, "ds_valtest00002"); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	})

	t.Run("structured dataset fails", func(t *testing.T) {
		err := ValidateDatasetTypeUnstructured(db, "ds_valtest00001")
		if err == nil || !strings.Contains(err.Error(), "only supports 'unstructured'") {
			t.Errorf("expected unstructured-only error, got: %v", err)
		}
	})

	t.Run("nonexistent dataset fails", func(t *testing.T) {
		err := ValidateDatasetTypeUnstructured(db, "ds_nonexist00")
		if err == nil || !strings.Contains(err.Error(), "not found") {
			t.Errorf("expected not-found error, got: %v", err)
		}
	})
}

// --- ValidateLocationBelongsToDataset ---

func TestValidateLocationBelongsToDataset(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("location belongs to dataset", func(t *testing.T) {
		if err := ValidateLocationBelongsToDataset(db, "loc_valtest0001", "ds_valtest00001"); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	})

	t.Run("location belongs to different dataset", func(t *testing.T) {
		err := ValidateLocationBelongsToDataset(db, "loc_valtest0001", "ds_valtest00002")
		if err == nil || !strings.Contains(err.Error(), "does not belong") {
			t.Errorf("expected mismatch error, got: %v", err)
		}
	})

	t.Run("inactive location", func(t *testing.T) {
		err := ValidateLocationBelongsToDataset(db, "loc_valtest0003", "ds_valtest00001")
		if err == nil || !strings.Contains(err.Error(), "not found or inactive") {
			t.Errorf("expected inactive error, got: %v", err)
		}
	})

	t.Run("nonexistent location", func(t *testing.T) {
		err := ValidateLocationBelongsToDataset(db, "loc_nonexist00", "ds_valtest00001")
		if err == nil {
			t.Error("expected error for nonexistent location")
		}
	})
}

// --- DatasetExistsAndActive ---

func TestDatasetExistsAndActive(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("active dataset returns name", func(t *testing.T) {
		name, err := DatasetExistsAndActive(db, "ds_valtest00001")
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if name != "Val Structured" {
			t.Errorf("got %q, want Val Structured", name)
		}
	})

	t.Run("inactive dataset fails", func(t *testing.T) {
		_, err := DatasetExistsAndActive(db, "ds_valtest00003")
		if err == nil || !strings.Contains(err.Error(), "not active") {
			t.Errorf("expected not-active error, got: %v", err)
		}
	})

	t.Run("nonexistent dataset fails", func(t *testing.T) {
		_, err := DatasetExistsAndActive(db, "ds_nonexist00")
		if err == nil || !strings.Contains(err.Error(), "does not exist") {
			t.Errorf("expected does-not-exist error, got: %v", err)
		}
	})
}

// --- LocationBelongsToDataset ---

func TestLocationBelongsToDataset(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("active location in correct dataset", func(t *testing.T) {
		name, err := LocationBelongsToDataset(db, "loc_valtest0001", "ds_valtest00001")
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if name != "Loc Active" {
			t.Errorf("got %q, want Loc Active", name)
		}
	})

	t.Run("active location in wrong dataset", func(t *testing.T) {
		_, err := LocationBelongsToDataset(db, "loc_valtest0001", "ds_valtest00002")
		if err == nil || !strings.Contains(err.Error(), "does not belong") {
			t.Errorf("expected does-not-belong error, got: %v", err)
		}
	})

	t.Run("inactive location", func(t *testing.T) {
		_, err := LocationBelongsToDataset(db, "loc_valtest0003", "ds_valtest00001")
		if err == nil || !strings.Contains(err.Error(), "not active") {
			t.Errorf("expected not-active error, got: %v", err)
		}
	})

	t.Run("nonexistent location", func(t *testing.T) {
		_, err := LocationBelongsToDataset(db, "loc_nonexist00", "ds_valtest00001")
		if err == nil || !strings.Contains(err.Error(), "does not exist") {
			t.Errorf("expected does-not-exist error, got: %v", err)
		}
	})
}

// --- ClusterExistsAndActive ---

func TestClusterExistsAndActive(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("active cluster passes", func(t *testing.T) {
		if err := ClusterExistsAndActive(db, "cl_valtest00001"); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	})

	t.Run("inactive cluster fails", func(t *testing.T) {
		err := ClusterExistsAndActive(db, "cl_valtest00002")
		if err == nil || !strings.Contains(err.Error(), "not active") {
			t.Errorf("expected not-active error, got: %v", err)
		}
	})

	t.Run("nonexistent cluster fails", func(t *testing.T) {
		err := ClusterExistsAndActive(db, "cl_nonexist00")
		if err == nil || !strings.Contains(err.Error(), "not found") {
			t.Errorf("expected not-found error, got: %v", err)
		}
	})
}

// --- PatternExistsAndActive ---

func TestPatternExistsAndActive(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("active pattern passes", func(t *testing.T) {
		if err := PatternExistsAndActive(db, "pat_valtest0001"); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	})

	t.Run("inactive pattern fails", func(t *testing.T) {
		err := PatternExistsAndActive(db, "pat_valtest0002")
		if err == nil || !strings.Contains(err.Error(), "not active") {
			t.Errorf("expected not-active error, got: %v", err)
		}
	})

	t.Run("nonexistent pattern fails", func(t *testing.T) {
		err := PatternExistsAndActive(db, "pat_nonexist0")
		if err == nil || !strings.Contains(err.Error(), "does not exist") {
			t.Errorf("expected does-not-exist error, got: %v", err)
		}
	})
}

// --- LocationExistsAndActive ---

func TestLocationExistsAndActive(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("active location passes", func(t *testing.T) {
		if err := LocationExistsAndActive(db, "loc_valtest0001"); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	})

	t.Run("inactive location fails", func(t *testing.T) {
		err := LocationExistsAndActive(db, "loc_valtest0003")
		if err == nil || !strings.Contains(err.Error(), "not active") {
			t.Errorf("expected not-active error, got: %v", err)
		}
	})

	t.Run("nonexistent location fails", func(t *testing.T) {
		err := LocationExistsAndActive(db, "loc_nonexist00")
		if err == nil || !strings.Contains(err.Error(), "not found") {
			t.Errorf("expected not-found error, got: %v", err)
		}
	})
}

// --- ValidateDatasetTypeForExport ---

func TestValidateDatasetTypeForExport(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("structured active dataset passes", func(t *testing.T) {
		name, err := ValidateDatasetTypeForExport(db, "ds_valtest00001")
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if name != "Val Structured" {
			t.Errorf("got %q, want Val Structured", name)
		}
	})

	t.Run("unstructured dataset fails type check", func(t *testing.T) {
		_, err := ValidateDatasetTypeForExport(db, "ds_valtest00002")
		if err == nil || !strings.Contains(err.Error(), "only structured") {
			t.Errorf("expected structured-only error, got: %v", err)
		}
	})

	t.Run("inactive dataset fails", func(t *testing.T) {
		_, err := ValidateDatasetTypeForExport(db, "ds_valtest00003")
		if err == nil || !strings.Contains(err.Error(), "not active") {
			t.Errorf("expected not-active error, got: %v", err)
		}
	})

	t.Run("nonexistent dataset fails", func(t *testing.T) {
		_, err := ValidateDatasetTypeForExport(db, "ds_nonexist00")
		if err == nil || !strings.Contains(err.Error(), "does not exist") {
			t.Errorf("expected does-not-exist error, got: %v", err)
		}
	})
}

// --- ClusterBelongsToLocation ---

func TestClusterBelongsToLocation(t *testing.T) {
	db := setupValidationDB(t)
	defer db.Close()

	t.Run("cluster in correct location passes", func(t *testing.T) {
		if err := ClusterBelongsToLocation(db, "cl_valtest00001", "loc_valtest0001"); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	})

	t.Run("cluster in wrong location fails", func(t *testing.T) {
		err := ClusterBelongsToLocation(db, "cl_valtest00001", "loc_valtest0002")
		if err == nil || !strings.Contains(err.Error(), "does not belong") {
			t.Errorf("expected does-not-belong error, got: %v", err)
		}
	})

	t.Run("inactive cluster fails", func(t *testing.T) {
		err := ClusterBelongsToLocation(db, "cl_valtest00002", "loc_valtest0001")
		if err == nil || !strings.Contains(err.Error(), "not active") {
			t.Errorf("expected not-active error, got: %v", err)
		}
	})

	t.Run("nonexistent cluster fails", func(t *testing.T) {
		err := ClusterBelongsToLocation(db, "cl_nonexist00", "loc_valtest0001")
		if err == nil || !strings.Contains(err.Error(), "does not exist") {
			t.Errorf("expected does-not-exist error, got: %v", err)
		}
	})
}