package mysqlbackend

import (
	"context"
	"testing"
	"time"
)

func TestSchemaManagerCaseInsensitiveLookup(t *testing.T) {
	cache := NewSchemaCache(time.Minute)
	user := "user"
	password := "password"
	key := userKey{user: user, password: password}
	expires := time.Now().Add(time.Minute)

	schema := "Test"
	table := "MixedCaseTable"
	column := "Value"
	tableKeyExact := tableKey{schema: schema, table: table}
	tableKeyLower := normalizeTableKey(schema, table)

	cache.mu.Lock()
	cache.schemas[key] = schemaCacheEntry{
		expires:  expires,
		list:     []string{schema},
		set:      map[string]struct{}{schema: {}},
		lowerSet: map[string]struct{}{normalizeLookup(schema): {}},
	}
	cache.tables[key] = tableCacheEntry{
		expires:             expires,
		list:                []TableInfo{{Schema: schema, Name: table}},
		tableSet:            map[tableKey]struct{}{tableKeyExact: {}},
		tableSetLower:       map[tableKey]struct{}{tableKeyLower: {}},
		tableByLower:        map[tableKey]TableInfo{tableKeyLower: {Schema: schema, Name: table}},
		tableLowerAmbiguous: map[tableKey]struct{}{},
		bySchema:            map[string][]TableInfo{schema: {{Schema: schema, Name: table}}},
	}
	cache.columns[key] = columnCacheEntry{
		expires:      expires,
		list:         []ColumnInfo{{Schema: schema, Table: table, Name: column}},
		byTable:      map[tableKey][]ColumnInfo{tableKeyExact: {{Schema: schema, Table: table, Name: column}}},
		byTableLower: map[tableKey][]ColumnInfo{tableKeyLower: {{Schema: schema, Table: table, Name: column}}},
	}
	cache.mu.Unlock()

	manager := &SchemaManager{cache: cache}
	ctx := context.Background()

	if ok, err := manager.SchemaExists(ctx, user, password, "test"); err != nil || !ok {
		t.Fatalf("SchemaExists(test) = %v, err=%v", ok, err)
	}
	if ok, err := manager.TableExists(ctx, user, password, "test", "mixedcasetable"); err != nil || !ok {
		t.Fatalf("TableExists(test.mixedcasetable) = %v, err=%v", ok, err)
	}
	info, ok, err := manager.ResolveTable(ctx, user, password, "test", "mixedcasetable")
	if err != nil {
		t.Fatalf("ResolveTable(test.mixedcasetable) err=%v", err)
	}
	if !ok || info.Name != table || info.Schema != schema {
		t.Fatalf("ResolveTable unexpected: ok=%v info=%#v", ok, info)
	}
	cols, err := manager.ColumnsForTable(ctx, user, password, "test", "mixedcasetable")
	if err != nil {
		t.Fatalf("ColumnsForTable(test.mixedcasetable) err=%v", err)
	}
	if len(cols) != 1 || cols[0].Name != column {
		t.Fatalf("ColumnsForTable unexpected columns: %#v", cols)
	}
}