handler.go

package logger

import (
	"errors"
	"fmt"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"time"
)

// handlerResult holds a handler and its associated closer
type handlerResult struct {
	handler slog.Handler
	closer  io.Closer
	rotator Rotator
	syncer  Syncer
}

type Rotator interface {
	Rotate() error
}

// Syncer is an interface for types that can flush buffered data.
type Syncer interface {
	Sync() error
}

func configuredLeveler(cfg *Config) slog.Leveler {
	if cfg.leveler != nil {
		return cfg.leveler
	}
	return cfg.Level
}

// closeAll closes all closers and returns any errors joined.
func closeAll(closers []io.Closer) error {
	var errs []error
	for _, c := range closers {
		if err := c.Close(); err != nil {
			errs = append(errs, err)
		}
	}
	return errors.Join(errs...)
}

func applyMiddlewares(handler slog.Handler, middlewares []Middleware) (slog.Handler, error) {
	for i, mw := range middlewares {
		if mw == nil {
			continue
		}

		next := mw(handler)
		if next == nil {
			return nil, fmt.Errorf("middleware at index %d returned nil handler", i)
		}
		handler = next
	}

	return handler, nil
}

// newHandler creates a handler with resource management
func newHandler(cfg *Config) (*handlerResult, error) {
	if err := validateConfig(cfg); err != nil {
		return nil, err
	}

	var handlers []slog.Handler
	var closers []io.Closer
	var rotator Rotator
	var syncer Syncer

	// Console handler
	if cfg.Console.Enabled {
		handler, err := newConsoleHandler(cfg)
		if err != nil {
			return nil, fmt.Errorf("console handler error: %w", err)
		}
		handlers = append(handlers, handler)
	}

	// File handler
	if cfg.File.Enabled && cfg.File.Path != "" {
		handler, closer, fileRotator, fileSyncer, err := newFileHandler(cfg)
		if err != nil {
			_ = closeAll(closers)
			return nil, fmt.Errorf("file handler error: %w", err)
		}
		handlers = append(handlers, handler)
		if closer != nil {
			closers = append(closers, closer)
		}
		if fileRotator != nil {
			rotator = fileRotator
		}
		if fileSyncer != nil {
			syncer = fileSyncer
		}
	}

	// Default to console if no handlers
	if len(handlers) == 0 {
		replaceAttr := composeReplaceAttrForStandardHandlers(cfg)
		var handler slog.Handler = slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
			Level:       configuredLeveler(cfg),
			AddSource:   cfg.AddSource,
			ReplaceAttr: replaceAttr,
		})

		handler, err := applyMiddlewares(handler, cfg.Middlewares)
		if err != nil {
			return nil, err
		}

		return &handlerResult{
			handler: handler,
		}, nil
	}

	var combinedCloser io.Closer
	if len(closers) > 0 {
		combinedCloser = &multiCloser{closers: closers}
	}

	var handler slog.Handler

	// Single handler
	if len(handlers) == 1 {
		handler = handlers[0]
	} else {
		// Multiple handlers
		handler = newMultiHandler(handlers...)
	}

	handler, err := applyMiddlewares(handler, cfg.Middlewares)
	if err != nil {
		if combinedCloser != nil {
			if closeErr := combinedCloser.Close(); closeErr != nil {
				return nil, errors.Join(err, fmt.Errorf("failed to close handler resources: %w", closeErr))
			}
		}
		return nil, err
	}

	return &handlerResult{
		handler: handler,
		closer:  combinedCloser,
		rotator: rotator,
		syncer:  syncer,
	}, nil
}

func newConsoleHandler(cfg *Config) (slog.Handler, error) {
	replaceAttr := cfg.ReplaceAttr
	if cfg.Console.Format == FormatText || cfg.Console.Format == FormatJSON {
		replaceAttr = composeReplaceAttrForStandardHandlers(cfg)
	}

	opts := &slog.HandlerOptions{
		Level:       configuredLeveler(cfg),
		AddSource:   cfg.AddSource,
		ReplaceAttr: replaceAttr,
	}

	writer := cfg.Console.Writer
	if writer == nil {
		writer = os.Stderr
	}

	switch cfg.Console.Format {
	case FormatJSON:
		return slog.NewJSONHandler(writer, opts), nil
	case FormatText:
		return slog.NewTextHandler(writer, opts), nil
	case FormatCustom:
		return newCustomHandler(writer, cfg, &cfg.Console, opts)
	default:
		return nil, fmt.Errorf("unsupported console format: %v", cfg.Console.Format)
	}
}

func newFileHandler(cfg *Config) (slog.Handler, io.Closer, Rotator, Syncer, error) {
	dir := filepath.Dir(cfg.File.Path)
	if err := os.MkdirAll(dir, 0o750); err != nil {
		return nil, nil, nil, nil, fmt.Errorf("failed to create log directory %s: %w", dir, err)
	}

	writer, err := newRotatingWriter(&rotatingConfig{
		directory:     filepath.Dir(cfg.File.Path),
		fileName:      filepath.Base(cfg.File.Path),
		maxSizeMB:     cfg.File.MaxSizeMB,
		retentionDays: cfg.File.RetentionDays,
		compress:      cfg.File.Compress,
		maxBackups:    cfg.File.MaxBackups,
	})
	if err != nil {
		return nil, nil, nil, nil, fmt.Errorf("rotating writer error: %w", err)
	}

	replaceAttr := cfg.ReplaceAttr
	if cfg.File.Format == FormatText || cfg.File.Format == FormatJSON {
		replaceAttr = composeReplaceAttrForStandardHandlers(cfg)
	}

	opts := &slog.HandlerOptions{
		Level:       configuredLeveler(cfg),
		AddSource:   cfg.AddSource,
		ReplaceAttr: replaceAttr,
	}

	var handler slog.Handler
	switch cfg.File.Format {
	case FormatJSON:
		handler = slog.NewJSONHandler(writer, opts)
	case FormatText:
		handler = slog.NewTextHandler(writer, opts)
	case FormatCustom:
		h, err := newCustomHandler(writer, cfg, &cfg.File, opts)
		if err != nil {
			writer.Close()
			return nil, nil, nil, nil, err
		}
		handler = h
	default:
		writer.Close()
		return nil, nil, nil, nil, fmt.Errorf("unsupported file format: %v", cfg.File.Format)
	}

	return handler, writer, writer, writer, nil
}

func composeReplaceAttrForStandardHandlers(cfg *Config) func([]string, slog.Attr) slog.Attr {
	if cfg == nil {
		return nil
	}

	userReplaceAttr := cfg.ReplaceAttr
	timeFormat := cfg.TimeFormat
	if timeFormat == "" {
		timeFormat = DefaultTimeFormat
	}
	timeZone := cfg.TimeZone
	if timeZone == nil {
		timeZone = time.Local
	}

	return func(groups []string, a slog.Attr) slog.Attr {
		if a.Key == slog.TimeKey && a.Value.Kind() == slog.KindTime {
			a = slog.Time(a.Key, a.Value.Time().In(timeZone))
		}

		if userReplaceAttr != nil {
			a = userReplaceAttr(groups, a)
		}

		if a.Equal(slog.Attr{}) {
			return a
		}

		if a.Key == slog.TimeKey && a.Value.Kind() == slog.KindTime {
			return slog.String(a.Key, a.Value.Time().Format(timeFormat))
		}

		return a
	}
}

// multiCloser closes multiple closers
type multiCloser struct {
	closers []io.Closer
}

func (mc *multiCloser) Close() error {
	var errs []error
	for _, closer := range mc.closers {
		if err := closer.Close(); err != nil {
			errs = append(errs, err)
		}
	}
	return errors.Join(errs...)
}