package rekursion

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

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

func RekursivEval(tree syntaxbaum.SyntaxBaum, I []string) int {
	var children = tree.GetChildren()
	if tree.IsAtom() || tree.IsGeneric() {
		if utils.StrListContains(I, tree.Expr) {
			return 1
		}
		return 0
	} else if tree.IsTautologySymbol() {
		return 1
	} else if tree.IsContradictionSymbol() {
		return 0
	} else if tree.IsNegation() {
		subtree0, _ := tree.GetChild()
		val0 := RekursivEval(subtree0, I)
		return 1 - val0
	} else if tree.IsConjunction2() {
		val0 := RekursivEval(children[0], I)
		val1 := RekursivEval(children[1], I)
		return utils.Min2(val0, val1)
	} else if tree.IsConjunction() {
		var val = 1
		for _, subtree := range children {
			var val_ = RekursivEval(subtree, I)
			val = utils.Min2(val, val_)
		}
		return val
	} else if tree.IsDisjunction2() {
		val0 := RekursivEval(children[0], I)
		val1 := RekursivEval(children[1], I)
		return utils.Max2(val0, val1)
	} else if tree.IsDisjunction() {
		var val = 0
		for _, subtree := range children {
			var val_ = RekursivEval(subtree, I)
			val = utils.Max2(val, val_)
		}
		return val
	} else if tree.IsImplication() {
		val0 := RekursivEval(children[0], I)
		val1 := RekursivEval(children[1], I)
		if val0 <= val1 {
			return 1
		}
		return 0
	} else {
		log.Fatal("Could not evaluate expression!")
		return 0
	}
}

func RekursivAtoms(tree syntaxbaum.SyntaxBaum) []string {
	// Herausforderung: schreibe diese Funktion!
	return []string{}
}

func RekursivDepth(tree syntaxbaum.SyntaxBaum) int {
	// Herausforderung: schreibe diese Funktion!
	return 0
}

func RekursivLength(tree syntaxbaum.SyntaxBaum) int {
	// Herausforderung: schreibe diese Funktion!
	return 0
}

func RekursivParentheses(tree syntaxbaum.SyntaxBaum) int {
	// Herausforderung: schreibe diese Funktion!
	return 0
}