package filesystem

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	"sync"
	"time"
)

// LogLevel 日志级别
type LogLevel int

const (
	LogLevelDebug LogLevel = iota
	LogLevelInfo
	LogLevelWarn
	LogLevelError
)

// Logger 结构化日志记录器
type Logger struct {
	minLevel  LogLevel
	logFile    *os.File
	logPath    string
	mu         sync.Mutex
	prefix     string
}

// NewLogger 创建新的日志记录器
func NewLogger(logPath string, minLevel LogLevel) (*Logger, error) {
	// 创建日志目录
	if err := os.MkdirAll(filepath.Dir(logPath), 0755); err != nil {
		return nil, fmt.Errorf("创建日志目录失败: %w", err)
	}

	// 打开日志文件
	logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		return nil, fmt.Errorf("打开日志文件失败: %w", err)
	}

	return &Logger{
		minLevel: minLevel,
		logFile:   logFile,
		logPath:   logPath,
		prefix:    "[FileSystem]",
	}, nil
}

// Close 关闭日志记录器
func (l *Logger) Close() error {
	l.mu.Lock()
	defer l.mu.Unlock()

	if l.logFile != nil {
		return l.logFile.Close()
	}
	return nil
}

// Debug 记录调试日志
func (l *Logger) Debug(format string, args ...interface{}) {
	l.log(LogLevelDebug, "DEBUG", format, args...)
}

// Info 记录信息日志
func (l *Logger) Info(format string, args ...interface{}) {
	l.log(LogLevelInfo, "INFO", format, args...)
}

// Error 记录错误日志
func (l *Logger) Error(format string, args ...interface{}) {
	l.log(LogLevelError, "ERROR", format, args...)
}

// log 内部日志记录方法
func (l *Logger) log(level LogLevel, levelStr, format string, args ...interface{}) {
	if level < l.minLevel {
		return
	}

	l.mu.Lock()
	defer l.mu.Unlock()

	// 格式化消息
	msg := fmt.Sprintf(format, args...)
	timestamp := time.Now().Format("2006-01-02 15:04:05.000")

	// 写入日志文件
	logLine := fmt.Sprintf("%s %s %s %s\n", timestamp, l.prefix, levelStr, msg)
	if l.logFile != nil {
		if _, err := l.logFile.WriteString(logLine); err != nil {
			// 日志写入失败，输出到控制台
			log.Print(logLine)
		}
	}

	// 根据级别决定是否输出到控制台
	if level >= LogLevelWarn {
		log.Print(logLine)
	}
}

// LogOperation 记录操作日志（辅助函数）
func LogOperation(operation, path string, success bool, err error) {
	logger := GetGlobalLogger()
	if logger == nil {
		return
	}

	if success {
		logger.Info("操作: %s %s - 成功", operation, path)
	} else {
		logger.Error("操作: %s %s - 失败: %v", operation, path, err)
	}
}

// LogError 记录错误日志（辅助函数）
func LogError(operation string, path string, err error) {
	logger := GetGlobalLogger()
	if logger == nil {
		return
	}

	logger.Error("错误: %s %s - %v", operation, path, err)

	// 如果是调试模式，输出堆栈跟踪
	if os.Getenv("UDESK_DEBUG") == "1" {
		logger.Debug("堆栈:\n%s", GetStackTrace(2))
	}
}

// ========== 全局日志记录器（向后兼容）==========

var (
	globalLogger *Logger
)

// GetGlobalLogger 获取全局日志记录器
func GetGlobalLogger() *Logger {
	return globalLogger
}

