package report

import (
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"time"
	
	"github.com/acmestudio/llm-api-benchmark-tool/benchmark"
	"github.com/acmestudio/llm-api-benchmark-tool/config"
	"github.com/acmestudio/llm-api-benchmark-tool/logger"
	"github.com/go-echarts/go-echarts/v2/charts"
	"github.com/go-echarts/go-echarts/v2/components"
	"github.com/go-echarts/go-echarts/v2/opts"
	"github.com/montanaflynn/stats"
)

// Metrics 表示性能指标
type Metrics struct {
	TotalRequests      int           // 总请求数
	SuccessfulRequests int           // 成功请求数
	FailedRequests     int           // 失败请求数
	TimeoutRatio       float64       // 超时比率
	AvgResponseTime    time.Duration // 平均响应时间
	P90ResponseTime    time.Duration // P90响应时间
	P95ResponseTime    time.Duration // P95响应时间
	P99ResponseTime    time.Duration // P99响应时间
	MaxResponseTime    time.Duration // 最大响应时间
	MinResponseTime    time.Duration // 最小响应时间
	AvgQPS             float64       // 平均QPS
	MaxQPS             float64       // 最大QPS
	AvgTokenRate       float64       // 平均Token生成速率
	MaxTokenRate       float64       // 最大Token生成速率
	MaxConcurrency     int           // 最大有效并发用户数
}

// GenerateReport 生成性能报告
func GenerateReport(results *benchmark.BenchmarkResults, cfg *config.Config, outputPath string) error {
	// 创建输出目录
	logger.Info("创建报告输出目录: %s", outputPath)
	if err := os.MkdirAll(outputPath, 0755); err != nil {
		return fmt.Errorf("创建输出目录失败: %w", err)
	}
	
	// 检查结果是否为空
	if len(results.Results) == 0 {
		logger.Warn("没有测试结果数据，无法生成详细报告")
	} else {
		logger.Debug("共有 %d 条测试结果记录", len(results.Results))
	}
	
	// 计算性能指标
	logger.Info("计算性能指标...")
	metrics := calculateMetrics(results)
	
	// 输出主要性能指标
	logger.Info("性能指标摘要:")
	logger.Info("  总请求数: %d (成功: %d, 失败: %d)", 
		metrics.TotalRequests, metrics.SuccessfulRequests, metrics.FailedRequests)
	logger.Info("  超时比率: %.2f%%", metrics.TimeoutRatio * 100)
	logger.Info("  平均响应时间: %v", metrics.AvgResponseTime)
	logger.Info("  P90响应时间: %v", metrics.P90ResponseTime)
	logger.Info("  P95响应时间: %v", metrics.P95ResponseTime)
	logger.Info("  P99响应时间: %v", metrics.P99ResponseTime)
	logger.Info("  平均QPS: %.2f", metrics.AvgQPS)
	logger.Info("  最大QPS: %.2f", metrics.MaxQPS)
	logger.Info("  平均Token生成速率: %.2f tokens/s", metrics.AvgTokenRate)
	logger.Info("  最大Token生成速率: %.2f tokens/s", metrics.MaxTokenRate)
	logger.Info("  最大有效并发用户数: %d", metrics.MaxConcurrency)
	
	// 生成HTML报告
	logger.Info("生成HTML报告...")
	if err := generateHTMLReport(results, metrics, cfg, outputPath); err != nil {
		return fmt.Errorf("生成HTML报告失败: %w", err)
	}
	
	// 生成CSV数据
	logger.Info("生成CSV数据...")
	if err := generateCSVData(results, outputPath); err != nil {
		return fmt.Errorf("生成CSV数据失败: %w", err)
	}
	
	logger.Info("报告生成完成")
	return nil
}

// calculateMetrics 计算性能指标
func calculateMetrics(results *benchmark.BenchmarkResults) *Metrics {
	metrics := &Metrics{}
	
	// 总请求数
	metrics.TotalRequests = len(results.Results)
	logger.Debug("计算指标 - 总请求数: %d", metrics.TotalRequests)
	
	// 统计成功和失败请求
	var successfulRequests []benchmark.Result
	for _, result := range results.Results {
		if result.Error == nil {
			successfulRequests = append(successfulRequests, result)
		}
	}
	
	metrics.SuccessfulRequests = len(successfulRequests)
	metrics.FailedRequests = metrics.TotalRequests - metrics.SuccessfulRequests
	logger.Debug("计算指标 - 成功请求: %d, 失败请求: %d", 
		metrics.SuccessfulRequests, metrics.FailedRequests)
	
	// 计算超时比率
	metrics.TimeoutRatio = float64(metrics.FailedRequests) / float64(metrics.TotalRequests)
	logger.Debug("计算指标 - 超时比率: %.2f%%", metrics.TimeoutRatio * 100)
	
	// 如果没有成功的请求，返回
	if len(successfulRequests) == 0 {
		logger.Warn("没有成功的请求，无法计算详细指标")
		return metrics
	}
	
	// 计算响应时间指标
	var responseTimes []float64
	for _, result := range successfulRequests {
		responseTimes = append(responseTimes, float64(result.ResponseTime.Milliseconds()))
	}
	
	// 排序响应时间
	sort.Float64s(responseTimes)
	
	// 计算响应时间百分位数
	p90, _ := stats.Percentile(responseTimes, 90)
	p95, _ := stats.Percentile(responseTimes, 95)
	p99, _ := stats.Percentile(responseTimes, 99)
	avg, _ := stats.Mean(responseTimes)
	max := responseTimes[len(responseTimes)-1]
	min := responseTimes[0]
	
	metrics.AvgResponseTime = time.Duration(avg) * time.Millisecond
	metrics.P90ResponseTime = time.Duration(p90) * time.Millisecond
	metrics.P95ResponseTime = time.Duration(p95) * time.Millisecond
	metrics.P99ResponseTime = time.Duration(p99) * time.Millisecond
	metrics.MaxResponseTime = time.Duration(max) * time.Millisecond
	metrics.MinResponseTime = time.Duration(min) * time.Millisecond
	
	logger.Debug("计算指标 - 响应时间(ms) - 平均: %.2f, P90: %.2f, P95: %.2f, P99: %.2f, 最小: %.2f, 最大: %.2f",
		avg, p90, p95, p99, min, max)
	
	// 计算QPS
	totalDuration := results.EndTime.Sub(results.StartTime).Seconds()
	metrics.AvgQPS = float64(metrics.SuccessfulRequests) / totalDuration
	logger.Debug("计算指标 - 平均QPS: %.2f (总持续时间: %.2f秒)", metrics.AvgQPS, totalDuration)
	
	// 计算每个并发步骤的QPS
	logger.Debug("计算各并发步骤的QPS...")
	for concurrency, stepResults := range results.ConcurrencyData {
		// 找出该步骤的第一个和最后一个请求
		if len(stepResults) == 0 {
			logger.Debug("  并发步骤 %d: 没有请求数据", concurrency)
			continue
		}
		
		// 排序结果，按时间戳
		sort.Slice(stepResults, func(i, j int) bool {
			return stepResults[i].Timestamp.Before(stepResults[j].Timestamp)
		})
		
		firstRequest := stepResults[0]
		lastRequest := stepResults[len(stepResults)-1]
		
		// 计算持续时间
		stepDuration := lastRequest.Timestamp.Sub(firstRequest.Timestamp).Seconds()
		if stepDuration <= 0 {
			logger.Debug("  并发步骤 %d: 持续时间过短", concurrency)
			continue
		}
		
		// 计算成功请求数
		var successCount int
		for _, result := range stepResults {
			if result.Error == nil {
				successCount++
			}
		}
		
		// 计算QPS
		stepQPS := float64(successCount) / stepDuration
		logger.Debug("  并发步骤 %d: QPS = %.2f (成功请求: %d, 持续时间: %.2f秒)", 
			concurrency, stepQPS, successCount, stepDuration)
		
		if stepQPS > metrics.MaxQPS {
			metrics.MaxQPS = stepQPS
			logger.Debug("  更新最大QPS: %.2f (并发步骤: %d)", metrics.MaxQPS, concurrency)
		}
		
		// 更新最大并发用户数
		if concurrency > metrics.MaxConcurrency && stepQPS > 0 {
			metrics.MaxConcurrency = concurrency
			logger.Debug("  更新最大有效并发用户数: %d", metrics.MaxConcurrency)
		}
	}
	
	// 计算Token生成速率
	var totalTokens int
	for _, result := range successfulRequests {
		totalTokens += result.CompletionTokens
	}
	
	metrics.AvgTokenRate = float64(totalTokens) / totalDuration
	logger.Debug("计算指标 - 平均Token生成速率: %.2f tokens/s (总Token: %d)", 
		metrics.AvgTokenRate, totalTokens)
	
	// 计算每个并发步骤的Token生成速率
	logger.Debug("计算各并发步骤的Token生成速率...")
	for concurrency, stepResults := range results.ConcurrencyData {
		// 找出该步骤的第一个和最后一个请求
		if len(stepResults) == 0 {
			continue
		}
		
		// 排序结果，按时间戳
		sort.Slice(stepResults, func(i, j int) bool {
			return stepResults[i].Timestamp.Before(stepResults[j].Timestamp)
		})
		
		firstRequest := stepResults[0]
		lastRequest := stepResults[len(stepResults)-1]
		
		// 计算持续时间
		stepDuration := lastRequest.Timestamp.Sub(firstRequest.Timestamp).Seconds()
		if stepDuration <= 0 {
			continue
		}
		
		// 计算总Token数
		var stepTokens int
		for _, result := range stepResults {
			if result.Error == nil {
				stepTokens += result.CompletionTokens
			}
		}
		
		// 计算Token生成速率
		stepTokenRate := float64(stepTokens) / stepDuration
		logger.Debug("  并发步骤 %d: Token生成速率 = %.2f tokens/s (总Token: %d, 持续时间: %.2f秒)", 
			concurrency, stepTokenRate, stepTokens, stepDuration)
		
		if stepTokenRate > metrics.MaxTokenRate {
			metrics.MaxTokenRate = stepTokenRate
			logger.Debug("  更新最大Token生成速率: %.2f tokens/s (并发步骤: %d)", 
				metrics.MaxTokenRate, concurrency)
		}
	}
	
	return metrics
}

// generateHTMLReport 生成HTML报告
func generateHTMLReport(results *benchmark.BenchmarkResults, metrics *Metrics, cfg *config.Config, outputPath string) error {
	// 创建页面
	logger.Debug("创建HTML报告页面...")
	page := components.NewPage()
	page.PageTitle = "LLM API 基准测试报告"
	page.Theme = "white"
	
	// 添加概述
	logger.Debug("添加概述图表...")
	page.AddCharts(createOverviewChart(results, metrics, cfg))
	
	// 添加响应时间分布图
	logger.Debug("添加响应时间分布图...")
	page.AddCharts(createResponseTimeDistributionChart(results))
	
	// 添加QPS随时间变化图
	logger.Debug("添加QPS随时间变化图...")
	page.AddCharts(createQPSOverTimeChart(results))
	
	// 添加Token生成速率随时间变化图
	logger.Debug("添加Token生成速率随时间变化图...")
	page.AddCharts(createTokenRateOverTimeChart(results))
	
	// 添加并发与响应时间关系图
	logger.Debug("添加并发与响应时间关系图...")
	page.AddCharts(createConcurrencyVsResponseTimeChart(results))
	
	// 保存HTML报告
	htmlPath := filepath.Join(outputPath, "report.html")
	logger.Debug("保存HTML报告: %s", htmlPath)
	f, err := os.Create(htmlPath)
	if err != nil {
		return err
	}
	defer f.Close()
	
	return page.Render(f)
}

// createOverviewChart 创建概述图表
func createOverviewChart(results *benchmark.BenchmarkResults, metrics *Metrics, cfg *config.Config) *charts.Bar {
	// 创建图表
	chart := charts.NewBar()
	chart.SetGlobalOptions(
		charts.WithTitleOpts(opts.Title{
			Title: "性能指标概述",
		}),
	)
	
	// 添加数据
	chart.SetXAxis([]string{"平均响应时间 (ms)", "P90响应时间 (ms)", "P95响应时间 (ms)", "P99响应时间 (ms)"})
	chart.AddSeries("响应时间", []opts.BarData{
		{Value: metrics.AvgResponseTime.Milliseconds()},
		{Value: metrics.P90ResponseTime.Milliseconds()},
		{Value: metrics.P95ResponseTime.Milliseconds()},
		{Value: metrics.P99ResponseTime.Milliseconds()},
	})
	
	return chart
}

// createResponseTimeDistributionChart 创建响应时间分布图
func createResponseTimeDistributionChart(results *benchmark.BenchmarkResults) *charts.Bar {
	// 创建图表
	chart := charts.NewBar()
	chart.SetGlobalOptions(
		charts.WithTitleOpts(opts.Title{
			Title: "响应时间分布",
		}),
	)
	
	// 统计响应时间分布
	timeRanges := []int{100, 200, 500, 1000, 2000, 5000, 10000}
	counts := make([]int, len(timeRanges)+1)
	
	for _, result := range results.Results {
		if result.Error != nil {
			continue
		}
		
		responseTime := result.ResponseTime.Milliseconds()
		found := false
		
		for i, timeRange := range timeRanges {
			if responseTime <= int64(timeRange) {
				counts[i]++
				found = true
				break
			}
		}
		
		if !found {
			counts[len(timeRanges)]++
		}
	}
	
	// 构建X轴标签
	xAxisLabels := make([]string, len(timeRanges)+1)
	for i, timeRange := range timeRanges {
		if i == 0 {
			xAxisLabels[i] = fmt.Sprintf("≤%dms", timeRange)
		} else {
			xAxisLabels[i] = fmt.Sprintf("%d-%dms", timeRanges[i-1], timeRange)
		}
	}
	xAxisLabels[len(timeRanges)] = fmt.Sprintf(">%dms", timeRanges[len(timeRanges)-1])
	
	// 添加数据
	chart.SetXAxis(xAxisLabels)
	
	barData := make([]opts.BarData, len(counts))
	for i, count := range counts {
		barData[i] = opts.BarData{Value: count}
	}
	
	chart.AddSeries("请求数", barData)
	
	return chart
}

// createQPSOverTimeChart 创建QPS随时间变化图
func createQPSOverTimeChart(results *benchmark.BenchmarkResults) *charts.Line {
	// 创建图表
	chart := charts.NewLine()
	chart.SetGlobalOptions(
		charts.WithTitleOpts(opts.Title{
			Title: "QPS随时间变化",
		}),
	)
	
	// 按并发步骤分组
	for concurrency, stepResults := range results.ConcurrencyData {
		// 按时间窗口统计QPS
		windowSize := 5 * time.Second
		
		// 找出该步骤的第一个和最后一个请求
		if len(stepResults) == 0 {
			continue
		}
		
		// 排序结果，按时间戳
		sort.Slice(stepResults, func(i, j int) bool {
			return stepResults[i].Timestamp.Before(stepResults[j].Timestamp)
		})
		
		firstRequest := stepResults[0]
		lastRequest := stepResults[len(stepResults)-1]
		
		// 计算时间窗口数
		duration := lastRequest.Timestamp.Sub(firstRequest.Timestamp)
		windowCount := int(duration / windowSize) + 1
		
		// 初始化时间窗口
		windows := make([]time.Time, windowCount)
		counts := make([]int, windowCount)
		
		for i := 0; i < windowCount; i++ {
			windows[i] = firstRequest.Timestamp.Add(time.Duration(i) * windowSize)
		}
		
		// 统计每个时间窗口的请求数
		for _, result := range stepResults {
			if result.Error != nil {
				continue
			}
			
			windowIndex := int(result.Timestamp.Sub(firstRequest.Timestamp) / windowSize)
			if windowIndex >= 0 && windowIndex < windowCount {
				counts[windowIndex]++
			}
		}
		
		// 计算QPS
		qpsData := make([]opts.LineData, windowCount)
		xAxisData := make([]string, windowCount)
		
		for i := 0; i < windowCount; i++ {
			qps := float64(counts[i]) / windowSize.Seconds()
			qpsData[i] = opts.LineData{Value: qps}
			xAxisData[i] = windows[i].Format("15:04:05")
		}
		
		// 添加数据
		chart.SetXAxis(xAxisData)
		chart.AddSeries(fmt.Sprintf("并发 %d", concurrency), qpsData)
	}
	
	return chart
}

// createTokenRateOverTimeChart 创建Token生成速率随时间变化图
func createTokenRateOverTimeChart(results *benchmark.BenchmarkResults) *charts.Line {
	// 创建图表
	chart := charts.NewLine()
	chart.SetGlobalOptions(
		charts.WithTitleOpts(opts.Title{
			Title: "Token生成速率随时间变化",
		}),
	)
	
	// 按并发步骤分组
	for concurrency, stepResults := range results.ConcurrencyData {
		// 按时间窗口统计Token生成速率
		windowSize := 5 * time.Second
		
		// 找出该步骤的第一个和最后一个请求
		if len(stepResults) == 0 {
			continue
		}
		
		// 排序结果，按时间戳
		sort.Slice(stepResults, func(i, j int) bool {
			return stepResults[i].Timestamp.Before(stepResults[j].Timestamp)
		})
		
		firstRequest := stepResults[0]
		lastRequest := stepResults[len(stepResults)-1]
		
		// 计算时间窗口数
		duration := lastRequest.Timestamp.Sub(firstRequest.Timestamp)
		windowCount := int(duration / windowSize) + 1
		
		// 初始化时间窗口
		windows := make([]time.Time, windowCount)
		tokens := make([]int, windowCount)
		
		for i := 0; i < windowCount; i++ {
			windows[i] = firstRequest.Timestamp.Add(time.Duration(i) * windowSize)
		}
		
		// 统计每个时间窗口的Token数
		for _, result := range stepResults {
			if result.Error != nil {
				continue
			}
			
			windowIndex := int(result.Timestamp.Sub(firstRequest.Timestamp) / windowSize)
			if windowIndex >= 0 && windowIndex < windowCount {
				tokens[windowIndex] += result.CompletionTokens
			}
		}
		
		// 计算Token生成速率
		tokenRateData := make([]opts.LineData, windowCount)
		xAxisData := make([]string, windowCount)
		
		for i := 0; i < windowCount; i++ {
			tokenRate := float64(tokens[i]) / windowSize.Seconds()
			tokenRateData[i] = opts.LineData{Value: tokenRate}
			xAxisData[i] = windows[i].Format("15:04:05")
		}
		
		// 添加数据
		chart.SetXAxis(xAxisData)
		chart.AddSeries(fmt.Sprintf("并发 %d", concurrency), tokenRateData)
	}
	
	return chart
}

// createConcurrencyVsResponseTimeChart 创建并发与响应时间关系图
func createConcurrencyVsResponseTimeChart(results *benchmark.BenchmarkResults) *charts.Line {
	// 创建图表
	chart := charts.NewLine()
	chart.SetGlobalOptions(
		charts.WithTitleOpts(opts.Title{
			Title: "并发与响应时间关系",
		}),
	)
	
	// 准备数据
	var concurrencies []int
	var avgResponseTimes []opts.LineData
	var p90ResponseTimes []opts.LineData
	var p95ResponseTimes []opts.LineData
	
	// 按并发步骤排序
	for concurrency := range results.ConcurrencyData {
		concurrencies = append(concurrencies, concurrency)
	}
	sort.Ints(concurrencies)
	
	// 计算每个并发步骤的响应时间
	for _, concurrency := range concurrencies {
		stepResults := results.ConcurrencyData[concurrency]
		
		// 收集成功请求的响应时间
		var responseTimes []float64
		for _, result := range stepResults {
			if result.Error == nil {
				responseTimes = append(responseTimes, float64(result.ResponseTime.Milliseconds()))
			}
		}
		
		// 如果没有成功的请求，跳过
		if len(responseTimes) == 0 {
			avgResponseTimes = append(avgResponseTimes, opts.LineData{Value: 0})
			p90ResponseTimes = append(p90ResponseTimes, opts.LineData{Value: 0})
			p95ResponseTimes = append(p95ResponseTimes, opts.LineData{Value: 0})
			continue
		}
		
		// 计算响应时间指标
		avg, _ := stats.Mean(responseTimes)
		p90, _ := stats.Percentile(responseTimes, 90)
		p95, _ := stats.Percentile(responseTimes, 95)
		
		avgResponseTimes = append(avgResponseTimes, opts.LineData{Value: avg})
		p90ResponseTimes = append(p90ResponseTimes, opts.LineData{Value: p90})
		p95ResponseTimes = append(p95ResponseTimes, opts.LineData{Value: p95})
	}
	
	// 将并发数转换为字符串
	xAxisData := make([]string, len(concurrencies))
	for i, concurrency := range concurrencies {
		xAxisData[i] = fmt.Sprintf("%d", concurrency)
	}
	
	// 添加数据
	chart.SetXAxis(xAxisData)
	chart.AddSeries("平均响应时间 (ms)", avgResponseTimes)
	chart.AddSeries("P90响应时间 (ms)", p90ResponseTimes)
	chart.AddSeries("P95响应时间 (ms)", p95ResponseTimes)
	
	return chart
}

// generateCSVData 生成CSV数据
func generateCSVData(results *benchmark.BenchmarkResults, outputPath string) error {
	// 创建CSV文件
	csvPath := filepath.Join(outputPath, "results.csv")
	logger.Debug("创建CSV文件: %s", csvPath)
	f, err := os.Create(csvPath)
	if err != nil {
		return err
	}
	defer f.Close()
	
	// 写入CSV头
	logger.Debug("写入CSV头...")
	_, err = f.WriteString("Timestamp,PromptType,PromptTokens,CompletionTokens,ResponseTime,Concurrency,Error\n")
	if err != nil {
		return err
	}
	
	// 检查结果是否为空
	if len(results.Results) == 0 {
		logger.Warn("没有测试结果数据，CSV文件将只包含表头")
		return nil
	}
	
	// 写入CSV数据
	logger.Debug("写入CSV数据，共%d条记录...", len(results.Results))
	for _, result := range results.Results {
		// 格式化错误信息
		errorMsg := ""
		if result.Error != nil {
			errorMsg = result.Error.Error()
		}
		
		// 写入一行数据
		line := fmt.Sprintf("%s,%s,%d,%d,%d,%d,%s\n",
			result.Timestamp.Format(time.RFC3339),
			result.PromptType,
			result.PromptTokens,
			result.CompletionTokens,
			result.ResponseTime.Milliseconds(),
			result.Concurrency,
			errorMsg,
		)
		
		_, err = f.WriteString(line)
		if err != nil {
			return err
		}
	}
	
	logger.Debug("CSV数据写入完成")
	return nil
}