1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118
119. 119
120. 120
121. 121

// Copyright 2019 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT

package log

import (
	"bytes"
	"fmt"
	"os"
	"strings"

	"code.gitea.io/gitea/modules/json"
)

// Level is the level of the logger
type Level int

const (
	// TRACE represents the lowest log level
	TRACE Level = iota
	// DEBUG is for debug logging
	DEBUG
	// INFO is for information
	INFO
	// WARN is for warning information
	WARN
	// ERROR is for error reporting
	ERROR
	// CRITICAL is for critical errors
	CRITICAL
	// FATAL is for fatal errors
	FATAL
	// NONE is for no logging
	NONE
)

var toString = map[Level]string{
	TRACE:    "trace",
	DEBUG:    "debug",
	INFO:     "info",
	WARN:     "warn",
	ERROR:    "error",
	CRITICAL: "critical",
	FATAL:    "fatal",
	NONE:     "none",
}

var toLevel = map[string]Level{
	"trace":    TRACE,
	"debug":    DEBUG,
	"info":     INFO,
	"warn":     WARN,
	"error":    ERROR,
	"critical": CRITICAL,
	"fatal":    FATAL,
	"none":     NONE,
}

// Levels returns all the possible logging levels
func Levels() []string {
	keys := make([]string, 0)
	for key := range toLevel {
		keys = append(keys, key)
	}
	return keys
}

func (l Level) String() string {
	s, ok := toString[l]
	if ok {
		return s
	}
	return "info"
}

// Color returns the color string for this Level
func (l Level) Color() *[]byte {
	color, ok := levelToColor[l]
	if ok {
		return &(color)
	}
	none := levelToColor[NONE]
	return &none
}

// MarshalJSON takes a Level and turns it into text
func (l Level) MarshalJSON() ([]byte, error) {
	buffer := bytes.NewBufferString(`"`)
	buffer.WriteString(toString[l])
	buffer.WriteString(`"`)
	return buffer.Bytes(), nil
}

// FromString takes a level string and returns a Level
func FromString(level string) Level {
	temp, ok := toLevel[strings.ToLower(level)]
	if !ok {
		return INFO
	}
	return temp
}

// UnmarshalJSON takes text and turns it into a Level
func (l *Level) UnmarshalJSON(b []byte) error {
	var tmp interface{}
	err := json.Unmarshal(b, &tmp)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Err: %v", err)
		return err
	}

	switch v := tmp.(type) {
	case string:
		*l = FromString(v)
	case int:
		*l = FromString(Level(v).String())
	default:
		*l = INFO
	}
	return nil
}