package service

import (
	"context"
	"errors"
	"strings"
	"testing"
	"time"

	"github.com/pingcap-inc/clinic/clinic_data_service/pkg/dto"
)

type fakeStatementsEngine struct {
	available bool
	err       error
}

func (e *fakeStatementsEngine) HasDeltaLog(context.Context, *dto.DataSourceInfo) (bool, error) {
	return e.available, e.err
}

func (e *fakeStatementsEngine) Execute(context.Context, string, *dto.DataSourceInfo) (*dto.DataProxyQueryResult, error) {
	return nil, errors.New("unexpected Execute call")
}

func (e *fakeStatementsEngine) Name() string { return "fake-delta" }

func (e *fakeStatementsEngine) Health(context.Context) error { return nil }

func (e *fakeStatementsEngine) GetDatabase(string) string { return "test" }

func (e *fakeStatementsEngine) GetTableSchema(context.Context, string, string, string) (*dto.SchemaResponse, error) {
	return nil, nil
}

func TestStatementsDataAvailable(t *testing.T) {
	ds := &dto.DataSourceInfo{Vendor: "aws", Region: "us-west-2"}

	available, err := statementsDataAvailable(context.Background(), &fakeStatementsEngine{available: true}, ds)
	if err != nil || !available {
		t.Fatalf("available = %v, err = %v; want true, nil", available, err)
	}

	wantErr := errors.New("access denied")
	available, err = statementsDataAvailable(context.Background(), &fakeStatementsEngine{err: wantErr}, ds)
	if available || !errors.Is(err, wantErr) {
		t.Fatalf("available = %v, err = %v; want false, %v", available, err, wantErr)
	}
}

func TestEmptyStatementsResultUsesCanonicalEmptyCollections(t *testing.T) {
	ds := &dto.DataSourceInfo{Vendor: "gcp", Region: "us-central1"}
	result := emptyStatementsResult(&fakeStatementsEngine{}, ds, 25*time.Millisecond)

	if result.Columns == nil || len(result.Columns) != 0 {
		t.Fatalf("columns = %#v, want non-nil empty slice", result.Columns)
	}
	if result.Rows == nil || len(result.Rows) != 0 {
		t.Fatalf("rows = %#v, want non-nil empty slice", result.Rows)
	}
	if result.Metadata.RowCount != 0 || result.Metadata.Engine != "fake-delta" || result.Metadata.Vendor != "gcp" || result.Metadata.Region != "us-central1" {
		t.Fatalf("unexpected metadata: %+v", result.Metadata)
	}
}

func TestValidateAndNormalizeStatementsSQLIgnoresCommentedDate(t *testing.T) {
	commentOnly := `SELECT digest FROM clinic_data_proxy.statements -- date IN ('2026-07-21')`
	if _, err := validateAndNormalizeStatementsSQL(commentOnly); err == nil {
		t.Fatal("commented date must not satisfy the Statements partition filter")
	}

	withRealDate := `SELECT digest FROM clinic_data_proxy.statements WHERE date = '2026-07-21' -- date IN ('2099-01-01')`
	normalized, err := validateAndNormalizeStatementsSQL(withRealDate)
	if err != nil {
		t.Fatalf("valid Statements SQL rejected: %v", err)
	}
	if strings.Contains(normalized, "2099-01-01") {
		t.Fatalf("normalized SQL retained commented partition value: %s", normalized)
	}
}