relspecgo/pkg/writers/bun/writer_test.go

package bun

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

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

func TestWriter_WriteTable(t *testing.T) {
	// Create a simple table
	table := models.InitTable("users", "public")
	table.Columns["id"] = &models.Column{
		Name:          "id",
		Type:          "bigint",
		NotNull:       true,
		IsPrimaryKey:  true,
		AutoIncrement: true,
		Sequence:      1,
	}
	table.Columns["email"] = &models.Column{
		Name:     "email",
		Type:     "varchar",
		Length:   255,
		NotNull:  false,
		Sequence: 2,
	}
	table.Columns["created_at"] = &models.Column{
		Name:     "created_at",
		Type:     "timestamp",
		NotNull:  true,
		Sequence: 3,
	}

	// Create writer
	opts := &writers.WriterOptions{
		PackageName: "models",
		Metadata: map[string]interface{}{
			"generate_table_name": true,
			"generate_get_id":     true,
		},
	}

	writer := NewWriter(opts)

	// Write to temporary file
	tmpDir := t.TempDir()
	opts.OutputPath = filepath.Join(tmpDir, "test.go")

	err := writer.WriteTable(table)
	if err != nil {
		t.Fatalf("WriteTable failed: %v", err)
	}

	// Read the generated file
	content, err := os.ReadFile(opts.OutputPath)
	if err != nil {
		t.Fatalf("Failed to read generated file: %v", err)
	}

	generated := string(content)

	// Verify key elements are present
	expectations := []string{
		"package models",
		"type ModelPublicUsers struct",
		"bun.BaseModel",
		"table:public.users",
		"alias:users",
		"ID",
		"int64",
		"Email",
		"*string",
		"CreatedAt",
		"time.Time",
		"bun:\"id",
		"bun:\"email",
		"func (m ModelPublicUsers) TableName() string",
		"return \"public.users\"",
		"func (m ModelPublicUsers) GetID() int64",
	}

	for _, expected := range expectations {
		if !strings.Contains(generated, expected) {
			t.Errorf("Generated code missing expected content: %q\nGenerated:\n%s", expected, generated)
		}
	}

	// Verify Bun-specific elements
	if !strings.Contains(generated, "bun:\"id,type:bigint,pk,autoincrement,") {
		t.Errorf("Missing Bun-style primary key tag with autoincrement")
	}
}

func TestWriter_WriteDatabase_MultiFile(t *testing.T) {
	// Create a database with two tables
	db := models.InitDatabase("testdb")
	schema := models.InitSchema("public")

	// Table 1: users
	users := models.InitTable("users", "public")
	users.Columns["id"] = &models.Column{
		Name:         "id",
		Type:         "bigint",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	schema.Tables = append(schema.Tables, users)

	// Table 2: posts
	posts := models.InitTable("posts", "public")
	posts.Columns["id"] = &models.Column{
		Name:         "id",
		Type:         "bigint",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	posts.Columns["user_id"] = &models.Column{
		Name:    "user_id",
		Type:    "bigint",
		NotNull: true,
	}
	posts.Constraints["fk_user"] = &models.Constraint{
		Name:              "fk_user",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"user_id"},
		ReferencedTable:   "users",
		ReferencedSchema:  "public",
		ReferencedColumns: []string{"id"},
		OnDelete:          "CASCADE",
	}
	schema.Tables = append(schema.Tables, posts)

	db.Schemas = append(db.Schemas, schema)

	// Create writer with multi-file mode
	tmpDir := t.TempDir()
	opts := &writers.WriterOptions{
		PackageName: "models",
		OutputPath:  tmpDir,
		Metadata: map[string]interface{}{
			"multi_file": true,
		},
	}

	writer := NewWriter(opts)

	err := writer.WriteDatabase(db)
	if err != nil {
		t.Fatalf("WriteDatabase failed: %v", err)
	}

	// Verify two files were created
	expectedFiles := []string{
		"sql_public_users.go",
		"sql_public_posts.go",
	}

	for _, filename := range expectedFiles {
		filepath := filepath.Join(tmpDir, filename)
		if _, err := os.Stat(filepath); os.IsNotExist(err) {
			t.Errorf("Expected file not created: %s", filename)
		}
	}

	// Check posts file contains relationship
	postsContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_public_posts.go"))
	if err != nil {
		t.Fatalf("Failed to read posts file: %v", err)
	}

	postsStr := string(postsContent)

	// Verify relationship is present with Bun format
	// Should now be RelUserID (has-one) instead of USE
	if !strings.Contains(postsStr, "RelUserID") {
		t.Errorf("Missing relationship field RelUserID (new naming convention)")
	}
	if !strings.Contains(postsStr, "rel:has-one") {
		t.Errorf("Missing Bun relationship tag: %s", postsStr)
	}

	// Check users file contains has-many relationship
	usersContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_public_users.go"))
	if err != nil {
		t.Fatalf("Failed to read users file: %v", err)
	}

	usersStr := string(usersContent)

	// Should have RelUserIDPublicPosts (has-many) field - includes schema prefix
	if !strings.Contains(usersStr, "RelUserIDPublicPosts") {
		t.Errorf("Missing has-many relationship field RelUserIDPublicPosts")
	}
}

func TestWriter_MultipleReferencesToSameTable(t *testing.T) {
	// Test scenario: api_event table with multiple foreign keys to filepointer table
	db := models.InitDatabase("testdb")
	schema := models.InitSchema("org")

	// Filepointer table
	filepointer := models.InitTable("filepointer", "org")
	filepointer.Columns["id_filepointer"] = &models.Column{
		Name:         "id_filepointer",
		Type:         "bigserial",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	schema.Tables = append(schema.Tables, filepointer)

	// API event table with two foreign keys to filepointer
	apiEvent := models.InitTable("api_event", "org")
	apiEvent.Columns["id_api_event"] = &models.Column{
		Name:         "id_api_event",
		Type:         "bigserial",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	apiEvent.Columns["rid_filepointer_request"] = &models.Column{
		Name:    "rid_filepointer_request",
		Type:    "bigint",
		NotNull: false,
	}
	apiEvent.Columns["rid_filepointer_response"] = &models.Column{
		Name:    "rid_filepointer_response",
		Type:    "bigint",
		NotNull: false,
	}

	// Add constraints
	apiEvent.Constraints["fk_request"] = &models.Constraint{
		Name:              "fk_request",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"rid_filepointer_request"},
		ReferencedTable:   "filepointer",
		ReferencedSchema:  "org",
		ReferencedColumns: []string{"id_filepointer"},
	}
	apiEvent.Constraints["fk_response"] = &models.Constraint{
		Name:              "fk_response",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"rid_filepointer_response"},
		ReferencedTable:   "filepointer",
		ReferencedSchema:  "org",
		ReferencedColumns: []string{"id_filepointer"},
	}

	schema.Tables = append(schema.Tables, apiEvent)
	db.Schemas = append(db.Schemas, schema)

	// Create writer
	tmpDir := t.TempDir()
	opts := &writers.WriterOptions{
		PackageName: "models",
		OutputPath:  tmpDir,
		Metadata: map[string]interface{}{
			"multi_file": true,
		},
	}

	writer := NewWriter(opts)
	err := writer.WriteDatabase(db)
	if err != nil {
		t.Fatalf("WriteDatabase failed: %v", err)
	}

	// Read the api_event file
	apiEventContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_api_event.go"))
	if err != nil {
		t.Fatalf("Failed to read api_event file: %v", err)
	}

	contentStr := string(apiEventContent)

	// Verify both relationships have unique names based on column names
	expectations := []struct {
		fieldName string
		tag       string
	}{
		{"RelRIDFilepointerRequest", "join:rid_filepointer_request=id_filepointer"},
		{"RelRIDFilepointerResponse", "join:rid_filepointer_response=id_filepointer"},
	}

	for _, exp := range expectations {
		if !strings.Contains(contentStr, exp.fieldName) {
			t.Errorf("Missing relationship field: %s\nGenerated:\n%s", exp.fieldName, contentStr)
		}
		if !strings.Contains(contentStr, exp.tag) {
			t.Errorf("Missing relationship tag: %s\nGenerated:\n%s", exp.tag, contentStr)
		}
	}

	// Verify NO duplicate field names (old behavior would create duplicate "FIL" fields)
	if strings.Contains(contentStr, "FIL *ModelFilepointer") {
		t.Errorf("Found old prefix-based naming (FIL), should use column-based naming")
	}

	// Also verify has-many relationships on filepointer table
	filepointerContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_filepointer.go"))
	if err != nil {
		t.Fatalf("Failed to read filepointer file: %v", err)
	}

	filepointerStr := string(filepointerContent)

	// Should have two different has-many relationships with unique names
	hasManyExpectations := []struct {
		fieldName string
		tag       string
	}{
		{"RelRIDFilepointerRequestOrgAPIEvents", "join:id_filepointer=rid_filepointer_request"},   // Has many via rid_filepointer_request
		{"RelRIDFilepointerResponseOrgAPIEvents", "join:id_filepointer=rid_filepointer_response"}, // Has many via rid_filepointer_response
	}

	for _, exp := range hasManyExpectations {
		if !strings.Contains(filepointerStr, exp.fieldName) {
			t.Errorf("Missing has-many relationship field: %s\nGenerated:\n%s", exp.fieldName, filepointerStr)
		}
		if !strings.Contains(filepointerStr, exp.tag) {
			t.Errorf("Missing has-many relationship join tag: %s\nGenerated:\n%s", exp.tag, filepointerStr)
		}
	}
}

func TestWriter_MultipleHasManyRelationships(t *testing.T) {
	// Test scenario: api_provider table referenced by multiple tables via rid_api_provider
	db := models.InitDatabase("testdb")
	schema := models.InitSchema("org")

	// Owner table
	owner := models.InitTable("owner", "org")
	owner.Columns["id_owner"] = &models.Column{
		Name:         "id_owner",
		Type:         "bigserial",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	schema.Tables = append(schema.Tables, owner)

	// API Provider table
	apiProvider := models.InitTable("api_provider", "org")
	apiProvider.Columns["id_api_provider"] = &models.Column{
		Name:         "id_api_provider",
		Type:         "bigserial",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	apiProvider.Columns["rid_owner"] = &models.Column{
		Name:    "rid_owner",
		Type:    "bigint",
		NotNull: true,
	}
	apiProvider.Constraints["fk_owner"] = &models.Constraint{
		Name:              "fk_owner",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"rid_owner"},
		ReferencedTable:   "owner",
		ReferencedSchema:  "org",
		ReferencedColumns: []string{"id_owner"},
	}
	schema.Tables = append(schema.Tables, apiProvider)

	// Login table
	login := models.InitTable("login", "org")
	login.Columns["id_login"] = &models.Column{
		Name:         "id_login",
		Type:         "bigserial",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	login.Columns["rid_api_provider"] = &models.Column{
		Name:    "rid_api_provider",
		Type:    "bigint",
		NotNull: true,
	}
	login.Constraints["fk_api_provider"] = &models.Constraint{
		Name:              "fk_api_provider",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"rid_api_provider"},
		ReferencedTable:   "api_provider",
		ReferencedSchema:  "org",
		ReferencedColumns: []string{"id_api_provider"},
	}
	schema.Tables = append(schema.Tables, login)

	// Filepointer table
	filepointer := models.InitTable("filepointer", "org")
	filepointer.Columns["id_filepointer"] = &models.Column{
		Name:         "id_filepointer",
		Type:         "bigserial",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	filepointer.Columns["rid_api_provider"] = &models.Column{
		Name:    "rid_api_provider",
		Type:    "bigint",
		NotNull: true,
	}
	filepointer.Constraints["fk_api_provider"] = &models.Constraint{
		Name:              "fk_api_provider",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"rid_api_provider"},
		ReferencedTable:   "api_provider",
		ReferencedSchema:  "org",
		ReferencedColumns: []string{"id_api_provider"},
	}
	schema.Tables = append(schema.Tables, filepointer)

	// API Event table
	apiEvent := models.InitTable("api_event", "org")
	apiEvent.Columns["id_api_event"] = &models.Column{
		Name:         "id_api_event",
		Type:         "bigserial",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	apiEvent.Columns["rid_api_provider"] = &models.Column{
		Name:    "rid_api_provider",
		Type:    "bigint",
		NotNull: true,
	}
	apiEvent.Constraints["fk_api_provider"] = &models.Constraint{
		Name:              "fk_api_provider",
		Type:              models.ForeignKeyConstraint,
		Columns:           []string{"rid_api_provider"},
		ReferencedTable:   "api_provider",
		ReferencedSchema:  "org",
		ReferencedColumns: []string{"id_api_provider"},
	}
	schema.Tables = append(schema.Tables, apiEvent)

	db.Schemas = append(db.Schemas, schema)

	// Create writer
	tmpDir := t.TempDir()
	opts := &writers.WriterOptions{
		PackageName: "models",
		OutputPath:  tmpDir,
		Metadata: map[string]interface{}{
			"multi_file": true,
		},
	}

	writer := NewWriter(opts)
	err := writer.WriteDatabase(db)
	if err != nil {
		t.Fatalf("WriteDatabase failed: %v", err)
	}

	// Read the api_provider file
	apiProviderContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_api_provider.go"))
	if err != nil {
		t.Fatalf("Failed to read api_provider file: %v", err)
	}

	contentStr := string(apiProviderContent)

	// Verify all has-many relationships have unique names
	hasManyExpectations := []string{
		"RelRIDAPIProviderOrgLogins",       // Has many via Login
		"RelRIDAPIProviderOrgFilepointers", // Has many via Filepointer
		"RelRIDAPIProviderOrgAPIEvents",    // Has many via APIEvent
		"RelRIDOwner",                      // Has one via rid_owner
	}

	for _, exp := range hasManyExpectations {
		if !strings.Contains(contentStr, exp) {
			t.Errorf("Missing relationship field: %s\nGenerated:\n%s", exp, contentStr)
		}
	}

	// Verify NO duplicate field names
	// Count occurrences of "RelRIDAPIProvider" fields - should have 3 unique ones
	count := strings.Count(contentStr, "RelRIDAPIProvider")
	if count != 3 {
		t.Errorf("Expected 3 RelRIDAPIProvider* fields, found %d\nGenerated:\n%s", count, contentStr)
	}

	// Verify no duplicate declarations (would cause compilation error)
	duplicatePattern := "RelRIDAPIProviders []*Model"
	if strings.Contains(contentStr, duplicatePattern) {
		t.Errorf("Found duplicate field declaration pattern, fields should be unique")
	}
}

func TestWriter_FieldNameCollision(t *testing.T) {
	// Test scenario: table with columns that would conflict with generated method names
	table := models.InitTable("audit_table", "audit")
	table.Columns["id_audit_table"] = &models.Column{
		Name:         "id_audit_table",
		Type:         "smallint",
		NotNull:      true,
		IsPrimaryKey: true,
		Sequence:     1,
	}
	table.Columns["table_name"] = &models.Column{
		Name:     "table_name",
		Type:     "varchar",
		Length:   100,
		NotNull:  true,
		Sequence: 2,
	}
	table.Columns["table_schema"] = &models.Column{
		Name:     "table_schema",
		Type:     "varchar",
		Length:   100,
		NotNull:  true,
		Sequence: 3,
	}

	// Create writer
	tmpDir := t.TempDir()
	opts := &writers.WriterOptions{
		PackageName: "models",
		OutputPath:  filepath.Join(tmpDir, "test.go"),
	}

	writer := NewWriter(opts)

	err := writer.WriteTable(table)
	if err != nil {
		t.Fatalf("WriteTable failed: %v", err)
	}

	// Read the generated file
	content, err := os.ReadFile(opts.OutputPath)
	if err != nil {
		t.Fatalf("Failed to read generated file: %v", err)
	}

	generated := string(content)

	// Verify that TableName field was renamed to TableName_ to avoid collision
	if !strings.Contains(generated, "TableName_") {
		t.Errorf("Expected field 'TableName_' (with underscore) but not found\nGenerated:\n%s", generated)
	}

	// Verify the struct tag still references the correct database column
	if !strings.Contains(generated, `bun:"table_name,`) {
		t.Errorf("Expected bun tag to reference 'table_name' column\nGenerated:\n%s", generated)
	}

	// Verify the TableName() method still exists and doesn't conflict
	if !strings.Contains(generated, "func (m ModelAuditAuditTable) TableName() string") {
		t.Errorf("TableName() method should still be generated\nGenerated:\n%s", generated)
	}

	// Verify NO field named just "TableName" (without underscore)
	if strings.Contains(generated, "TableName sql_types") || strings.Contains(generated, "TableName string") {
		t.Errorf("Field 'TableName' without underscore should not exist (would conflict with method)\nGenerated:\n%s", generated)
	}
}

func TestTypeMapper_SQLTypeToGoType_Bun(t *testing.T) {
	mapper := NewTypeMapper("", "")

	tests := []struct {
		sqlType string
		notNull bool
		want    string
	}{
		{"bigint", true, "int64"},
		{"bigint", false, "*int64"},
		{"varchar", true, "string"},
		{"varchar", false, "*string"},
		{"timestamp", true, "time.Time"},
		{"timestamp", false, "*time.Time"},
		{"date", false, "*time.Time"},
		{"boolean", true, "bool"},
		{"boolean", false, "*bool"},
		{"uuid", false, "*string"},
		{"jsonb", false, "*string"},
		{"text[]", true, "[]string"},
		{"text[]", false, "[]string"},
		{"integer[]", true, "[]int32"},
		{"bigint[]", false, "[]int64"},
	}

	for _, tt := range tests {
		t.Run(tt.sqlType, func(t *testing.T) {
			result := mapper.SQLTypeToGoType(tt.sqlType, tt.notNull)
			if result != tt.want {
				t.Errorf("SQLTypeToGoType(%q, %v) = %q, want %q", tt.sqlType, tt.notNull, result, tt.want)
			}
		})
	}
}

func TestWriter_UpdateIDTypeSafety_Bun(t *testing.T) {
	tests := []struct {
		name         string
		pkType       string
		expectedPK   string
		expectedLine string
		forbidInt32  bool
	}{
		{"int32_pk", "int", "int32", "m.ID = int32(newid)", false},
		{"sql_int16_pk", "smallint", "int16", "m.ID = int16(newid)", true},
		{"int64_pk", "bigint", "int64", "m.ID = int64(newid)", true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			table := models.InitTable("test_table", "public")
			table.Columns["id"] = &models.Column{
				Name:         "id",
				Type:         tt.pkType,
				NotNull:      true,
				IsPrimaryKey: true,
			}

			tmpDir := t.TempDir()
			opts := &writers.WriterOptions{
				PackageName: "models",
				OutputPath:  filepath.Join(tmpDir, "test.go"),
			}

			writer := NewWriter(opts)
			err := writer.WriteTable(table)
			if err != nil {
				t.Fatalf("WriteTable failed: %v", err)
			}

			content, err := os.ReadFile(opts.OutputPath)
			if err != nil {
				t.Fatalf("Failed to read generated file: %v", err)
			}

			generated := string(content)

			if !strings.Contains(generated, tt.expectedLine) {
				t.Errorf("Expected UpdateID to include %s\nGenerated:\n%s", tt.expectedLine, generated)
			}

			if !strings.Contains(generated, "ID            "+tt.expectedPK) {
				t.Errorf("Expected generated primary key field type %s\nGenerated:\n%s", tt.expectedPK, generated)
			}

			if tt.forbidInt32 && strings.Contains(generated, "int32(newid)") {
				t.Errorf("UpdateID should not cast to int32 for %s type\nGenerated:\n%s", tt.pkType, generated)
			}

			if !strings.Contains(generated, "UpdateID(newid int64)") {
				t.Errorf("UpdateID should accept int64 parameter\nGenerated:\n%s", generated)
			}
		})
	}
}

func TestWriter_StringPrimaryKeyHelpers_Bun(t *testing.T) {
	table := models.InitTable("accounts", "public")
	table.Columns["id"] = &models.Column{
		Name:         "id",
		Type:         "uuid",
		NotNull:      true,
		IsPrimaryKey: true,
	}

	tmpDir := t.TempDir()
	opts := &writers.WriterOptions{
		PackageName: "models",
		OutputPath:  filepath.Join(tmpDir, "test.go"),
	}

	writer := NewWriter(opts)
	err := writer.WriteTable(table)
	if err != nil {
		t.Fatalf("WriteTable failed: %v", err)
	}

	content, err := os.ReadFile(opts.OutputPath)
	if err != nil {
		t.Fatalf("Failed to read generated file: %v", err)
	}

	generated := string(content)

	expectations := []string{
		"ID            string",
		"func (m ModelPublicAccounts) GetID() string",
		"return m.ID",
		"func (m ModelPublicAccounts) GetIDStr() string",
		"func (m ModelPublicAccounts) SetID(newid string)",
		"func (m *ModelPublicAccounts) UpdateID(newid string)",
		"m.ID = newid",
	}

	for _, expected := range expectations {
		if !strings.Contains(generated, expected) {
			t.Errorf("Generated code missing expected content: %q\nGenerated:\n%s", expected, generated)
		}
	}

	if strings.Contains(generated, "GetID() int64") || strings.Contains(generated, "UpdateID(newid int64)") {
		t.Errorf("String primary keys should not use int64 helper signatures\nGenerated:\n%s", generated)
	}
}

func TestTypeMapper_BuildBunTag(t *testing.T) {
	mapper := NewTypeMapper("", "")

	tests := []struct {
		name   string
		column *models.Column
		want   []string // Parts that should be in the tag
	}{
		{
			name: "primary key",
			column: &models.Column{
				Name:         "id",
				Type:         "bigint",
				IsPrimaryKey: true,
				NotNull:      true,
			},
			want: []string{"id,", "type:bigint,", "pk,"},
		},
		{
			name: "nullable varchar",
			column: &models.Column{
				Name:    "email",
				Type:    "varchar",
				Length:  255,
				NotNull: false,
			},
			want: []string{"email,", "type:varchar(255),", "nullzero,"},
		},
		{
			name: "with default string",
			column: &models.Column{
				Name:    "status",
				Type:    "text",
				NotNull: true,
				Default: "active",
			},
			want: []string{"status,", "type:text,", "default:'active',"},
		},
		{
			name: "with default integer",
			column: &models.Column{
				Name:    "retries",
				Type:    "integer",
				NotNull: true,
				Default: "0",
			},
			want: []string{"retries,", "type:integer,", "default:0,"},
		},
		{
			name: "with default boolean",
			column: &models.Column{
				Name:    "active",
				Type:    "boolean",
				NotNull: true,
				Default: "true",
			},
			want: []string{"active,", "type:boolean,", "default:true,"},
		},
		{
			name: "with default function call",
			column: &models.Column{
				Name:    "created_at",
				Type:    "timestamp",
				NotNull: true,
				Default: "now()",
			},
			want: []string{"created_at,", "type:timestamp,", "default:now(),"},
		},
		{
			name: "auto increment with AutoIncrement flag",
			column: &models.Column{
				Name:          "id",
				Type:          "bigint",
				NotNull:       true,
				IsPrimaryKey:  true,
				AutoIncrement: true,
			},
			want: []string{"id,", "type:bigint,", "pk,", "autoincrement,"},
		},
		{
			name: "serial type (auto-increment)",
			column: &models.Column{
				Name:         "id",
				Type:         "serial",
				NotNull:      true,
				IsPrimaryKey: true,
			},
			want: []string{"id,", "type:serial,", "pk,", "autoincrement,"},
		},
		{
			name: "bigserial type (auto-increment)",
			column: &models.Column{
				Name:         "id",
				Type:         "bigserial",
				NotNull:      true,
				IsPrimaryKey: true,
			},
			want: []string{"id,", "type:bigserial,", "pk,", "autoincrement,"},
		},
		{
			name: "text array type",
			column: &models.Column{
				Name:    "tags",
				Type:    "text[]",
				NotNull: false,
			},
			want: []string{"tags,", "type:text[],"},
		},
		{
			name: "integer array type",
			column: &models.Column{
				Name:    "scores",
				Type:    "integer[]",
				NotNull: true,
			},
			want: []string{"scores,", "type:integer[],"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := mapper.BuildBunTag(tt.column, nil)
			for _, part := range tt.want {
				if !strings.Contains(result, part) {
					t.Errorf("BuildBunTag() = %q, missing %q", result, part)
				}
			}
			// Array columns always carry the "array" tag, telling bun's
			// pgdialect to scan/append the native Go slice as a PostgreSQL array.
			if strings.HasSuffix(tt.column.Type, "[]") && !strings.Contains(result, ",array,") {
				t.Errorf("BuildBunTag() = %q, expected 'array' tag", result)
			}
		})
	}
}

// TestTypeMapper_BuildBunTag_MultipleUniqueIndexesDeterministic verifies that
// when a column belongs to more than one unique index, the "unique:" tag
// fragments always appear in the same order across repeated calls, instead
// of following Go's randomized map iteration order over Table.Indexes.
func TestTypeMapper_BuildBunTag_MultipleUniqueIndexesDeterministic(t *testing.T) {
	mapper := NewTypeMapper("", "")
	table := &models.Table{
		Name: "accounts",
		Indexes: map[string]*models.Index{
			"idx_z_accounts_email_tenant": {
				Name:    "idx_z_accounts_email_tenant",
				Columns: []string{"email", "tenant_id"},
				Unique:  true,
			},
			"idx_a_accounts_email_region": {
				Name:    "idx_a_accounts_email_region",
				Columns: []string{"email", "region_id"},
				Unique:  true,
			},
		},
	}
	column := &models.Column{Name: "email", Type: "varchar", Length: 255, NotNull: true}

	first := mapper.BuildBunTag(column, table)
	for i := 0; i < 50; i++ {
		got := mapper.BuildBunTag(column, table)
		if got != first {
			t.Fatalf("BuildBunTag() is non-deterministic across calls: %q vs %q", first, got)
		}
	}

	wantOrder := "unique:idx_a_accounts_email_region,unique:idx_z_accounts_email_tenant,"
	if !strings.Contains(first, wantOrder) {
		t.Errorf("BuildBunTag() = %q, want unique tags sorted by index name: %q", first, wantOrder)
	}
}

// TestTypeMapper_BuildBunTag_ArraysAreNativeInEveryMode verifies that array
// columns always use a plain "text[]"-style type and the native Go slice
// type plus an explicit "array" tag, regardless of NullableTypes style
// (sqltypes/stdlib/baselib). bun's pgdialect scans/appends native slices
// directly; the SqlXxxArray wrapper types are never used for array columns.
func TestTypeMapper_BuildBunTag_ArraysAreNativeInEveryMode(t *testing.T) {
	for _, style := range []string{writers.NullableTypeSqlTypes, writers.NullableTypeStdlib, writers.NullableTypeBaselib} {
		t.Run(style, func(t *testing.T) {
			mapper := NewTypeMapper(style, "")

			cases := []struct {
				name       string
				column     *models.Column
				wantSubstr string
			}{
				{name: "text array", column: &models.Column{Name: "tags", Type: "text[]"}, wantSubstr: "type:text[],array,"},
				{name: "varchar array", column: &models.Column{Name: "labels", Type: "varchar[]"}, wantSubstr: "type:varchar[],array,"},
				{name: "integer array", column: &models.Column{Name: "scores", Type: "integer[]", NotNull: true}, wantSubstr: "type:integer[],array,"},
				{name: "boolean array", column: &models.Column{Name: "flags", Type: "boolean[]"}, wantSubstr: "type:boolean[],array,"},
				{name: "uuid array", column: &models.Column{Name: "ids", Type: "uuid[]"}, wantSubstr: "type:uuid[],array,"},
			}
			for _, tt := range cases {
				t.Run(tt.name, func(t *testing.T) {
					result := mapper.BuildBunTag(tt.column, nil)
					if !strings.Contains(result, tt.wantSubstr) {
						t.Errorf("BuildBunTag() = %q, missing %q", result, tt.wantSubstr)
					}
					goType := mapper.SQLTypeToGoType(tt.column.Type, tt.column.NotNull)
					if strings.Contains(goType, "sql_types") {
						t.Errorf("SQLTypeToGoType() = %q, array columns must use a native Go slice, not an sql_types wrapper", goType)
					}
				})
			}
		})
	}
}

// TestTypeMapper_SQLTypeToGoType_ArrayNullable verifies that nullable array
// columns become a pointer-to-slice when NullableArrays is
// "pointer_slice", so callers can distinguish SQL NULL (nil pointer) from
// '{}' (pointer to an empty slice); NOT NULL columns are unaffected.
func TestTypeMapper_SQLTypeToGoType_ArrayNullable(t *testing.T) {
	cases := []struct {
		name          string
		typeStyle     string
		arrayNullable string
		sqlType       string
		notNull       bool
		want          string
	}{
		{name: "baselib nullable slice (default)", typeStyle: writers.NullableTypeBaselib, arrayNullable: "", sqlType: "text[]", notNull: false, want: "[]string"},
		{name: "baselib nullable pointer_slice", typeStyle: writers.NullableTypeBaselib, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "text[]", notNull: false, want: "*[]string"},
		{name: "baselib not null pointer_slice unaffected", typeStyle: writers.NullableTypeBaselib, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "text[]", notNull: true, want: "[]string"},
		{name: "stdlib nullable pointer_slice", typeStyle: writers.NullableTypeStdlib, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "integer[]", notNull: false, want: "*[]int32"},
		{name: "sqltypes nullable pointer_slice (arrays are always native)", typeStyle: writers.NullableTypeSqlTypes, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "text[]", notNull: false, want: "*[]string"},
	}

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			mapper := NewTypeMapper(tt.typeStyle, tt.arrayNullable)
			got := mapper.SQLTypeToGoType(tt.sqlType, tt.notNull)
			if got != tt.want {
				t.Errorf("SQLTypeToGoType(%q, %v) = %q, want %q", tt.sqlType, tt.notNull, got, tt.want)
			}
		})
	}
}

func TestExtraFields_LoadFromMetadata(t *testing.T) {
	tests := []struct {
		name     string
		metadata map[string]interface{}
		expected int
	}{
		{
			name:     "nil metadata",
			metadata: nil,
			expected: 0,
		},
		{
			name: "no extra_fields key",
			metadata: map[string]interface{}{
				"generate_table_name": true,
			},
			expected: 0,
		},
		{
			name: "empty array",
			metadata: map[string]interface{}{
				"extra_fields": []interface{}{},
			},
			expected: 0,
		},
		{
			name: "JSON string format",
			metadata: map[string]interface{}{
				"extra_fields": `[{"name":"ThoughtCount","type":"int64","bun_tag":"thought_count,scanonly","json_tag":"thought_count"}]`,
			},
			expected: 1,
		},
		{
			name: "structured format",
			metadata: map[string]interface{}{
				"extra_fields": []interface{}{
					map[string]interface{}{
						"name":     "ThoughtCount",
						"type":     "int64",
						"bun_tag":  "thought_count,scanonly",
						"json_tag": "thought_count",
					},
				},
			},
			expected: 1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			fields := LoadExtraFieldsFromMetadata(tt.metadata)
			if len(fields) != tt.expected {
				t.Errorf("expected %d fields, got %d", tt.expected, len(fields))
			}
		})
	}
}

func TestExtraFields_InSingleFile(t *testing.T) {
	table := models.InitTable("projects", "public")
	table.Columns["id"] = &models.Column{
		Name:         "id",
		Type:         "bigint",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	table.Columns["name"] = &models.Column{
		Name:     "name",
		Type:     "varchar",
		Length:   255,
		Sequence: 1,
	}

	opts := &writers.WriterOptions{
		PackageName: "models",
		OutputPath:  t.TempDir() + "/test.go",
		Metadata: map[string]interface{}{
			"extra_fields": `[{"name":"ThoughtCount","type":"int64","bun_tag":"thought_count,scanonly","json_tag":"thought_count"}]`,
		},
	}

	writer := NewWriter(opts)
	err := writer.WriteTable(table)
	if err != nil {
		t.Fatalf("WriteTable failed: %v", err)
	}

	content, _ := os.ReadFile(opts.OutputPath)
	generated := string(content)

	// Verify extra field is present with separator comment
	expectations := []string{
		"// --- Custom fields (managed by relspecgo generator config, issue #4) ---",
		"ThoughtCount int64 `bun:\"thought_count,scanonly\" json:\"thought_count\"`",
	}

	for _, expected := range expectations {
		if !strings.Contains(generated, expected) {
			t.Errorf("Generated code missing: %q\nGenerated:\n%s", expected, generated)
		}
	}
}

func TestExtraFields_InMultiFile(t *testing.T) {
	db := models.InitDatabase("testdb")
	schema := models.InitSchema("public")

	users := models.InitTable("users", "public")
	users.Columns["id"] = &models.Column{
		Name:         "id",
		Type:         "bigint",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	schema.Tables = append(schema.Tables, users)

	posts := models.InitTable("posts", "public")
	posts.Columns["id"] = &models.Column{
		Name:         "id",
		Type:         "bigint",
		NotNull:      true,
		IsPrimaryKey: true,
	}
	schema.Tables = append(schema.Tables, posts)

	db.Schemas = append(db.Schemas, schema)

	tmpDir := t.TempDir()
	opts := &writers.WriterOptions{
		PackageName: "models",
		OutputPath:  tmpDir,
		Metadata: map[string]interface{}{
			"multi_file":   true,
			"extra_fields": `[{"target_table":"users","name":"PostCount","type":"int64","bun_tag":"post_count,scanonly","json_tag":"post_count"}]`,
		},
	}

	writer := NewWriter(opts)
	err := writer.WriteDatabase(db)
	if err != nil {
		t.Fatalf("WriteDatabase failed: %v", err)
	}

	// Check users file has the extra field (matched by table name "users")
	usersContent, _ := os.ReadFile(tmpDir + "/sql_public_users.go")
	usersStr := string(usersContent)

	if !strings.Contains(usersStr, "PostCount int64 `bun:\"post_count,scanonly\"") {
		t.Errorf("Extra field not found in users file:\n%s", usersStr)
	}

	// Posts file should NOT have the extra field (name mismatch)
	postsContent, _ := os.ReadFile(tmpDir + "/sql_public_posts.go")
	postsStr := string(postsContent)

	if strings.Contains(postsStr, "PostCount") {
		t.Errorf("Extra field should not be in posts file:\n%s", postsStr)
	}
}

func TestTypeMapper_BuildBunTag_PreservesExplicitTypeModifiers(t *testing.T) {
	mapper := NewTypeMapper("", "")

	col := &models.Column{
		Name:      "embedding",
		Type:      "vector(1536)",
		Length:    1536,
		Precision: 0,
		Scale:     0,
	}

	tag := mapper.BuildBunTag(col, nil)
	if !strings.Contains(tag, "type:vector(1536),") {
		t.Fatalf("expected explicit modifier to be preserved, got %q", tag)
	}
	if strings.Contains(tag, ")(") {
		t.Fatalf("type modifier appears duplicated in %q", tag)
	}
}