package starlog

import (
	"errors"
	"io"
	"log"

	"b612.me/starlog/internal/stdlibx"
)

type StdlibLevelMapper = stdlibx.LevelMapper

type StdlibBridgeOptions = stdlibx.Options

type StdlibBridgeOption = stdlibx.Option

func DefaultStdlibBridgeOptions() StdlibBridgeOptions { return stdlibx.DefaultOptions() }

func WithStdlibPrefix(prefix string) StdlibBridgeOption {
	return stdlibx.WithPrefix(prefix)
}

func WithStdlibFlags(flags int) StdlibBridgeOption {
	return stdlibx.WithFlags(flags)
}

func WithStdlibShowStd(show bool) StdlibBridgeOption {
	return stdlibx.WithShowStd(show)
}

func WithStdlibTrimNewline(trim bool) StdlibBridgeOption {
	return stdlibx.WithTrimNewline(trim)
}

func WithStdlibLevelMapper(mapper StdlibLevelMapper) StdlibBridgeOption {
	return stdlibx.WithLevelMapper(mapper)
}

func normalizeStdlibBridgeOptions(opts []StdlibBridgeOption) StdlibBridgeOptions {
	return stdlibx.NormalizeOptions(opts)
}

type LevelWriter struct {
	logger *StarLogger
	core   *stdlibx.Writer
}

func NewLevelWriter(logger *StarLogger, level int) *LevelWriter {
	return NewLevelWriterWithOptions(logger, level)
}

func NewLevelWriterWithOptions(logger *StarLogger, level int, opts ...StdlibBridgeOption) *LevelWriter {
	options := normalizeStdlibBridgeOptions(opts)
	var emit stdlibx.EmitFunc
	if logger != nil {
		emit = func(mappedLevel int, showStd bool, text string) {
			logger.emit(mappedLevel, showStd, text)
		}
	}
	return &LevelWriter{
		logger: logger,
		core:   stdlibx.NewWriter(level, options, emit),
	}
}

func NewLevelWriterBridge(logger *StarLogger, level int) io.Writer {
	return NewLevelWriter(logger, level)
}

func NewStdlibLogger(logger *StarLogger, level int) *log.Logger {
	return NewStdlibLoggerWithOptions(logger, level)
}

func NewStdlibLoggerWithOptions(logger *StarLogger, level int, opts ...StdlibBridgeOption) *log.Logger {
	options := normalizeStdlibBridgeOptions(opts)
	if logger == nil {
		return log.New(io.Discard, options.Prefix, options.Flags)
	}
	return logger.AsStdlibLoggerWithOptions(level, opts...)
}

func (writer *LevelWriter) SetShowStd(show bool) {
	if writer == nil || writer.core == nil {
		return
	}
	writer.core.SetShowStd(show)
}

func (writer *LevelWriter) SetTrimNewline(trim bool) {
	if writer == nil || writer.core == nil {
		return
	}
	writer.core.SetTrimNewline(trim)
}

func (writer *LevelWriter) Write(data []byte) (int, error) {
	if writer == nil || writer.logger == nil || writer.core == nil {
		return 0, errors.New("level writer logger is nil")
	}
	return writer.core.Write(data)
}

func (logger *StarLogger) AsWriter(level int) io.Writer {
	return logger.AsWriterWithOptions(level)
}

func (logger *StarLogger) AsWriterWithOptions(level int, opts ...StdlibBridgeOption) io.Writer {
	return NewLevelWriterWithOptions(logger, level, opts...)
}

func (logger *StarLogger) AsStdlibLogger(level int) *log.Logger {
	return logger.AsStdlibLoggerWithOptions(level)
}

func (logger *StarLogger) AsStdlibLoggerWithOptions(level int, opts ...StdlibBridgeOption) *log.Logger {
	options := normalizeStdlibBridgeOptions(opts)
	return log.New(logger.AsWriterWithOptions(level, opts...), options.Prefix, options.Flags)
}