// limitations under the License.

package msg

// Create static initializers file
//go:generate go run generate.main.go messages.yaml messages.gen.go

package diag

import (
	"sort"
)

// Messages is a slice of Message items.
type Messages []Message

// Add a new message to the messages
func (ms *Messages) Add(m ...Message) {
	*ms = append(*ms, m...)
}

// Sort the message lexicographically by level, code, resource origin name, then string.
func (ms *Messages) Sort() {
	sort.Slice(*ms, func(i, j int) bool {
		a, b := (*ms)[i], (*ms)[j]

	}
}

// NewInternalError returns a new diag.Message based on InternalError.
func NewInternalError(r *resource.Instance, detail string) diag.Message {
	return diag.NewMessage(
		InternalError,
		r,
		detail,
	)
}

// NewDeprecated returns a new diag.Message based on Deprecated.
func NewDeprecated(r *resource.Instance, detail string) diag.Message {
	return diag.NewMessage(
		Deprecated,
		r,

		MockResource("B"),
		"A",
	)
	fifthMsg := NewMessage(
		NewMessageType(Warning, "B1", "Template: %q"),
		MockResource("B"),
		"B",
	)

	msgs := Messages{fifthMsg, fourthMsg, thirdMsg, secondMsg, firstMsg}
	expectedMsgs := Messages{firstMsg, secondMsg, thirdMsg, fourthMsg, fifthMsg}

	msgs.Sort()

	g.Expect(msgs).To(Equal(expectedMsgs))
}

func TestMessages_SortWithNilOrigin(t *testing.T) {

func (i *istiodContext) Report(c config.GroupVersionKind, m diag.Message) {
	msgs := i.messages[i.currentAnalyzer]
	if msgs == nil {
		msgs = &diag.Messages{}
		i.messages[i.currentAnalyzer] = msgs
	}
	msgs.Add(m)
}

func (i *istiodContext) SetAnalyzer(analyzerName string) {
	i.currentAnalyzer = analyzerName
}

func (i *istiodContext) GetMessages(analyzerNames ...string) diag.Messages {
	result := diag.Messages{}

func printYAML(ms diag.Messages) (string, error) {
	yamlOutput, err := yaml.Marshal(ms)
	return string(yamlOutput), err
}

// Formatting options for Message
var (
	colorPrefixes = map[diag.Level]string{
		diag.Info:    "",           // no special color for info messages
		diag.Warning: "\033[33m",   // yellow
		diag.Error:   "\033[1;31m", // bold red
	}
)

		})
	}
	oldmsgs := map[string]diag.Messages{}
	pushFn := func(combinedKinds sets.Set[config.GroupVersionKind]) {
		res, err := c.analyzer.ReAnalyzeSubset(combinedKinds, stop)
		if err != nil {
			log.Errorf("In-cluster analysis has failed: %s", err)
			return
		}
		// reorganize messages to map
		index := map[status.Resource]diag.Messages{}
		for _, m := range res.Messages {

	)

	msgs := diag.Messages{firstMsg, secondMsg}
	output, _ := Print(msgs, YAMLFormat, false)

	expectedOutput := `- code: B1
  documentationUrl: ` + url.ConfigAnalysis + `/b1/
  level: Error
  message: 'Explosion accident: the bubble is too big'
  origin: SoapBubble
- code: C1
  documentationUrl: ` + url.ConfigAnalysis + `/c1/
  level: Warning
  message: 'Collapse danger: the castle is too old'

		json.Unmarshal([]byte(srv.messages[0]), &got[0])
		json.Unmarshal([]byte(srv.messages[1]), &got[1])
		if !reflect.DeepEqual(got, want) {
			t.Errorf("received log messages, got %v want %v", got, want)
		}
	}

	{
		t.Log("test sending log with specified time")

		// Clean up all the mssages, and log again. Check that buffer is cleaned up properly.
		srv.messages = make([]string, 0)

	meshConfigMapName  = "istio"
	meshNetworksMapKey = "meshNetworks"
)

// AnalysisResult represents the returnable results of an analysis execution
type AnalysisResult struct {
	Messages          diag.Messages
	MappedMessages    map[string]diag.Messages
	SkippedAnalyzers  []string
	ExecutedAnalyzers []string