package logging

import (
	"bytes"
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/rs/zerolog"
)

// ==================== New / Init 构造测试 ====================

func TestNew_DefaultOptions(t *testing.T) {
	logger, err := New(Options{})
	if err != nil {
		t.Fatalf("New() 默认选项不应报错, got: %v", err)
	}
	if logger == nil {
		t.Fatal("New() 返回的 Logger 不应为 nil")
	}
	// 默认级别应为 Info
	if logger.level != zerolog.InfoLevel {
		t.Errorf("默认级别应为 Info, got: %s", logger.level)
	}
	if logger.quiet {
		t.Error("默认不应为静默模式")
	}
	if logger.verbose {
		t.Error("默认不应为详细模式")
	}
	if logger.logFile != nil {
		t.Error("默认不应有日志文件")
	}
}

func TestNew_WithLevel(t *testing.T) {
	tests := []struct {
		level    string
		expected zerolog.Level
	}{
		{"trace", zerolog.TraceLevel},
		{"debug", zerolog.DebugLevel},
		{"info", zerolog.InfoLevel},
		{"warn", zerolog.WarnLevel},
		{"error", zerolog.ErrorLevel},
		{"fatal", zerolog.FatalLevel},
	}

	for _, tt := range tests {
		t.Run(tt.level, func(t *testing.T) {
			logger, err := New(Options{Level: tt.level, Quiet: true})
			if err != nil {
				t.Fatalf("New(Level=%s) 不应报错, got: %v", tt.level, err)
			}
			if logger.level != tt.expected {
				t.Errorf("级别应为 %s, got: %s", tt.expected, logger.level)
			}
		})
	}
}

func TestNew_InvalidLevel(t *testing.T) {
	_, err := New(Options{Level: "invalid_level"})
	if err == nil {
		t.Fatal("无效日志级别应返回错误")
	}
	if !strings.Contains(err.Error(), "无效的日志级别") {
		t.Errorf("错误消息应包含 '无效的日志级别', got: %s", err.Error())
	}
}

func TestNew_VerboseOverridesLevel(t *testing.T) {
	logger, err := New(Options{Level: "error", Verbose: true, Quiet: true})
	if err != nil {
		t.Fatalf("不应报错, got: %v", err)
	}
	// Verbose 应覆盖 Level，强制设为 Debug
	if logger.level != zerolog.DebugLevel {
		t.Errorf("Verbose=true 时级别应为 Debug, got: %s", logger.level)
	}
	if !logger.verbose {
		t.Error("verbose 标志应为 true")
	}
}

func TestNew_QuietMode(t *testing.T) {
	logger, err := New(Options{Quiet: true})
	if err != nil {
		t.Fatalf("不应报错, got: %v", err)
	}
	if !logger.quiet {
		t.Error("quiet 标志应为 true")
	}
}

func TestNew_WithLogFile(t *testing.T) {
	tmpDir := t.TempDir()
	logPath := filepath.Join(tmpDir, "test.log")

	logger, err := New(Options{LogFile: logPath, Quiet: true})
	if err != nil {
		t.Fatalf("不应报错, got: %v", err)
	}
	defer logger.Close()

	if logger.logFile == nil {
		t.Fatal("logFile 不应为 nil")
	}

	// 验证文件已创建
	if _, err := os.Stat(logPath); os.IsNotExist(err) {
		t.Error("日志文件应已被创建")
	}
}

func TestNew_LogFileCreatesDir(t *testing.T) {
	tmpDir := t.TempDir()
	logPath := filepath.Join(tmpDir, "subdir", "nested", "test.log")

	logger, err := New(Options{LogFile: logPath, Quiet: true})
	if err != nil {
		t.Fatalf("不应报错, got: %v", err)
	}
	defer logger.Close()

	// 验证嵌套目录已创建
	dirPath := filepath.Dir(logPath)
	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
		t.Error("日志目录应已被自动创建")
	}
}

// ==================== Init / G 全局实例测试 ====================

func TestInit_SetsGlobal(t *testing.T) {
	// 保存并恢复原始全局实例
	original := global
	defer func() { global = original }()

	logger, err := Init(Options{Quiet: true})
	if err != nil {
		t.Fatalf("Init() 不应报错, got: %v", err)
	}
	if G() != logger {
		t.Error("G() 应返回 Init() 设置的全局实例")
	}
}

func TestG_DefaultSafe(t *testing.T) {
	// 即使未初始化，G() 也应返回安全的 nop logger
	original := global
	defer func() { global = original }()

	global = &Logger{zl: zerolog.Nop()}
	log := G()
	if log == nil {
		t.Fatal("G() 不应返回 nil")
	}
	// 调用方法不应 panic
	log.Info("安全调用测试")
	log.Debugf("格式化 %s", "测试")
}

// ==================== 日志输出测试 ====================

// newBufferLogger 创建一个写入 buffer 的 Logger，用于验证输出
func newBufferLogger(level zerolog.Level) (*Logger, *bytes.Buffer) {
	buf := &bytes.Buffer{}
	zl := zerolog.New(buf).Level(level).With().Timestamp().Logger()
	return &Logger{zl: zl, level: level}, buf
}

func TestLogger_InfoOutput(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Info("测试消息")

	output := buf.String()
	if !strings.Contains(output, "测试消息") {
		t.Errorf("输出应包含日志消息, got: %s", output)
	}
	if !strings.Contains(output, `"level":"info"`) {
		t.Errorf("输出应包含 info 级别, got: %s", output)
	}
}

func TestLogger_Infof(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Infof("你好 %s, 编号 %d", "世界", 42)

	output := buf.String()
	if !strings.Contains(output, "你好 世界, 编号 42") {
		t.Errorf("格式化输出不正确, got: %s", output)
	}
}

func TestLogger_DebugFilteredByLevel(t *testing.T) {
	// Info 级别的 Logger 应过滤 Debug 消息
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Debug("这条不应出现")

	if buf.Len() > 0 {
		t.Errorf("Info 级别不应输出 Debug 消息, got: %s", buf.String())
	}
}

func TestLogger_DebugVisibleAtDebugLevel(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.DebugLevel)

	logger.Debug("调试信息")

	if !strings.Contains(buf.String(), "调试信息") {
		t.Errorf("Debug 级别应输出 Debug 消息, got: %s", buf.String())
	}
}

func TestLogger_TraceFilteredByInfo(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Trace("跟踪信息")

	if buf.Len() > 0 {
		t.Errorf("Info 级别不应输出 Trace 消息, got: %s", buf.String())
	}
}

func TestLogger_WarnOutput(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Warn("警告信息")

	output := buf.String()
	if !strings.Contains(output, "警告信息") {
		t.Errorf("输出应包含警告消息, got: %s", output)
	}
	if !strings.Contains(output, `"level":"warn"`) {
		t.Errorf("输出应包含 warn 级别, got: %s", output)
	}
}

func TestLogger_ErrorOutput(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Error("错误信息")

	output := buf.String()
	if !strings.Contains(output, "错误信息") {
		t.Errorf("输出应包含错误消息, got: %s", output)
	}
	if !strings.Contains(output, `"level":"error"`) {
		t.Errorf("输出应包含 error 级别, got: %s", output)
	}
}

func TestLogger_Errorf(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Errorf("文件 %s 失败: %d", "test.txt", 404)

	if !strings.Contains(buf.String(), "文件 test.txt 失败: 404") {
		t.Errorf("格式化错误输出不正确, got: %s", buf.String())
	}
}

func TestLogger_Warnf(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.Warnf("版本 %s 已废弃", "v0.1.0")

	if !strings.Contains(buf.String(), "版本 v0.1.0 已废弃") {
		t.Errorf("格式化警告输出不正确, got: %s", buf.String())
	}
}

func TestLogger_Tracef(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.TraceLevel)

	logger.Tracef("进入函数 %s", "Scan")

	if !strings.Contains(buf.String(), "进入函数 Scan") {
		t.Errorf("格式化跟踪输出不正确, got: %s", buf.String())
	}
}

func TestLogger_Debugf(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.DebugLevel)

	logger.Debugf("变量值: %v", map[string]int{"a": 1})

	if !strings.Contains(buf.String(), "变量值:") {
		t.Errorf("格式化调试输出不正确, got: %s", buf.String())
	}
}

// ==================== 结构化字段测试 ====================

func TestLogger_WithField(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.WithField("collector", "go").Msg("扫描完成")

	output := buf.String()
	if !strings.Contains(output, "collector") {
		t.Errorf("输出应包含字段名 collector, got: %s", output)
	}
	if !strings.Contains(output, "扫描完成") {
		t.Errorf("输出应包含消息, got: %s", output)
	}
}

func TestLogger_WithError(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	testErr := os.ErrNotExist
	logger.WithError(testErr).Msg("操作失败")

	output := buf.String()
	if !strings.Contains(output, "error") {
		t.Errorf("输出应包含 error 字段, got: %s", output)
	}
	if !strings.Contains(output, "操作失败") {
		t.Errorf("输出应包含消息, got: %s", output)
	}
}

func TestLogger_WithDuration(t *testing.T) {
	logger, buf := newBufferLogger(zerolog.InfoLevel)

	logger.WithDuration(3 * time.Second).Msg("处理完成")

	output := buf.String()
	if !strings.Contains(output, "duration") {
		t.Errorf("输出应包含 duration 字段, got: %s", output)
	}
	if !strings.Contains(output, "处理完成") {
		t.Errorf("输出应包含消息, got: %s", output)
	}
}

// ==================== 工具方法测试 ====================

func TestLogger_IsDebug(t *testing.T) {
	tests := []struct {
		name     string
		level    zerolog.Level
		expected bool
	}{
		{"TraceLevel", zerolog.TraceLevel, true},
		{"DebugLevel", zerolog.DebugLevel, true},
		{"InfoLevel", zerolog.InfoLevel, false},
		{"WarnLevel", zerolog.WarnLevel, false},
		{"ErrorLevel", zerolog.ErrorLevel, false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			logger := &Logger{level: tt.level, zl: zerolog.Nop()}
			if logger.IsDebug() != tt.expected {
				t.Errorf("IsDebug() 应为 %v (level=%s)", tt.expected, tt.level)
			}
		})
	}
}

func TestLogger_IsQuiet(t *testing.T) {
	logger := &Logger{quiet: true, zl: zerolog.Nop()}
	if !logger.IsQuiet() {
		t.Error("IsQuiet() 应返回 true")
	}

	logger2 := &Logger{quiet: false, zl: zerolog.Nop()}
	if logger2.IsQuiet() {
		t.Error("IsQuiet() 应返回 false")
	}
}

func TestLogger_IsVerbose(t *testing.T) {
	logger := &Logger{verbose: true, zl: zerolog.Nop()}
	if !logger.IsVerbose() {
		t.Error("IsVerbose() 应返回 true")
	}

	logger2 := &Logger{verbose: false, zl: zerolog.Nop()}
	if logger2.IsVerbose() {
		t.Error("IsVerbose() 应返回 false")
	}
}

// ==================== Close 测试 ====================

func TestLogger_Close_WithFile(t *testing.T) {
	tmpDir := t.TempDir()
	logPath := filepath.Join(tmpDir, "close_test.log")

	logger, err := New(Options{LogFile: logPath, Quiet: true})
	if err != nil {
		t.Fatalf("不应报错, got: %v", err)
	}

	// 写一条日志确保文件可用
	logger.Info("关闭前的日志")

	// Close 不应 panic
	logger.Close()

	// 关闭后文件不可写（已关闭）
	_, writeErr := logger.logFile.WriteString("test")
	if writeErr == nil {
		t.Error("文件关闭后写入应报错")
	}
}

func TestLogger_Close_WithoutFile(t *testing.T) {
	logger, _ := New(Options{Quiet: true})
	// 没有日志文件时 Close 不应 panic
	logger.Close()
}

// ==================== 日志文件写入测试 ====================

func TestLogger_FileOutput(t *testing.T) {
	tmpDir := t.TempDir()
	logPath := filepath.Join(tmpDir, "output_test.log")

	logger, err := New(Options{LogFile: logPath, Quiet: true})
	if err != nil {
		t.Fatalf("不应报错, got: %v", err)
	}

	logger.Info("写入文件的消息")
	logger.Warn("警告消息")
	logger.Close()

	// 读取文件内容
	content, err := os.ReadFile(logPath)
	if err != nil {
		t.Fatalf("读取日志文件失败: %v", err)
	}

	lines := strings.Split(strings.TrimSpace(string(content)), "\n")
	if len(lines) < 2 {
		t.Fatalf("日志文件应至少有 2 行, got %d 行: %s", len(lines), string(content))
	}

	// 验证是合法的 JSON 格式（文件输出为 JSON）
	for i, line := range lines {
		var entry map[string]any
		if err := json.Unmarshal([]byte(line), &entry); err != nil {
			t.Errorf("第 %d 行不是合法 JSON: %s", i+1, line)
		}
	}
}

// ==================== 级别过滤综合测试 ====================

func TestLogger_LevelFiltering(t *testing.T) {
	tests := []struct {
		name      string
		logLevel  zerolog.Level
		writeFunc func(l *Logger)
		shouldLog bool
	}{
		{"Error级别写Info", zerolog.ErrorLevel, func(l *Logger) { l.Info("msg") }, false},
		{"Error级别写Error", zerolog.ErrorLevel, func(l *Logger) { l.Error("msg") }, true},
		{"Error级别写Warn", zerolog.ErrorLevel, func(l *Logger) { l.Warn("msg") }, false},
		{"Warn级别写Warn", zerolog.WarnLevel, func(l *Logger) { l.Warn("msg") }, true},
		{"Warn级别写Info", zerolog.WarnLevel, func(l *Logger) { l.Info("msg") }, false},
		{"Debug级别写Trace", zerolog.DebugLevel, func(l *Logger) { l.Trace("msg") }, false},
		{"Trace级别写Trace", zerolog.TraceLevel, func(l *Logger) { l.Trace("msg") }, true},
		{"Info级别写Info", zerolog.InfoLevel, func(l *Logger) { l.Info("msg") }, true},
		{"Info级别写Error", zerolog.InfoLevel, func(l *Logger) { l.Error("msg") }, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			logger, buf := newBufferLogger(tt.logLevel)
			tt.writeFunc(logger)
			hasOutput := buf.Len() > 0
			if hasOutput != tt.shouldLog {
				t.Errorf("shouldLog=%v, but hasOutput=%v (output: %s)",
					tt.shouldLog, hasOutput, buf.String())
			}
		})
	}
}