package virtualtables

import (
	"context"
	"testing"

	"github.com/everything-on-mysql/cassandra-on-mysql/pkg/cql/parser"
)

func TestVirtualTableExecutor(t *testing.T) {
	registry := NewRegistry()
	executor := NewVirtualTableExecutor(registry)
	ctx := context.Background()

	// Test 1: Query system_views.clients
	t.Run("clients", func(t *testing.T) {
		stmt := &parser.SelectStatement{
			From: &parser.TableName{Schema: "system_views", Name: "clients"},
		}
		result, err := executor.Execute(ctx, stmt, "test_user")
		if err != nil {
			t.Fatalf("Execute failed: %v", err)
		}
		if result == nil {
			t.Fatal("Expected non-nil result")
		}
		if len(result.Columns) == 0 {
			t.Fatal("Expected columns")
		}
		t.Logf("Columns: %v", result.Columns)
		t.Logf("Rows: %d", len(result.Rows))
	})

	// Test 2: Query system_views.settings
	t.Run("settings", func(t *testing.T) {
		stmt := &parser.SelectStatement{
			From: &parser.TableName{Schema: "system_views", Name: "settings"},
		}
		result, err := executor.Execute(ctx, stmt, "test_user")
		if err != nil {
			t.Fatalf("Execute failed: %v", err)
		}
		if result == nil {
			t.Fatal("Expected non-nil result")
		}
		if len(result.Rows) != 0 {
			t.Fatalf("Expected system_views.settings to be empty")
		}
	})

	// Test 3: Query system_virtual_schema.tables
	t.Run("schema_tables", func(t *testing.T) {
		stmt := &parser.SelectStatement{
			From: &parser.TableName{Schema: "system_virtual_schema", Name: "tables"},
		}
		result, err := executor.Execute(ctx, stmt, "test_user")
		if err != nil {
			t.Fatalf("Execute failed: %v", err)
		}
		if result == nil {
			t.Fatal("Expected non-nil result")
		}
		t.Logf("Schema tables rows: %d", len(result.Rows))
	})

	// Test 4: Query system_virtual_schema.columns
	t.Run("schema_columns", func(t *testing.T) {
		stmt := &parser.SelectStatement{
			From: &parser.TableName{Schema: "system_virtual_schema", Name: "columns"},
		}
		result, err := executor.Execute(ctx, stmt, "test_user")
		if err != nil {
			t.Fatalf("Execute failed: %v", err)
		}
		if result == nil {
			t.Fatal("Expected non-nil result")
		}
		t.Logf("Schema columns rows: %d", len(result.Rows))
	})

	// Test 5: Query system_virtual_schema.keyspaces
	t.Run("schema_keyspaces", func(t *testing.T) {
		stmt := &parser.SelectStatement{
			From: &parser.TableName{Schema: "system_virtual_schema", Name: "keyspaces"},
		}
		result, err := executor.Execute(ctx, stmt, "test_user")
		if err != nil {
			t.Fatalf("Execute failed: %v", err)
		}
		if result == nil {
			t.Fatal("Expected non-nil result")
		}
		t.Logf("Schema keyspaces rows: %d", len(result.Rows))
	})

	// Test 6: Query system_views.thread_pools
	t.Run("thread_pools", func(t *testing.T) {
		stmt := &parser.SelectStatement{
			From: &parser.TableName{Schema: "system_views", Name: "thread_pools"},
		}
		result, err := executor.Execute(ctx, stmt, "test_user")
		if err != nil {
			t.Fatalf("Execute failed: %v", err)
		}
		if result == nil {
			t.Fatal("Expected non-nil result")
		}
		t.Logf("Thread pools rows: %d", len(result.Rows))
	})

	// Test 7: Query system_views.system_properties
	t.Run("system_properties", func(t *testing.T) {
		stmt := &parser.SelectStatement{
			From: &parser.TableName{Schema: "system_views", Name: "system_properties"},
		}
		result, err := executor.Execute(ctx, stmt, "test_user")
		if err != nil {
			t.Fatalf("Execute failed: %v", err)
		}
		if result == nil {
			t.Fatal("Expected non-nil result")
		}
		if len(result.Rows) != 0 {
			t.Fatalf("Expected system_views.system_properties to be empty")
		}
	})
}

func TestIsVirtualTableQuery(t *testing.T) {
	tests := []struct {
		name     string
		stmt     *parser.SelectStatement
		expected bool
	}{
		{
			name: "system_views.clients",
			stmt: &parser.SelectStatement{
				From: &parser.TableName{Schema: "system_views", Name: "clients"},
			},
			expected: true,
		},
		{
			name: "system_metrics.all_groups",
			stmt: &parser.SelectStatement{
				From: &parser.TableName{Schema: "system_metrics", Name: "all_groups"},
			},
			expected: true,
		},
		{
			name: "system_accord_debug.constants",
			stmt: &parser.SelectStatement{
				From: &parser.TableName{Schema: "system_accord_debug", Name: "constants"},
			},
			expected: true,
		},
		{
			name: "system_virtual_schema.tables",
			stmt: &parser.SelectStatement{
				From: &parser.TableName{Schema: "system_virtual_schema", Name: "tables"},
			},
			expected: true,
		},
		{
			name: "system_views_custom",
			stmt: &parser.SelectStatement{
				From: &parser.TableName{Schema: "system_views_custom", Name: "clients"},
			},
			expected: false,
		},
		{
			name: "regular_table",
			stmt: &parser.SelectStatement{
				From: &parser.TableName{Schema: "my_keyspace", Name: "my_table"},
			},
			expected: false,
		},
		{
			name:     "nil_statement",
			stmt:     nil,
			expected: false,
		},
		{
			name: "nil_from",
			stmt: &parser.SelectStatement{
				From: nil,
			},
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := IsVirtualTableQuery(tt.stmt)
			if result != tt.expected {
				t.Errorf("IsVirtualTableQuery() = %v, want %v", result, tt.expected)
			}
		})
	}
}