// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package logger provides methods for logging with different levels.
package logger

import (
	"context"
	"fmt"
	"io"
	goLog "log"
	"os"
	"sort"

	"go.fuchsia.dev/fuchsia/tools/lib/color"
)

type globalLoggerKeyType struct{}

// WithLogger returns the context with its logger set as the provided Logger.
func WithLogger(ctx context.Context, logger *Logger) context.Context {
	return context.WithValue(ctx, globalLoggerKeyType{}, logger)
}

// LoggerFromContext returns the context logger if configured, otherwise nil.
func LoggerFromContext(ctx context.Context) *Logger {
	if v, ok := ctx.Value(globalLoggerKeyType{}).(*Logger); ok && v != nil {
		return v
	}
	return nil
}

// Logger represents a specific LogLevel with a specified color and prefix.
type Logger struct {
	LoggerLevel   LogLevel
	goLogger      *goLog.Logger
	goErrorLogger *goLog.Logger
	color         color.Color
	prefix        interface{}
}

// LogLevel represents different levels for logging depending on the amount of detail wanted.
type LogLevel int

const (
	NoLogLevel LogLevel = iota
	FatalLevel
	ErrorLevel
	WarningLevel
	InfoLevel
	DebugLevel
	TraceLevel
)

var levelToName = map[LogLevel]string{
	NoLogLevel:   "no",
	FatalLevel:   "fatal",
	ErrorLevel:   "error",
	WarningLevel: "warning",
	InfoLevel:    "info",
	DebugLevel:   "debug",
	TraceLevel:   "trace",
}

// Populated at runtime by init() by inverting levelToName.
var nameToLevel = map[string]LogLevel{}

func init() {
	for level, name := range levelToName {
		nameToLevel[name] = level
	}
}

// AllLevels enumerates all log levels.
func AllLevels() []LogLevel {
	var levels []LogLevel
	for level := range levelToName {
		levels = append(levels, level)
	}
	sort.Slice(levels, func(i, j int) bool {
		return levels[i] < levels[j]
	})
	return levels
}

// Copied from Go log so callers don't need to also import log.
const (
	Ldate         = 1 << iota             // the date in the local time zone: 2009/01/23
	Ltime                                 // the time in the local time zone: 01:23:23
	Lmicroseconds                         // microsecond resolution: 01:23:23.123123.  assumes Ltime.
	Llongfile                             // full file name and line number: /a/b/c/d.go:23
	Lshortfile                            // final file name element and line number: d.go:23. overrides Llongfile
	LUTC                                  // if Ldate or Ltime is set, use UTC rather than the local time zone
	Lmsgprefix                            // move the "prefix" from the beginning of the line to before the message
	LstdFlags     = Ldate | Lmicroseconds // initial values for the standard logger
)

// StartDepth defines the starting point for the call depth when entering the logger.
const startDepth = 2

// String returns the string representation of the LogLevel, or an empty string
// if the LogLevel has no string representation specified.
func (l *LogLevel) String() string {
	return levelToName[*l]
}

// Set sets the LogLevel based on its string value.
func (l *LogLevel) Set(s string) error {
	level, ok := nameToLevel[s]
	if !ok {
		return fmt.Errorf("%s is not a valid level", s)
	}
	*l = level
	return nil
}

// NewLogger creates a new logger instance. The loggerLevel variable sets the log level for the logger.
// The color variable specifies the visual color of displayed log output.
// The outWriter and errWriter variables set the destination to which non-error and error data will be written.
// The prefix appears on the same line directly preceding any log data. It should be thread-safe to format this value.
func NewLogger(loggerLevel LogLevel, color color.Color, outWriter, errWriter io.Writer, prefix interface{}) *Logger {
	if outWriter == nil {
		outWriter = os.Stdout
	}
	if errWriter == nil {
		errWriter = os.Stderr
	}
	l := &Logger{
		LoggerLevel:   loggerLevel,
		goLogger:      goLog.New(outWriter, "", LstdFlags),
		goErrorLogger: goLog.New(errWriter, "", LstdFlags),
		color:         color,
		prefix:        prefix,
	}
	return l
}

func (l *Logger) SetFlags(flags int) {
	l.goLogger.SetFlags(flags)
	l.goErrorLogger.SetFlags(flags)
}

func (l *Logger) log(callDepth int, prefix, format string, a ...interface{}) {
	l.goLogger.Output(callDepth+1, fmt.Sprintf("%s%s%s", l.prefix, prefix, fmt.Sprintf(format, a...)))
}

// Logf logs the string based on the loglevel of the string and the LogLevel of the logger.
func (l *Logger) logf(callDepth int, logLevel LogLevel, format string, a ...interface{}) {
	switch logLevel {
	case InfoLevel:
		l.infof(callDepth+1, format, a...)
	case DebugLevel:
		l.debugf(callDepth+1, format, a...)
	case TraceLevel:
		l.tracef(callDepth+1, format, a...)
	case WarningLevel:
		l.warningf(callDepth+1, format, a...)
	case ErrorLevel:
		l.errorf(callDepth+1, format, a...)
	case FatalLevel:
		l.fatalf(callDepth+1, format, a...)
	default:
		panic(fmt.Sprintf("Undefined loglevel: %v, log message: %s", logLevel, fmt.Sprintf(format, a...)))
	}
}

func Logf(ctx context.Context, logLevel LogLevel, format string, a ...interface{}) {
	logf(startDepth, ctx, logLevel, format, a...)
}

func logf(callDepth int, ctx context.Context, logLevel LogLevel, format string, a ...interface{}) {
	if v := LoggerFromContext(ctx); v != nil {
		v.logf(callDepth+1, logLevel, format, a...)
		return
	}
	switch logLevel {
	case InfoLevel:
	case DebugLevel:
	case TraceLevel:
	case WarningLevel:
	case ErrorLevel:
		goLog.Output(callDepth+1, fmt.Sprintf(format, a...))
	case FatalLevel:
		goLog.Output(callDepth+1, fmt.Sprintf(format, a...))
		os.Exit(1)
	default:
		panic(fmt.Sprintf("Undefined loglevel: %v, log message: %s", logLevel, fmt.Sprintf(format, a...)))
	}
}

// Infof logs the string if the logger is at least InfoLevel.
func (l *Logger) Infof(format string, a ...interface{}) {
	l.infof(startDepth, format, a...)
}

// infof logs the string if the logger is at least InfoLevel.
func (l *Logger) infof(callDepth int, format string, a ...interface{}) {
	if l.LoggerLevel >= InfoLevel {
		l.log(callDepth+1, "", format, a...)
	}
}

func Infof(ctx context.Context, format string, a ...interface{}) {
	logf(startDepth, ctx, InfoLevel, format, a...)
}

// Debugf logs the string if the logger is at least DebugLevel.
func (l *Logger) Debugf(format string, a ...interface{}) {
	l.debugf(startDepth, format, a...)
}

// Debugf logs the string if the logger is at least DebugLevel.
func (l *Logger) debugf(callDepth int, format string, a ...interface{}) {
	if l.LoggerLevel >= DebugLevel {
		l.log(callDepth+1, l.color.Cyan("DEBUG: "), format, a...)
	}
}

func Debugf(ctx context.Context, format string, a ...interface{}) {
	logf(startDepth, ctx, DebugLevel, format, a...)
}

// Tracef logs the string if the logger is at least TraceLevel.
func (l *Logger) Tracef(format string, a ...interface{}) {
	l.tracef(startDepth, format, a...)
}

// Tracef logs the string if the logger is at least TraceLevel.
func (l *Logger) tracef(callDepth int, format string, a ...interface{}) {
	if l.LoggerLevel >= TraceLevel {
		l.log(callDepth+1, l.color.Blue("TRACE: "), format, a...)
	}
}

func Tracef(ctx context.Context, format string, a ...interface{}) {
	logf(startDepth, ctx, TraceLevel, format, a...)
}

// Warningf logs the string if the logger is at least WarningLevel.
func (l *Logger) Warningf(format string, a ...interface{}) {
	l.warningf(startDepth, format, a...)
}

// Warningf logs the string if the logger is at least WarningLevel.
func (l *Logger) warningf(callDepth int, format string, a ...interface{}) {
	if l.LoggerLevel >= WarningLevel {
		l.log(callDepth+1, l.color.Yellow("WARN: "), format, a...)
	}
}

func Warningf(ctx context.Context, format string, a ...interface{}) {
	logf(startDepth, ctx, WarningLevel, format, a...)
}

// Errorf logs the string if the logger is at least ErrorLevel.
func (l *Logger) Errorf(format string, a ...interface{}) {
	l.errorf(startDepth, format, a...)
}

// Errorf logs the string if the logger is at least ErrorLevel.
func (l *Logger) errorf(callDepth int, format string, a ...interface{}) {
	if l.LoggerLevel >= ErrorLevel {
		l.goErrorLogger.Output(callDepth+1, fmt.Sprintf("%s%s%s", l.prefix, l.color.Red("ERROR: "), fmt.Sprintf(format, a...)))
	}
}

func Errorf(ctx context.Context, format string, a ...interface{}) {
	logf(startDepth, ctx, ErrorLevel, format, a...)
}

// Fatalf logs the string if the logger is at least FatalLevel.
func (l *Logger) Fatalf(format string, a ...interface{}) {
	l.fatalf(startDepth, format, a...)
}

// Fatalf logs the string if the logger is at least FatalLevel.
func (l *Logger) fatalf(callDepth int, format string, a ...interface{}) {
	if l.LoggerLevel >= FatalLevel {
		l.goErrorLogger.Output(callDepth+1, fmt.Sprintf("%s%s%s", l.prefix, l.color.Red("FATAL: "), fmt.Sprintf(format, a...)))
	}
	os.Exit(1)
}

func Fatalf(ctx context.Context, format string, a ...interface{}) {
	logf(startDepth, ctx, FatalLevel, format, a...)
}