package logger

import (
	"context"
	"fmt"
	"log/slog"
	"os"
)

// multiHandler writes to multiple slog.Handlers
type multiHandler struct {
	handlers []slog.Handler
}

func (m *multiHandler) Enabled(ctx context.Context, level slog.Level) bool {
	for _, h := range m.handlers {
		if h.Enabled(ctx, level) {
			return true
		}
	}
	return false
}

func (m *multiHandler) Handle(ctx context.Context, r slog.Record) error {
	var err error
	for _, h := range m.handlers {
		if e := h.Handle(ctx, r); e != nil && err == nil {
			err = e
		}
	}
	return err
}

func (m *multiHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
	newHandlers := make([]slog.Handler, len(m.handlers))
	for i, h := range m.handlers {
		newHandlers[i] = h.WithAttrs(attrs)
	}
	return &multiHandler{handlers: newHandlers}
}

func (m *multiHandler) WithGroup(name string) slog.Handler {
	newHandlers := make([]slog.Handler, len(m.handlers))
	for i, h := range m.handlers {
		newHandlers[i] = h.WithGroup(name)
	}
	return &multiHandler{handlers: newHandlers}
}

type customMessageOnlyHandler struct {
	output *os.File
}

func (h *customMessageOnlyHandler) Enabled(_ context.Context, _ slog.Level) bool {
	return true
}

func (h *customMessageOnlyHandler) Handle(_ context.Context, r slog.Record) error {
	msg := r.Message
	if msg != "" {
		_, err := fmt.Fprintln(h.output, msg)
		return err
	}
	return nil
}

func (h *customMessageOnlyHandler) WithAttrs(_ []slog.Attr) slog.Handler {
	return h
}

func (h *customMessageOnlyHandler) WithGroup(_ string) slog.Handler {
	return h
}

// SetupLogger configures slog based on format and file
func SetupLogger(logFormat string, logFilePath string, level slog.Level) *slog.Logger {
	var handlers []slog.Handler
	var logFile *os.File
	var levelVar slog.LevelVar
	levelVar.Set(level)

	if logFilePath != "" {
		f, err := os.OpenFile(logFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
		if err == nil {
			logFile = f
			// Do not close here; let OS handle it at process exit
		}
	}

	switch logFormat {
	case "basic":
		handlers = append(handlers, slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
			ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
				if a.Key == slog.TimeKey {
					return slog.Attr{}
				}
				return a
			},
		}))
		if logFile != nil {
			handlers = append(handlers, slog.NewTextHandler(logFile, &slog.HandlerOptions{}))
		}
	case "none":
		handlers = append(handlers, &customMessageOnlyHandler{output: os.Stdout})
		if logFile != nil {
			handlers = append(handlers, &customMessageOnlyHandler{output: logFile})
		}
	default:
		handlers = append(handlers, slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: &levelVar}))
		if logFile != nil {
			handlers = append(handlers, slog.NewJSONHandler(logFile, &slog.HandlerOptions{Level: &levelVar}))
		}
	}

	if len(handlers) == 1 {
		return slog.New(handlers[0])
	}
	return slog.New(&multiHandler{handlers: handlers})
}