/*
calculator_test.go - 计算器测试文件
测试计算器的各种功能
*/

package main

import (
	"fmt"
	"testing"

	"./calculator"
)

// TestBasicOperations 测试基本运算
func TestBasicOperations(t *testing.T) {
	calc := calculator.NewCalculator()

	tests := []struct {
		name       string
		expression string
		expected   float64
		shouldErr  bool
	}{
		{"加法", "2 + 3", 5, false},
		{"减法", "10 - 4", 6, false},
		{"乘法", "3 * 7", 21, false},
		{"除法", "15 / 3", 5, false},
		{"浮点数加法", "2.5 + 1.5", 4, false},
		{"浮点数除法", "7.5 / 2.5", 3, false},
		{"负数", "-5 + 3", -2, false},
		{"除零错误", "5 / 0", 0, true},
		{"空表达式", "", 0, true},
		{"无效字符", "2 + a", 0, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := calc.Calculate(tt.expression)

			if tt.shouldErr {
				if err == nil {
					t.Errorf("期望出现错误，但没有错误")
				}
			} else {
				if err != nil {
					t.Errorf("不期望出现错误，但出现了错误: %v", err)
				}
				if result != tt.expected {
					t.Errorf("期望结果 %g，实际结果 %g", tt.expected, result)
				}
			}
		})
	}
}

// TestComplexExpressions 测试复杂表达式
func TestComplexExpressions(t *testing.T) {
	calc := calculator.NewCalculator()

	tests := []struct {
		name       string
		expression string
		expected   float64
	}{
		{"括号运算", "(2 + 3) * 4", 20},
		{"嵌套括号", "((2 + 3) * 4) - 5", 15},
		{"运算优先级", "2 + 3 * 4", 14},
		{"复杂表达式", "10 + (5 - 2) * 3", 19},
		{"多层嵌套", "(2 + (3 * 4)) / 2", 7},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := calc.Calculate(tt.expression)
			if err != nil {
				t.Errorf("不期望出现错误: %v", err)
			}
			if result != tt.expected {
				t.Errorf("期望结果 %g，实际结果 %g", tt.expected, result)
			}
		})
	}
}

// TestHistory 测试历史记录功能
func TestHistory(t *testing.T) {
	calc := calculator.NewCalculator()

	// 执行一些计算
	expressions := []string{"2 + 3", "10 - 4", "3 * 7"}
	for _, expr := range expressions {
		_, err := calc.Calculate(expr)
		if err != nil {
			t.Errorf("计算 %s 时出现错误: %v", expr, err)
		}
	}

	// 检查历史记录
	history := calc.GetHistory()
	if len(history) != len(expressions) {
		t.Errorf("期望历史记录数量 %d，实际数量 %d", len(expressions), len(history))
	}

	// 验证历史记录内容
	for i, record := range history {
		if record.Expression != expressions[i] {
			t.Errorf("历史记录 %d 表达式不匹配，期望 %s，实际 %s",
				i, expressions[i], record.Expression)
		}
	}

	// 测试清空历史记录
	calc.ClearHistory()
	history = calc.GetHistory()
	if len(history) != 0 {
		t.Errorf("清空后期望历史记录数量 0，实际数量 %d", len(history))
	}
}

// TestErrorHandling 测试错误处理
func TestErrorHandling(t *testing.T) {
	calc := calculator.NewCalculator()

	errorTests := []struct {
		name       string
		expression string
		errorMsg   string
	}{
		{"括号不匹配1", "(2 + 3", "括号不匹配"},
		{"括号不匹配2", "2 + 3)", "括号不匹配"},
		{"连续运算符", "2 ++ 3", "连续的运算符"},
		{"除零", "5 / 0", "除零错误"},
		{"无效字符", "2 + @", "包含无效字符"},
		{"空表达式", "", "表达式不能为空"},
	}

	for _, tt := range errorTests {
		t.Run(tt.name, func(t *testing.T) {
			_, err := calc.Calculate(tt.expression)
			if err == nil {
				t.Errorf("期望出现错误，但没有错误")
			}
		})
	}
}

// BenchmarkCalculate 基准测试
func BenchmarkCalculate(b *testing.B) {
	calc := calculator.NewCalculator()
	expression := "(2 + 3) * 4 - 1"

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := calc.Calculate(expression)
		if err != nil {
			b.Errorf("计算出现错误: %v", err)
		}
	}
}

// BenchmarkSimpleAddition 简单加法基准测试
func BenchmarkSimpleAddition(b *testing.B) {
	calc := calculator.NewCalculator()
	expression := "2 + 3"

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := calc.Calculate(expression)
		if err != nil {
			b.Errorf("计算出现错误: %v", err)
		}
	}
}

// BenchmarkComplexExpression 复杂表达式基准测试
func BenchmarkComplexExpression(b *testing.B) {
	calc := calculator.NewCalculator()
	expression := "((2 + 3) * 4 - 1) / (5 + 2)"

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := calc.Calculate(expression)
		if err != nil {
			b.Errorf("计算出现错误: %v", err)
		}
	}
}

// ExampleCalculator_Calculate 计算器使用示例
func ExampleCalculator_Calculate() {
	calc := calculator.NewCalculator()

	result, err := calc.Calculate("2 + 3")
	if err != nil {
		panic(err)
	}

	fmt.Printf("%.0f", result)
	// Output: 5
}

// ExampleCalculator_ComplexExpression 复杂表达式示例
func ExampleCalculator_ComplexExpression() {
	calc := calculator.NewCalculator()

	result, err := calc.Calculate("(2 + 3) * 4")
	if err != nil {
		panic(err)
	}

	fmt.Printf("%.0f", result)
	// Output: 20
}