package next_greater_element

/* ---------------------------------------------------------------- *
 * IMPORTS
 * ---------------------------------------------------------------- */

import (
	"ads/internal/core/logging"
	"ads/internal/core/metrics"
	"ads/pkg/data_structures/stacks"
)

/* ---------------------------------------------------------------- *
 * GLOBAL VARIABLES/CONSTANTS
 * ---------------------------------------------------------------- */

var _output_list [][2]int

/* ---------------------------------------------------------------- *
 * ALGORITHM next greater element
 * ---------------------------------------------------------------- */

/*
Inputs: L = Liste von Zahlen, x = Zahl.

Outputs: Liste von Paaren von Elementen und ihrem nächsten größeren Element
*/
func NextGreaterElement(L []int) [][2]int {
	clearOutput()
	if len(L) == 0 {
		return output()
	}

	S := stacks.CREATE()

	for i := 0; i < len(L); i++ {
		logging.Debug("Nächstes List-Element L[%v] = %v betrachten", i, L[i])
		nextElement := L[i]

		logging.Debug("Entferne alle top Elemente vom Stack bis >= nextElement")
		/*
			Entferne alle top Elemente vom Stack < nextElement
			bis oben ein Elment >= nextElement ist, oder Stack leer ist.
		*/
		logging.Debug("Stack S | %v", S)
		for !S.EMPTY() {
			element := S.TOP()
			S.POP()
			metrics.AddMovesCost()
			logging.Debug("Stack S | %v; (popped) Top-Element = %v", S, element)
			// falls element < next Element, zum Output hinzufügen
			if element < nextElement {
				addToOutput(element, nextElement)
				// sonst Element auf Stack zurücklegen und Schleife abbrechen.
			} else {
				logging.Debug("Stack-Element >= nextElement ==> zurücklegen")
				S.PUSH(element)
				metrics.AddMovesCost()
				break
			}
		}

		logging.Debug("L[%v] auf Stack legen", i)
		S.PUSH(nextElement)
		logging.Debug("Stack S | %v", S)
		metrics.AddMovesCost()
	}

	// was übrig bleibt hat kein größeres Element
	logging.Debug("Alles übrige auf Stack hat kein nächstes größeres Element")
	for !S.EMPTY() {
		logging.Debug("Stack S | %v", S)
		element := S.TOP()
		S.POP()
		metrics.AddMovesCost()
		addToOutput(element, -1)
	}
	logging.Debug("Stack S | %v", S)

	return output()
}

/* ---------------------------------------------------------------- *
 * AUXILIARY METHODS
 * ---------------------------------------------------------------- */

func clearOutput() {
	_output_list = [][2]int{}
}

func addToOutput(m int, n int) {
	_output_list = append(_output_list, [2]int{m, n})
}

func output() [][2]int {
	var output = make([][2]int, len(_output_list))
	copy(output, _output_list)
	clearOutput()
	return output
}