package file

import (
	"context"
	"os"
	"path/filepath"
	"testing"
	"time"

	"git.pyer.club/kingecg/gotidb/pkg/engine"
)

// TestFileEngine 测试文件引擎的基本功能
func TestFileEngine(t *testing.T) {
	// 创建临时目录
	tempDir, err := os.MkdirTemp("", "gotidb_test")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	// 创建引擎配置
	config := &engine.FileEngineConfig{
		DataDir:          tempDir,
		SegmentSize:      1024 * 1024, // 1MB
		MaxSegments:      10,
		WriteBufferSize:  1000,
		IndexCacheSize:   1024 * 1024, // 1MB
		UseCompression:   false,
		CompressionLevel: 0,
		CompactThreshold: 0.7,
		MaxOpenFiles:     100,
		SyncWrites:       true,
		RetentionPeriod:  24 * time.Hour,
	}

	// 创建引擎
	e, err := NewFileEngine(engine.EngineConfig{
		Type:       "file",
		FileConfig: config,
	})
	if err != nil {
		t.Fatalf("Failed to create file engine: %v", err)
	}

	// 打开引擎
	if err := e.Open(); err != nil {
		t.Fatalf("Failed to open engine: %v", err)
	}
	defer e.Close()

	// 写入测试数据
	ctx := context.Background()
	points := []engine.DataPoint{
		{
			Timestamp: time.Now().UnixNano(),
			Value:     1.0,
			Labels: map[string]string{
				"host":   "server1",
				"region": "us-west",
			},
		},
		{
			Timestamp: time.Now().Add(time.Second).UnixNano(),
			Value:     2.0,
			Labels: map[string]string{
				"host":   "server1",
				"region": "us-west",
			},
		},
		{
			Timestamp: time.Now().Add(2 * time.Second).UnixNano(),
			Value:     3.0,
			Labels: map[string]string{
				"host":   "server2",
				"region": "us-east",
			},
		},
	}

	// 写入数据
	if err := e.Write(ctx, points); err != nil {
		t.Fatalf("Failed to write points: %v", err)
	}

	// 查询原始数据
	query := engine.Query{
		Type:      engine.QueryTypeRaw,
		StartTime: time.Now().Add(-time.Minute).UnixNano(),
		EndTime:   time.Now().Add(time.Minute).UnixNano(),
		Tags: map[string]string{
			"host": "server1",
		},
		Limit: 10,
	}

	result, err := e.Query(ctx, query)
	if err != nil {
		t.Fatalf("Failed to query: %v", err)
	}

	// 验证查询结果
	if len(result) == 0 {
		t.Fatalf("Expected non-empty result")
	}

	// 检查结果中的数据点数量
	seriesResult := result[0]
	if len(seriesResult.Points) != 2 {
		t.Fatalf("Expected 2 points, got %d", len(seriesResult.Points))
	}

	// 查询最新数据
	latestQuery := engine.Query{
		Type:      engine.QueryTypeLatest,
		StartTime: time.Now().Add(-time.Minute).UnixNano(),
		EndTime:   time.Now().Add(time.Minute).UnixNano(),
		Tags: map[string]string{
			"host": "server1",
		},
	}

	latestResult, err := e.Query(ctx, latestQuery)
	if err != nil {
		t.Fatalf("Failed to query latest: %v", err)
	}

	// 验证最新查询结果
	if len(latestResult) == 0 {
		t.Fatalf("Expected non-empty latest result")
	}

	// 检查最新结果中的数据点
	latestSeriesResult := latestResult[0]
	if len(latestSeriesResult.Points) != 1 {
		t.Fatalf("Expected 1 point in latest result, got %d", len(latestSeriesResult.Points))
	}

	// 查询聚合数据
	aggQuery := engine.Query{
		Type:          engine.QueryTypeAggregate,
		StartTime:     time.Now().Add(-time.Minute).UnixNano(),
		EndTime:       time.Now().Add(time.Minute).UnixNano(),
		AggregateType: engine.AggregateTypeAvg,
		Tags: map[string]string{
			"host": "server1",
		},
	}

	aggResult, err := e.Query(ctx, aggQuery)
	if err != nil {
		t.Fatalf("Failed to query aggregate: %v", err)
	}

	// 验证聚合查询结果
	if len(aggResult) == 0 {
		t.Fatalf("Expected non-empty aggregate result")
	}

	// 检查聚合结果中的数据点
	aggSeriesResult := aggResult[0]
	if len(aggSeriesResult.Points) != 1 {
		t.Fatalf("Expected 1 point in aggregate result, got %d", len(aggSeriesResult.Points))
	}

	// 验证平均值
	avgValue := aggSeriesResult.Points[0].Value
	if avgValue != 1.5 { // (1.0 + 2.0) / 2 = 1.5
		t.Fatalf("Expected avg value 1.5, got %f", avgValue)
	}

	// 获取引擎统计信息
	stats := e.Stats()
	if stats.PointsCount != 3 {
		t.Fatalf("Expected 3 points in stats, got %d", stats.PointsCount)
	}

	// 检查段文件是否创建
	files, err := os.ReadDir(tempDir)
	if err != nil {
		t.Fatalf("Failed to read data directory: %v", err)
	}
	if len(files) == 0 {
		t.Fatalf("Expected segment files to be created")
	}

	// 检查是否有.seg文件
	var segFileFound bool
	for _, file := range files {
		if filepath.Ext(file.Name()) == ".seg" {
			segFileFound = true
			break
		}
	}
	if !segFileFound {
		t.Fatalf("Expected .seg files to be created")
	}
}