// Copyright 2020 The Go 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 severity

import (
	"context"
	"fmt"

	"golang.org/x/exp/event"
)

// Level represents a severity level of an event.
// The basic severity levels are designed to match the levels used in open telemetry.
// Smaller numerical values correspond to less severe events (such as debug events),
// larger numerical values correspond to more severe events (such as errors and critical events).
//
// The following table defines the meaning severity levels:
// 1-4	TRACE	A fine-grained debugging event. Typically disabled in default configurations.
// 5-8	DEBUG	A debugging event.
// 9-12	INFO	An informational event. Indicates that an event happened.
// 13-16	WARN	A warning event. Not an error but is likely more important than an informational event.
// 17-20	ERROR	An error event. Something went wrong.
// 21-24	FATAL	A fatal error such as application or system crash.
//
// See https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#severity-fields
// for more details
type Level uint64

const (
	Trace   = Level(1)
	Debug   = Level(5)
	Info    = Level(9)
	Warning = Level(13)
	Error   = Level(17)
	Fatal   = Level(21)
	Max     = Level(24)
)

const Key = "level"

// Of creates a label for the level.
func (l Level) Label() event.Label {
	return event.Label{Name: Key, Value: event.ValueOf(l)}
}

// From can be used to get a value from a Label.
func From(t event.Label) Level {
	return t.Value.Interface().(Level)
}

func (l Level) Log(ctx context.Context, msg string, labels ...event.Label) {
	ev := event.New(ctx, event.LogKind)
	if ev != nil {
		ev.Labels = append(ev.Labels, l.Label())
		ev.Labels = append(ev.Labels, labels...)
		ev.Message = msg
		ev.Deliver()
	}
}

func (l Level) Logf(ctx context.Context, msg string, args ...interface{}) {
	ev := event.New(ctx, event.LogKind)
	if ev != nil {
		ev.Labels = append(ev.Labels, l.Label())
		ev.Message = fmt.Sprintf(msg, args...)
		ev.Deliver()
	}
}

func (l Level) Class() Level {
	switch {
	case l > Max:
		return Max
	case l > Fatal:
		return Fatal
	case l > Error:
		return Error
	case l > Warning:
		return Warning
	case l > Debug:
		return Debug
	case l > Info:
		return Info
	case l > Trace:
		return Trace
	default:
		return 0
	}
}

func (l Level) String() string {
	switch l {
	case 0:
		return "invalid"

	case Trace:
		return "trace"
	case Trace + 1:
		return "trace2"
	case Trace + 2:
		return "trace3"
	case Trace + 3:
		return "trace4"

	case Debug:
		return "debug"
	case Debug + 1:
		return "debug2"
	case Debug + 2:
		return "debug3"
	case Debug + 3:
		return "debug4"

	case Info:
		return "info"
	case Info + 1:
		return "info2"
	case Info + 2:
		return "info3"
	case Info + 3:
		return "info4"

	case Warning:
		return "warning"
	case Warning + 1:
		return "warning2"
	case Warning + 2:
		return "warning3"
	case Warning + 3:
		return "warning4"

	case Error:
		return "error"
	case Error + 1:
		return "error2"
	case Error + 2:
		return "error3"
	case Error + 3:
		return "error4"

	case Fatal:
		return "fatal"
	case Fatal + 1:
		return "fatal2"
	case Fatal + 2:
		return "fatal3"
	case Fatal + 3:
		return "fatal4"
	default:
		return "invalid"
	}
}