package app

import (
	"testing"

	"GoNavi-Wails/internal/connection"
)

func TestNormalizeSchemaAndTable_SQLServerKeepsDatabaseAndQualifiedTable(t *testing.T) {
	t.Parallel()

	schemaOrDb, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type:     "sqlserver",
		Database: "master",
	}, "biz_db", "dbo.users")

	if schemaOrDb != "biz_db" {
		t.Fatalf("expected sqlserver first return value as database name, got %q", schemaOrDb)
	}
	if table != "dbo.users" {
		t.Fatalf("expected sqlserver table name keep qualified form, got %q", table)
	}
}

func TestNormalizeSchemaAndTable_SQLServerFallbackToConfigDatabase(t *testing.T) {
	t.Parallel()

	schemaOrDb, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type:     "sqlserver",
		Database: "biz_db",
	}, "", "dbo.users")

	if schemaOrDb != "biz_db" {
		t.Fatalf("expected sqlserver fallback database from config, got %q", schemaOrDb)
	}
	if table != "dbo.users" {
		t.Fatalf("expected sqlserver table name keep qualified form, got %q", table)
	}
}

func TestNormalizeSchemaAndTable_PostgresStillSplitsQualifiedName(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "postgres",
	}, "demo_db", "public.orders")

	if schema != "public" || table != "orders" {
		t.Fatalf("expected postgres qualified split to public.orders, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_KingbaseNormalizesEscapedQualifiedName(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "kingbase",
	}, "demo_db", `\"Idf_server\".\"mes_bip_wip_finished\"`)

	if schema != "Idf_server" || table != "mes_bip_wip_finished" {
		t.Fatalf("expected kingbase qualified split to Idf_server.mes_bip_wip_finished, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_KingbasePureTableUsesCurrentSearchPath(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "kingbase",
	}, "demo_db", "users")

	if schema != "" || table != "users" {
		t.Fatalf("expected kingbase pure table to use current search_path, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_PGLikePureTableKeepsPublicFallback(t *testing.T) {
	t.Parallel()

	for _, dbType := range []string{"postgres", "highgo", "vastbase", "opengauss"} {
		t.Run(dbType, func(t *testing.T) {
			t.Parallel()

			schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
				Type: dbType,
			}, "demo_db", "users")

			if schema != "public" || table != "users" {
				t.Fatalf("expected %s pure table to keep public fallback, got %q.%q", dbType, schema, table)
			}
		})
	}
}

func TestNormalizeMetadataSchemaAndTable_PGLikePureTableUsesSearchPath(t *testing.T) {
	t.Parallel()

	for _, dbType := range []string{"postgres", "highgo", "vastbase", "opengauss", "kingbase"} {
		t.Run(dbType, func(t *testing.T) {
			t.Parallel()

			schema, table := normalizeMetadataSchemaAndTable(connection.ConnectionConfig{
				Type: dbType,
			}, "demo_db", "users")

			if schema != "" || table != "users" {
				t.Fatalf("expected %s metadata pure table to use search_path, got %q.%q", dbType, schema, table)
			}
		})
	}
}

func TestNormalizeMetadataSchemaAndTable_PGLikeQualifiedTableKeepsSchema(t *testing.T) {
	t.Parallel()

	schema, table := normalizeMetadataSchemaAndTable(connection.ConnectionConfig{
		Type: "postgres",
	}, "demo_db", `"audit.schema"."order.items"`)

	if schema != "audit.schema" || table != "order.items" {
		t.Fatalf("expected metadata qualified table to keep schema/table, got %q.%q", schema, table)
	}
}

func TestNormalizeMetadataSchemaAndTable_PGLikeDottedUnquotedTableKeepsFallback(t *testing.T) {
	t.Parallel()

	schema, table := normalizeMetadataSchemaAndTable(connection.ConnectionConfig{
		Type: "postgres",
	}, "demo_db", "audit.users")

	if schema != "audit" || table != "users" {
		t.Fatalf("expected metadata dotted table to keep explicit schema, got %q.%q", schema, table)
	}
}

func TestNormalizeMetadataSchemaAndTable_PGLikeQuotedDottedTableUsesSearchPath(t *testing.T) {
	t.Parallel()

	schema, table := normalizeMetadataSchemaAndTable(connection.ConnectionConfig{
		Type: "postgres",
	}, "demo_db", `"order.items"`)

	if schema != "" || table != "order.items" {
		t.Fatalf("expected quoted dotted metadata table to use search_path, got %q.%q", schema, table)
	}
}

func TestNormalizeMetadataSchemaAndTable_NonPGLikeKeepsNormalBehavior(t *testing.T) {
	t.Parallel()

	schema, table := normalizeMetadataSchemaAndTable(connection.ConnectionConfig{
		Type: "mysql",
	}, "demo_db", "users")

	if schema != "demo_db" || table != "users" {
		t.Fatalf("expected mysql metadata to keep db/table behavior, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_PGLikePureTableStillSplitsKingbaseSearchPathOnlyInMetadata(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "kingbase",
	}, "demo_db", "users")

	if schema != "" || table != "users" {
		t.Fatalf("expected kingbase normal path to keep existing search_path behavior, got %q.%q", schema, table)
	}
}

func TestNormalizeMetadataSchemaAndTable_PGLikePreservesNormalFallbackForQuotedQualifiedTable(t *testing.T) {
	t.Parallel()

	for _, dbType := range []string{"highgo", "vastbase", "opengauss"} {
		t.Run(dbType, func(t *testing.T) {
			t.Parallel()

			schema, table := normalizeMetadataSchemaAndTable(connection.ConnectionConfig{
				Type: dbType,
			}, "demo_db", `"audit"."users"`)

			if schema != "audit" || table != "users" {
				t.Fatalf("expected %s metadata qualified table to keep schema, got %q.%q", dbType, schema, table)
			}
		})
	}
}

func TestNormalizeRunConfig_OceanBaseOracleKeepsServiceName(t *testing.T) {
	t.Parallel()

	config := connection.ConnectionConfig{
		Type:              "oceanbase",
		Database:          "OBORCL",
		OceanBaseProtocol: "oracle",
	}
	runConfig := normalizeRunConfig(config, "SYS")

	if runConfig.Database != "OBORCL" {
		t.Fatalf("expected OceanBase Oracle service name to stay OBORCL, got %q", runConfig.Database)
	}
}

func TestNormalizeRunConfig_StarRocksUsesDatabaseFromTree(t *testing.T) {
	t.Parallel()

	runConfig := normalizeRunConfig(connection.ConnectionConfig{
		Type:     "starrocks",
		Database: "default_cluster",
	}, "analytics")

	if runConfig.Database != "analytics" {
		t.Fatalf("expected StarRocks database from tree, got %q", runConfig.Database)
	}
}

func TestNormalizeRunConfig_IRISUsesNamespaceFromTree(t *testing.T) {
	t.Parallel()

	runConfig := normalizeRunConfig(connection.ConnectionConfig{
		Type:     "iris",
		Database: "USER",
	}, "APP")

	if runConfig.Database != "APP" {
		t.Fatalf("expected IRIS namespace from tree, got %q", runConfig.Database)
	}
}

func TestNormalizeRunConfig_RedisAllowsDatabaseIndexAboveDefault(t *testing.T) {
	t.Parallel()

	runConfig := normalizeRunConfig(connection.ConnectionConfig{
		Type:    "redis",
		RedisDB: 0,
	}, "31")

	if runConfig.Database != "31" || runConfig.RedisDB != 31 {
		t.Fatalf("expected Redis db31 from tree, got database=%q redisDB=%d", runConfig.Database, runConfig.RedisDB)
	}
}

func TestNormalizeSchemaAndTable_IRISDoesNotTreatNamespaceAsSchema(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "iris",
	}, "USER", "Person")

	if schema != "" || table != "Person" {
		t.Fatalf("expected IRIS pure table to omit schema, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_IRISSplitsQualifiedTable(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "iris",
	}, "USER", `"Sample.Schema"."Person.Table"`)

	if schema != "Sample.Schema" || table != "Person.Table" {
		t.Fatalf("expected IRIS qualified table split, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_OceanBaseOracleUsesSchemaFromDatabaseTree(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type:              "oceanbase",
		OceanBaseProtocol: "oracle",
	}, "SYS", "ORDERS")

	if schema != "SYS" || table != "ORDERS" {
		t.Fatalf("expected OceanBase Oracle schema/table SYS.ORDERS, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_DuckDBPreservesQuotedQualifiedName(t *testing.T) {
	t.Parallel()

	schemaOrDb, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "duckdb",
	}, `"analytics.catalog"."main.schema"`, `"daily.events"."2026.06"`)

	if schemaOrDb != `"analytics.catalog"."main.schema"` {
		t.Fatalf("expected duckdb dbName/catalog path preserved, got %q", schemaOrDb)
	}
	if table != `"daily.events"."2026.06"` {
		t.Fatalf("expected duckdb qualified table preserved, got %q", table)
	}
}

func TestQuoteTableIdentByType_KingbaseNormalizesQuotedQualifiedTable(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTableByType("kingbase", "", `\"Idf_server\".\"mes_bip_wip_finished\"`)
	if schema != "Idf_server" || table != "mes_bip_wip_finished" {
		t.Fatalf("expected kingbase qualified split to Idf_server.mes_bip_wip_finished, got %q.%q", schema, table)
	}

	if got := quoteTableIdentByType("kingbase", schema, table); got != `"Idf_server".mes_bip_wip_finished` {
		t.Fatalf("unexpected kingbase table identifier: %s", got)
	}
}
