package rekursion

import (
	"logik/aussagenlogik/syntaxbaum"
	"logik/core/utils"
)

/* ---------------------------------------------------------------- *
 * EXPORTS
 * ---------------------------------------------------------------- */

type RekursiveChannelInt struct {
	channel chan int
}

func RekursivEval(ch chan int, tree syntaxbaum.SyntaxBaum, I []string) {
	// Werte für Teilformeln rekursiv berechnen
	fn := func(_ch chan int, _tree syntaxbaum.SyntaxBaum) { RekursivEval(_ch, _tree, I) }
	var values = RekursiveCallInt(fn, tree.GetChildren())
	// Aus Werten für Teilformeln Wert für Formeln berechnen
	if tree.IsAtom() || tree.IsGeneric() {
		ch <- utils.BoolToInt(utils.StrListContains(I, tree.GetExpr()))
	} else if tree.IsTautologySymbol() {
		ch <- 1
	} else if tree.IsContradictionSymbol() {
		ch <- 0
	} else if tree.IsNegation() {
		ch <- 1 - values[0]
	} else if tree.IsConjunction2() {
		ch <- utils.Min2(values[0], values[1])
	} else if tree.IsConjunction() {
		ch <- utils.MinList(values)
	} else if tree.IsDisjunction2() {
		ch <- utils.Max2(values[0], values[1])
	} else if tree.IsDisjunction() {
		ch <- utils.MaxList(values)
	} else if tree.IsImplication() {
		ch <- utils.BoolToInt(values[0] <= values[1])
	} else {
		panic("Could not evaluate expression!")
	}
}

func RekursivAtoms(ch chan []string, tree syntaxbaum.SyntaxBaum) {
	// // Werte für Teilformeln rekursiv berechnen
	// var values = RekursiveCallStringList(RekursivAtoms, tree.GetChildren())
	// Herausforderung: schreibe diese Funktion!
	ch <- []string{}
}

func RekursivDepth(ch chan int, tree syntaxbaum.SyntaxBaum) {
	// // Werte für Teilformeln rekursiv berechnen
	// var values = RekursiveCallInt(RekursivDepth, tree.GetChildren())
	// Herausforderung: schreibe diese Funktion!
	ch <- 0
}

func RekursivLength(ch chan int, tree syntaxbaum.SyntaxBaum) {
	// // Werte für Teilformeln rekursiv berechnen
	// var values = RekursiveCallInt(RekursivLength, tree.GetChildren())
	// Herausforderung: schreibe diese Funktion!
	ch <- 0
}

func RekursivParentheses(ch chan int, tree syntaxbaum.SyntaxBaum) {
	// // Werte für Teilformeln rekursiv berechnen
	// var values = RekursiveCallInt(RekursivParentheses, tree.GetChildren())
	// Herausforderung: schreibe diese Funktion!
	ch <- 0
}