package rekursion

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

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

func RekursivEval(tree syntaxbaum.SyntaxBaum, I []string) int {
	var children = tree.GetChildren()
	switch tree.Kind {
	case "atom", "generic":
		if utils.StrListContains(I, tree.Expr) {
			return 1
		}
		return 0
	case "taut":
		return 1
	case "contradiction":
		return 0
	case "not":
		subtree0, _ := tree.GetChild()
		val0 := RekursivEval(subtree0, I)
		return 1 - val0
	case "and2":
		val0 := RekursivEval(children[0], I)
		val1 := RekursivEval(children[1], I)
		return utils.Min2(val0, val1)
	case "and":
		var val = 1
		for _, subtree := range children {
			var val_ = RekursivEval(subtree, I)
			val = utils.Min2(val, val_)
		}
		return val
	case "or2":
		val0 := RekursivEval(children[0], I)
		val1 := RekursivEval(children[1], I)
		return utils.Max2(val0, val1)
	case "or":
		var val = 0
		for _, subtree := range children {
			var val_ = RekursivEval(subtree, I)
			val = utils.Max2(val, val_)
		}
		return val
	case "implies":
		val0 := RekursivEval(children[0], I)
		val1 := RekursivEval(children[1], I)
		if val0 <= val1 {
			return 1
		}
		return 0
	default:
		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
}