relspecgo/pkg/writers/pgsql/migration_writer_test.go

package pgsql

import (
	"bytes"
	"strings"
	"testing"

	"git.warky.dev/wdevs/relspecgo/pkg/models"
	"git.warky.dev/wdevs/relspecgo/pkg/writers"
)

func TestWriteMigration_NewTable(t *testing.T) {
	// Current database (empty)
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	// Model database (with new table)
	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("users", "public")
	idCol := models.InitColumn("id", "users", "public")
	idCol.Type = "integer"
	idCol.NotNull = true
	table.Columns["id"] = idCol

	nameCol := models.InitColumn("name", "users", "public")
	nameCol.Type = "text"
	table.Columns["name"] = nameCol

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	// Generate migration
	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	err = writer.WriteMigration(model, current)
	if err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	t.Logf("Generated migration:\n%s", output)

	// Verify CREATE TABLE is present
	if !strings.Contains(output, "CREATE TABLE") {
		t.Error("Migration missing CREATE TABLE statement")
	}
	if !strings.Contains(output, "users") {
		t.Error("Migration missing table name 'users'")
	}
}

func TestWriteMigration_ArrayDefault(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("plans", "public")

	tagsCol := models.InitColumn("tags", "plans", "public")
	tagsCol.Type = "text[]"
	tagsCol.NotNull = true
	tagsCol.Default = "''{}''"
	table.Columns["tags"] = tagsCol

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	err = writer.WriteMigration(model, current)
	if err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "tags text[] DEFAULT '{}' NOT NULL") {
		t.Fatalf("expected normalized array default in migration, got:\n%s", output)
	}
	if strings.Contains(output, "'''{}'''") {
		t.Fatalf("migration still contains triple-quoted array default:\n%s", output)
	}
}

func TestWriteMigration_AltersColumnTypeWhenActualTypeDiffers(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("learnings", "public")
	currentDetails := models.InitColumn("details", "learnings", "public")
	currentDetails.Type = "jsonb"
	currentTable.Columns["details"] = currentDetails
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("learnings", "public")
	modelDetails := models.InitColumn("details", "learnings", "public")
	modelDetails.Type = "text"
	modelTable.Columns["details"] = modelDetails
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "ALTER TABLE public.learnings") || !strings.Contains(output, "ALTER COLUMN details TYPE text") {
		t.Fatalf("expected migration to alter mismatched column type, got:\n%s", output)
	}
	if !strings.Contains(output, `ALTER COLUMN details TYPE text USING details::text;`) {
		t.Fatalf("expected migration type alter to include USING cast, got:\n%s", output)
	}
}

func TestWriteMigration_AltersColumnTypeFallsBackToRenameAndAddOnConversionFailure(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("learnings", "public")
	currentDetails := models.InitColumn("details", "learnings", "public")
	currentDetails.Type = "varchar(50)"
	currentTable.Columns["details"] = currentDetails
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("learnings", "public")
	modelDetails := models.InitColumn("details", "learnings", "public")
	modelDetails.Type = "integer"
	modelTable.Columns["details"] = modelDetails
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "EXCEPTION WHEN OTHERS THEN") {
		t.Fatalf("expected migration to guard the type conversion with an exception handler, got:\n%s", output)
	}
	if !strings.Contains(output, "RENAME COLUMN details TO %I") {
		t.Fatalf("expected migration to rename the old column (derived from the live type) on conversion failure, got:\n%s", output)
	}
	if !strings.Contains(output, "renamed_column := 'details_' || trim(both '_' from regexp_replace(lower(current_type)") {
		t.Fatalf("expected migration to derive the renamed column name from the live type, got:\n%s", output)
	}
	if !strings.Contains(output, "ADD COLUMN details integer") {
		t.Fatalf("expected migration to add a fresh column with the new type on conversion failure, got:\n%s", output)
	}
}

func TestWriteMigration_AltersColumnNullabilityWhenNotNullDiffers(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("service_instance", "public")
	currentType := models.InitColumn("rid_service_instance_type", "service_instance", "public")
	currentType.Type = "text"
	currentType.NotNull = true
	currentTable.Columns["rid_service_instance_type"] = currentType
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("service_instance", "public")
	modelType := models.InitColumn("rid_service_instance_type", "service_instance", "public")
	modelType.Type = "text"
	modelType.NotNull = false
	modelTable.Columns["rid_service_instance_type"] = modelType
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "ALTER COLUMN rid_service_instance_type DROP NOT NULL") {
		t.Fatalf("expected migration to drop NOT NULL on existing column, got:\n%s", output)
	}
}

func TestWriteMigration_DoesNotDropDefaultOnGeneratedColumn(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("info_city", "public")
	currentGeom := models.InitColumn("geom", "info_city", "public")
	currentGeom.Type = "text"
	currentGeom.Generated = true
	currentGeom.GenerationExpression = "st_makepoint(lon, lat)"
	currentTable.Columns["geom"] = currentGeom
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("info_city", "public")
	modelGeom := models.InitColumn("geom", "info_city", "public")
	modelGeom.Type = "text"
	// DBML cannot express GENERATED ALWAYS columns, so the model declares
	// this as a plain column with no default — it must not be treated as a
	// default-value drift against the DB-side generated column.
	modelTable.Columns["geom"] = modelGeom
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if strings.Contains(output, "DROP DEFAULT") {
		t.Fatalf("did not expect DROP DEFAULT against a generated column, got:\n%s", output)
	}
}

func TestWriteMigration_DoesNotAlterIdentityColumn(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("users", "public")
	currentID := models.InitColumn("id", "users", "public")
	currentID.Type = "bigint"
	currentID.NotNull = true
	currentID.Identity = true
	currentID.IdentityGeneration = "ALWAYS"
	currentTable.Columns["id"] = currentID
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("users", "public")
	modelID := models.InitColumn("id", "users", "public")
	modelID.Type = "bigint"
	// DBML cannot express GENERATED ... AS IDENTITY, so the model declares this
	// as a plain nullable column — it must not be diffed as NOT NULL drift
	// against the DB-side identity column (Postgres rejects DROP NOT NULL on
	// an identity column).
	modelID.NotNull = false
	modelTable.Columns["id"] = modelID
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if strings.Contains(output, "DROP NOT NULL") {
		t.Fatalf("did not expect DROP NOT NULL against an identity column, got:\n%s", output)
	}
}

func TestWriteMigration_UsesStorageTypeForSerialAlterStatements(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("learnings", "public")
	currentID := models.InitColumn("id", "learnings", "public")
	currentID.Type = "uuid"
	currentTable.Columns["id"] = currentID
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("learnings", "public")
	modelID := models.InitColumn("id", "learnings", "public")
	modelID.Type = "bigserial"
	modelTable.Columns["id"] = modelID
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "ALTER COLUMN id TYPE bigint") {
		t.Fatalf("expected serial alter to use bigint storage type, got:\n%s", output)
	}
	if strings.Contains(output, "ALTER COLUMN id TYPE bigserial;") {
		t.Fatalf("did not expect invalid bigserial alter statement, got:\n%s", output)
	}
	if !strings.Contains(output, `ALTER COLUMN id TYPE bigint USING id::bigint;`) {
		t.Fatalf("expected serial alter to include USING cast, got:\n%s", output)
	}
}

func TestWriteMigration_ArrayAlterIncludesUsingCast(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("learnings", "public")
	currentTags := models.InitColumn("tags", "learnings", "public")
	currentTags.Type = "text"
	currentTable.Columns["tags"] = currentTags
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("learnings", "public")
	modelTags := models.InitColumn("tags", "learnings", "public")
	modelTags.Type = "text[]"
	modelTable.Columns["tags"] = modelTags
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, `ALTER COLUMN tags TYPE text[] USING tags::text[];`) {
		t.Fatalf("expected array alter to include USING cast, got:\n%s", output)
	}
}

func TestWriteMigration_DoesNotAlterEquivalentNormalizedColumnType(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	currentTable := models.InitTable("users", "public")
	currentEmail := models.InitColumn("email", "users", "public")
	currentEmail.Type = "character varying"
	currentEmail.Length = 255
	currentTable.Columns["email"] = currentEmail
	currentSchema.Tables = append(currentSchema.Tables, currentTable)
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")
	modelTable := models.InitTable("users", "public")
	modelEmail := models.InitColumn("email", "users", "public")
	modelEmail.Type = "varchar(255)"
	modelTable.Columns["email"] = modelEmail
	modelSchema.Tables = append(modelSchema.Tables, modelTable)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if strings.Contains(output, "ALTER COLUMN email TYPE") {
		t.Fatalf("did not expect alter type for equivalent normalized types, got:\n%s", output)
	}
}

func TestWriteMigration_ConcurrentIndex(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("articles", "public")
	titleCol := models.InitColumn("title", "articles", "public")
	titleCol.Type = "text"
	table.Columns["title"] = titleCol

	index := &models.Index{
		Name:       "idx_articles_title",
		Columns:    []string{"title"},
		Concurrent: true,
	}
	table.Indexes[index.Name] = index

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "CREATE INDEX CONCURRENTLY IF NOT EXISTS") {
		t.Fatalf("expected CONCURRENTLY create index statement, got:\n%s", output)
	}
}

func TestWriteMigration_GinIndexOnTextUsesTrigramOperatorClass(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("articles", "public")
	titleCol := models.InitColumn("title", "articles", "public")
	titleCol.Type = "text"
	table.Columns["title"] = titleCol

	index := &models.Index{
		Name:    "idx_articles_title_gin",
		Type:    "gin",
		Columns: []string{"title"},
	}
	table.Indexes[index.Name] = index

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "CREATE EXTENSION IF NOT EXISTS pg_trgm;") {
		t.Fatalf("expected trigram extension for text GIN migration index, got:\n%s", output)
	}
	if !strings.Contains(output, "USING gin (title gin_trgm_ops)") {
		t.Fatalf("expected GIN text index to include gin_trgm_ops, got:\n%s", output)
	}
}

func TestWriteMigration_GinIndexOnQuotedTextColumnUsesTrigramOperatorClass(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("agent_personas", "public")
	nameCol := models.InitColumn("name", "agent_personas", "public")
	nameCol.Type = "text"
	table.Columns["name"] = nameCol

	index := &models.Index{
		Name:    "idx_agent_personas_name_gin",
		Type:    "gin",
		Columns: []string{`"name"`},
	}
	table.Indexes[index.Name] = index

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "USING gin (name gin_trgm_ops)") {
		t.Fatalf("expected quoted text column GIN index to include gin_trgm_ops, got:\n%s", output)
	}
}

func TestWriteMigration_GinIndexOnTextArrayDoesNotUseTrigramOperatorClass(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("plans", "public")
	tagsCol := models.InitColumn("tags", "plans", "public")
	tagsCol.Type = "text[]"
	table.Columns["tags"] = tagsCol

	index := &models.Index{
		Name:    "idx_plans_tags",
		Type:    "gin",
		Columns: []string{"tags"},
	}
	table.Indexes[index.Name] = index

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "USING gin (tags array_ops)") {
		t.Fatalf("expected GIN array index with array_ops, got:\n%s", output)
	}
	if strings.Contains(output, "gin_trgm_ops") {
		t.Fatalf("did not expect gin_trgm_ops for text[] migration index, got:\n%s", output)
	}
}

func TestWriteMigration_GinIndexOnJSONBUsesJSONBOperatorClass(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("learnings", "public")
	detailsCol := models.InitColumn("details", "learnings", "public")
	detailsCol.Type = "jsonb"
	table.Columns["details"] = detailsCol

	index := &models.Index{
		Name:    "idx_learnings_details",
		Type:    "gin",
		Columns: []string{"details"},
	}
	table.Indexes[index.Name] = index

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "USING gin (details jsonb_ops)") {
		t.Fatalf("expected GIN jsonb index to include jsonb_ops, got:\n%s", output)
	}
	if strings.Contains(output, "gin_trgm_ops") {
		t.Fatalf("did not expect gin_trgm_ops for jsonb migration index, got:\n%s", output)
	}
}

func TestWriteMigration_GinIndexOnJSONBIgnoresIncompatibleTrigramOperatorClass(t *testing.T) {
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("learnings", "public")
	detailsCol := models.InitColumn("details", "learnings", "public")
	detailsCol.Type = "jsonb"
	table.Columns["details"] = detailsCol

	index := &models.Index{
		Name:    "idx_learnings_details",
		Type:    "gin",
		Columns: []string{"details"},
		Comment: "gin_trgm_ops",
	}
	table.Indexes[index.Name] = index

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "USING gin (details jsonb_ops)") {
		t.Fatalf("expected incompatible trigram hint on jsonb to fall back to jsonb_ops, got:\n%s", output)
	}
}

func TestWriteMigration_WithAudit(t *testing.T) {
	// Current database (empty)
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("public")
	current.Schemas = append(current.Schemas, currentSchema)

	// Model database (with table to audit)
	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("users", "public")

	idCol := models.InitColumn("id", "users", "public")
	idCol.Type = "integer"
	idCol.IsPrimaryKey = true
	table.Columns["id"] = idCol

	nameCol := models.InitColumn("name", "users", "public")
	nameCol.Type = "text"
	table.Columns["name"] = nameCol

	passwordCol := models.InitColumn("password", "users", "public")
	passwordCol.Type = "text"
	table.Columns["password"] = passwordCol

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	// Configure audit
	auditConfig := NewAuditConfig()
	auditConfig.AuditSchema = "public"
	tableConfig := auditConfig.EnableTableAudit("public", "users")
	tableConfig.EncryptedColumns = []string{"password"}

	// Generate migration with audit
	var buf bytes.Buffer
	options := &writers.WriterOptions{
		Metadata: map[string]interface{}{
			"audit_config": auditConfig,
		},
	}
	writer, err := NewMigrationWriter(options)
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	err = writer.WriteMigration(model, current)
	if err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	t.Logf("Generated migration with audit:\n%s", output)

	// Verify audit tables
	if !strings.Contains(output, "CREATE TABLE IF NOT EXISTS public.atevent") {
		t.Error("Migration missing atevent table")
	}
	if !strings.Contains(output, "CREATE TABLE IF NOT EXISTS public.atdetail") {
		t.Error("Migration missing atdetail table")
	}

	// Verify audit function
	if !strings.Contains(output, "CREATE OR REPLACE FUNCTION public.tf_audit_users()") {
		t.Error("Migration missing audit function")
	}

	// Verify audit trigger
	if !strings.Contains(output, "CREATE TRIGGER t_audit_users") {
		t.Error("Migration missing audit trigger")
	}

	// Verify encrypted column handling
	if !strings.Contains(output, "'****************'") {
		t.Error("Migration missing encrypted column handling")
	}
}

func TestTemplateExecutor_CreateTable(t *testing.T) {
	executor, err := NewTemplateExecutor(false)
	if err != nil {
		t.Fatalf("Failed to create executor: %v", err)
	}

	data := CreateTableData{
		SchemaName: "public",
		TableName:  "test_table",
		Columns: []ColumnData{
			{Name: "id", Type: "integer", NotNull: true},
			{Name: "name", Type: "text", Default: "'unknown'"},
		},
	}

	sql, err := executor.ExecuteCreateTable(data)
	if err != nil {
		t.Fatalf("Failed to execute template: %v", err)
	}

	t.Logf("Generated SQL:\n%s", sql)

	if !strings.Contains(sql, "CREATE TABLE IF NOT EXISTS public.test_table") {
		t.Error("SQL missing CREATE TABLE statement")
	}
	if !strings.Contains(sql, "id integer NOT NULL") {
		t.Error("SQL missing id column definition")
	}
	if !strings.Contains(sql, "name text DEFAULT 'unknown'") {
		t.Error("SQL missing name column definition")
	}
}

func TestTemplateExecutor_AuditFunction(t *testing.T) {
	executor, err := NewTemplateExecutor(false)
	if err != nil {
		t.Fatalf("Failed to create executor: %v", err)
	}

	data := AuditFunctionData{
		SchemaName:      "public",
		FunctionName:    "tf_audit_users",
		TableName:       "users",
		TablePrefix:     "NULL",
		PrimaryKey:      "id",
		AuditSchema:     "public",
		UserFunction:    "current_user",
		AuditInsert:     true,
		AuditUpdate:     true,
		AuditDelete:     true,
		UpdateCondition: "old.name IS DISTINCT FROM new.name",
		UpdateColumns: []AuditColumnData{
			{Name: "name", OldValue: "old.name::text", NewValue: "new.name::text"},
		},
		DeleteColumns: []AuditColumnData{
			{Name: "name", OldValue: "old.name::text"},
		},
	}

	sql, err := executor.ExecuteAuditFunction(data)
	if err != nil {
		t.Fatalf("Failed to execute template: %v", err)
	}

	t.Logf("Generated SQL:\n%s", sql)

	if !strings.Contains(sql, "CREATE OR REPLACE FUNCTION public.tf_audit_users()") {
		t.Error("SQL missing function definition")
	}
	if !strings.Contains(sql, "IF TG_OP = 'INSERT'") {
		t.Error("SQL missing INSERT handling")
	}
	if !strings.Contains(sql, "ELSIF TG_OP = 'UPDATE'") {
		t.Error("SQL missing UPDATE handling")
	}
	if !strings.Contains(sql, "ELSIF TG_OP = 'DELETE'") {
		t.Error("SQL missing DELETE handling")
	}
}

func TestWriteMigration_NumericConstraintNames(t *testing.T) {
	// Current database (empty)
	current := models.InitDatabase("testdb")
	currentSchema := models.InitSchema("entity")
	current.Schemas = append(current.Schemas, currentSchema)

	// Model database (with constraint starting with number)
	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("entity")

	// Create individual_actor_relationship table
	table := models.InitTable("individual_actor_relationship", "entity")
	idCol := models.InitColumn("id", "individual_actor_relationship", "entity")
	idCol.Type = "integer"
	idCol.IsPrimaryKey = true
	table.Columns["id"] = idCol

	actorIDCol := models.InitColumn("actor_id", "individual_actor_relationship", "entity")
	actorIDCol.Type = "integer"
	table.Columns["actor_id"] = actorIDCol

	// Add constraint with name starting with number
	constraint := &models.Constraint{
		Name:              "215162_fk_actor",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"actor_id"},
		ReferencedSchema:  "entity",
		ReferencedTable:   "actor",
		ReferencedColumns: []string{"id"},
		OnDelete:          "CASCADE",
		OnUpdate:          "NO ACTION",
	}
	table.Constraints["215162_fk_actor"] = constraint

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	// Generate migration
	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	err = writer.WriteMigration(model, current)
	if err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	t.Logf("Generated migration:\n%s", output)

	// Verify constraint name is properly quoted
	if !strings.Contains(output, `"215162_fk_actor"`) {
		t.Error("Constraint name starting with number should be quoted")
	}

	// Verify the SQL is syntactically correct (contains required keywords)
	if !strings.Contains(output, "ADD CONSTRAINT") {
		t.Error("Migration missing ADD CONSTRAINT")
	}
	if !strings.Contains(output, "FOREIGN KEY") {
		t.Error("Migration missing FOREIGN KEY")
	}
}

func TestNewMigrationWriter_NilOptions(t *testing.T) {
	writer, err := NewMigrationWriter(nil)
	if err != nil {
		t.Fatalf("NewMigrationWriter(nil) returned error: %v", err)
	}
	if writer == nil {
		t.Fatal("expected writer instance")
	}
	if writer.options == nil {
		t.Fatal("expected default writer options to be initialized")
	}
}

func TestWriteMigration_NilCurrentTreatsDatabaseAsEmpty(t *testing.T) {
	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("users", "public")
	idCol := models.InitColumn("id", "users", "public")
	idCol.Type = "integer"
	idCol.NotNull = true
	table.Columns["id"] = idCol

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(nil)
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, nil); err != nil {
		t.Fatalf("WriteMigration with nil current failed: %v", err)
	}

	output := buf.String()
	if !strings.Contains(output, "CREATE TABLE") {
		t.Fatalf("expected CREATE TABLE in migration output, got:\n%s", output)
	}
}

func TestWriteMigration_VectorAndPostGISIndexes(t *testing.T) {
	current := models.InitDatabase("testdb")
	current.Schemas = append(current.Schemas, models.InitSchema("public"))

	model := models.InitDatabase("testdb")
	modelSchema := models.InitSchema("public")

	table := models.InitTable("documents", "public")

	embedding := models.InitColumn("embedding", "documents", "public")
	embedding.Type = "vector(1536)"
	table.Columns["embedding"] = embedding

	location := models.InitColumn("location", "documents", "public")
	location.Type = "geometry(Point,4326)"
	table.Columns["location"] = location

	table.Indexes["idx_documents_embedding"] = &models.Index{
		Name:    "idx_documents_embedding",
		Type:    "ivfflat",
		Columns: []string{"embedding"},
		Comment: "opclass=vector_cosine_ops; with (lists=100)",
	}
	table.Indexes["idx_documents_location"] = &models.Index{
		Name:    "idx_documents_location",
		Type:    "gist",
		Columns: []string{"location"},
	}

	modelSchema.Tables = append(modelSchema.Tables, table)
	model.Schemas = append(model.Schemas, modelSchema)

	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf

	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}

	output := buf.String()
	for _, want := range []string{
		"CREATE EXTENSION IF NOT EXISTS postgis;",
		"CREATE EXTENSION IF NOT EXISTS vector;",
		"vector(1536)",
		"geometry(Point,4326)",
		"USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100)",
		"USING gist (location)",
	} {
		if !strings.Contains(output, want) {
			t.Fatalf("expected migration to contain %q, got:\n%s", want, output)
		}
	}
}

func TestIndexesEqual_OperatorClassAndStorageParameters(t *testing.T) {
	newIndex := func(comment string) *models.Index {
		return &models.Index{
			Name:    "idx_documents_embedding",
			Type:    "hnsw",
			Columns: []string{"embedding"},
			Comment: comment,
		}
	}

	tests := []struct {
		name      string
		comment1  string
		comment2  string
		wantEqual bool
	}{
		{"identical hints", "opclass=vector_l2_ops", "opclass=vector_l2_ops", true},
		{"different operator class", "opclass=vector_l2_ops", "opclass=vector_cosine_ops", false},
		{"different storage parameters", "with (m=16)", "with (m=32)", false},
		{"unspecified hint on one side", "", "opclass=vector_l2_ops; with (m=16)", true},
		{"unrelated comments", "primary lookup index", "primary lookup index", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := indexesEqual(newIndex(tt.comment1), newIndex(tt.comment2)); got != tt.wantEqual {
				t.Errorf("indexesEqual() = %v, want %v", got, tt.wantEqual)
			}
		})
	}
}

func uniqueConstraintTestModel() *models.Database {
	model := models.InitDatabase("testdb")
	schema := models.InitSchema("public")

	table := models.InitTable("login", "public")
	idCol := models.InitColumn("id", "login", "public")
	idCol.Type = "integer"
	idCol.NotNull = true
	table.Columns["id"] = idCol
	guidCol := models.InitColumn("guid", "login", "public")
	guidCol.Type = "uuid"
	table.Columns["guid"] = guidCol

	uc := models.InitConstraint("ukey_login_guid", models.UniqueConstraint)
	uc.Schema = "public"
	uc.Table = "login"
	uc.Columns = []string{"guid"}
	table.Constraints[uc.Name] = uc

	schema.Tables = append(schema.Tables, table)
	model.Schemas = append(model.Schemas, schema)
	return model
}

func TestWriteMigration_UniqueConstraint(t *testing.T) {
	tests := []struct {
		name         string
		current      func() *models.Database
		wantConstrnt bool
	}{
		{
			name: "new table",
			current: func() *models.Database {
				c := models.InitDatabase("testdb")
				c.Schemas = append(c.Schemas, models.InitSchema("public"))
				return c
			},
			wantConstrnt: true,
		},
		{
			name: "existing table without constraint",
			current: func() *models.Database {
				c := uniqueConstraintTestModel()
				delete(c.Schemas[0].Tables[0].Constraints, "ukey_login_guid")
				return c
			},
			wantConstrnt: true,
		},
		{
			name:         "existing table with constraint",
			current:      uniqueConstraintTestModel,
			wantConstrnt: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var buf bytes.Buffer
			writer, err := NewMigrationWriter(&writers.WriterOptions{})
			if err != nil {
				t.Fatalf("Failed to create writer: %v", err)
			}
			writer.writer = &buf

			if err := writer.WriteMigration(uniqueConstraintTestModel(), tt.current()); err != nil {
				t.Fatalf("WriteMigration failed: %v", err)
			}

			output := buf.String()
			has := strings.Contains(output, "ADD CONSTRAINT") && strings.Contains(output, "ukey_login_guid") && strings.Contains(output, "UNIQUE")
			if has != tt.wantConstrnt {
				t.Fatalf("unique constraint present = %v, want %v; output:\n%s", has, tt.wantConstrnt, output)
			}
			if strings.Contains(output, "DROP CONSTRAINT") {
				t.Fatalf("unexpected DROP CONSTRAINT; output:\n%s", output)
			}
		})
	}
}

func TestWriteMigration_UniqueConstraintAdoptsSameNamedModelIndex(t *testing.T) {
	newIndex := func(name string, unique bool, where string) *models.Index {
		idx := models.InitIndex(name, "login", "public")
		idx.Columns = []string{"guid"}
		idx.Unique = unique
		idx.Type = "btree"
		idx.Where = where
		return idx
	}

	tests := []struct {
		name      string
		modelIdx  *models.Index
		liveIdx   *models.Index // nil: fresh table
		wantAdopt bool
		wantDrop  bool
	}{
		{
			name:      "fresh table: same-named unique index is promoted",
			modelIdx:  newIndex("ukey_login_guid", true, ""),
			wantAdopt: true,
		},
		{
			name:      "existing live unique index is promoted",
			modelIdx:  newIndex("ukey_login_guid", true, ""),
			liveIdx:   newIndex("ukey_login_guid", true, ""),
			wantAdopt: true,
		},
		{
			name:     "live unique index not in model is dropped and constraint built fresh",
			liveIdx:  newIndex("ukey_login_guid", true, ""),
			wantDrop: true,
		},
		{
			name:     "partial model index is not promoted",
			modelIdx: newIndex("ukey_login_guid", true, "guid IS NOT NULL"),
		},
		{
			name:     "non-unique same-named index is not promoted",
			modelIdx: newIndex("ukey_login_guid", false, ""),
		},
		{
			name:     "differently named index is not promoted",
			modelIdx: newIndex("idx_login_guid", true, ""),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			model := uniqueConstraintTestModel()
			if tt.modelIdx != nil {
				model.Schemas[0].Tables[0].Indexes[tt.modelIdx.Name] = tt.modelIdx
			}

			current := models.InitDatabase("testdb")
			current.Schemas = append(current.Schemas, models.InitSchema("public"))
			if tt.liveIdx != nil {
				current = uniqueConstraintTestModel()
				curTable := current.Schemas[0].Tables[0]
				delete(curTable.Constraints, "ukey_login_guid")
				curTable.Indexes[tt.liveIdx.Name] = tt.liveIdx
			}

			var buf bytes.Buffer
			writer, err := NewMigrationWriter(&writers.WriterOptions{})
			if err != nil {
				t.Fatalf("Failed to create writer: %v", err)
			}
			writer.writer = &buf
			if err := writer.WriteMigration(model, current); err != nil {
				t.Fatalf("WriteMigration failed: %v", err)
			}
			output := buf.String()

			if got := strings.Contains(output, "UNIQUE USING INDEX"); got != tt.wantAdopt {
				t.Errorf("USING INDEX present = %v, want %v; output:\n%s", got, tt.wantAdopt, output)
			}
			if got := strings.Contains(output, "UNIQUE (guid)") || strings.Contains(output, "UNIQUE (\"guid\")"); got == tt.wantAdopt {
				t.Errorf("column-list ADD CONSTRAINT present = %v, want %v; output:\n%s", got, !tt.wantAdopt, output)
			}
			if got := strings.Contains(output, "DROP INDEX"); got != tt.wantDrop {
				t.Errorf("DROP INDEX present = %v, want %v; output:\n%s", got, tt.wantDrop, output)
			}
		})
	}
}

func TestWriteDatabase_UniqueConstraintAdoptsSameNamedIndex(t *testing.T) {
	db := uniqueConstraintTestModel()
	idx := models.InitIndex("ukey_login_guid", "login", "public")
	idx.Columns = []string{"guid"}
	idx.Unique = true
	db.Schemas[0].Tables[0].Indexes[idx.Name] = idx

	var buf bytes.Buffer
	w := NewWriter(&writers.WriterOptions{})
	w.writer = &buf
	if err := w.WriteDatabase(db); err != nil {
		t.Fatalf("WriteDatabase failed: %v", err)
	}
	output := buf.String()

	if !strings.Contains(output, "UNIQUE USING INDEX") {
		t.Fatalf("expected UNIQUE USING INDEX in output:\n%s", output)
	}
	if strings.Index(output, "CREATE UNIQUE INDEX") > strings.Index(output, "UNIQUE USING INDEX") {
		t.Fatalf("index must be created before the constraint adopts it:\n%s", output)
	}
}

func fkDeferralTestModel(def, init *bool) *models.Database {
	db := models.InitDatabase("testdb")
	schema := models.InitSchema("public")

	users := models.InitTable("users", "public")
	uid := models.InitColumn("id", "users", "public")
	uid.Type = "integer"
	uid.NotNull = true
	users.Columns["id"] = uid

	posts := models.InitTable("posts", "public")
	pid := models.InitColumn("id", "posts", "public")
	pid.Type = "integer"
	pid.NotNull = true
	posts.Columns["id"] = pid
	puid := models.InitColumn("user_id", "posts", "public")
	puid.Type = "integer"
	posts.Columns["user_id"] = puid

	fk := models.InitConstraint("fk_posts_user_id", models.ForeignKeyConstraint)
	fk.Schema = "public"
	fk.Table = "posts"
	fk.Columns = []string{"user_id"}
	fk.ReferencedSchema = "public"
	fk.ReferencedTable = "users"
	fk.ReferencedColumns = []string{"id"}
	fk.Deferrable = def
	fk.InitiallyDeferred = init
	posts.Constraints[fk.Name] = fk

	schema.Tables = append(schema.Tables, users, posts)
	db.Schemas = append(db.Schemas, schema)
	return db
}

func migrationOutput(t *testing.T, model, current *models.Database) string {
	t.Helper()
	var buf bytes.Buffer
	writer, err := NewMigrationWriter(&writers.WriterOptions{})
	if err != nil {
		t.Fatalf("Failed to create writer: %v", err)
	}
	writer.writer = &buf
	if err := writer.WriteMigration(model, current); err != nil {
		t.Fatalf("WriteMigration failed: %v", err)
	}
	return buf.String()
}

func TestWriteMigration_ForeignKeyDeferral(t *testing.T) {
	yes, no := true, false
	empty := func() *models.Database {
		c := models.InitDatabase("testdb")
		c.Schemas = append(c.Schemas, models.InitSchema("public"))
		return c
	}

	tests := []struct {
		name     string
		def      *bool
		init     *bool
		wantFrag string
	}{
		{"unspecified keeps DEFERRABLE default", nil, nil, "ON UPDATE NO ACTION\n  DEFERRABLE;"},
		{"deferrable", &yes, nil, "DEFERRABLE;"},
		{"initially deferred", &yes, &yes, "DEFERRABLE INITIALLY DEFERRED;"},
		{"not deferrable", &no, nil, "NOT DEFERRABLE;"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			out := migrationOutput(t, fkDeferralTestModel(tt.def, tt.init), empty())
			if !strings.Contains(out, tt.wantFrag) {
				t.Fatalf("expected %q in output:\n%s", tt.wantFrag, out)
			}
		})
	}
}

func TestWriteMigration_ForeignKeyDeferralDiff(t *testing.T) {
	yes, no := true, false
	live := func(def, init bool) *models.Database {
		db := fkDeferralTestModel(&def, &init)
		return db
	}

	tests := []struct {
		name         string
		def, init    *bool
		liveDef      bool
		liveInit     bool
		wantRecreate bool
	}{
		{"unspecified vs deferrable live: untouched", nil, nil, true, false, false},
		{"unspecified vs not deferrable live: untouched", nil, nil, false, false, false},
		{"deferrable matches live", &yes, nil, true, true, false},
		{"deferrable vs not deferrable live: recreated", &yes, nil, false, false, true},
		{"not deferrable vs deferrable live: recreated", &no, nil, true, false, true},
		{"initially deferred vs initially immediate live: recreated", &yes, &yes, true, false, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			out := migrationOutput(t, fkDeferralTestModel(tt.def, tt.init), live(tt.liveDef, tt.liveInit))
			got := strings.Contains(out, "ADD CONSTRAINT") && strings.Contains(out, "FOREIGN KEY")
			if got != tt.wantRecreate {
				t.Fatalf("FK recreated = %v, want %v; output:\n%s", got, tt.wantRecreate, out)
			}
		})
	}
}

func TestWriteDatabase_ForeignKeyDeferral(t *testing.T) {
	yes := true
	var buf bytes.Buffer
	w := NewWriter(&writers.WriterOptions{})
	w.writer = &buf
	if err := w.WriteDatabase(fkDeferralTestModel(&yes, &yes)); err != nil {
		t.Fatalf("WriteDatabase failed: %v", err)
	}
	if !strings.Contains(buf.String(), "DEFERRABLE INITIALLY DEFERRED;") {
		t.Fatalf("expected DEFERRABLE INITIALLY DEFERRED in output:\n%s", buf.String())
	}
}