package rekursion_test

/* ---------------------------------------------------------------- *
 * UNIT TESTING
 * ---------------------------------------------------------------- */

import (
	"logik/aussagenlogik/rekursion"
	"logik/aussagenlogik/schema"
	"logik/aussagenlogik/syntaxbaum"
	"logik/core/utils"
	"testing"

	"github.com/stretchr/testify/assert"
)

/* ---------------------------------------------------------------- *
 * TESTCASE eval(·, ·)
 * ---------------------------------------------------------------- */

func TestRekursivEvalLiteral(test *testing.T) {
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	var I []string
	tree = schema.ParseExpr("A0")
	I = []string{"A0"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(1, <-ch)
	tree = schema.ParseExpr("A0")
	I = []string{}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(0, <-ch)
	tree = schema.ParseExpr("! A0")
	I = []string{"A0"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(0, <-ch)
	tree = schema.ParseExpr("! A0")
	I = []string{}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(1, <-ch)
}

func TestRekursivEvalComplex1(test *testing.T) {
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	var I []string
	tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))")
	I = []string{"A0", "A2"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(1, <-ch)
	I = []string{"A0", "A3"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(1, <-ch)
	I = []string{"A0"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(0, <-ch)
	I = []string{"A4", "A8"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(1, <-ch)
}

func TestRekursivEvalComplex2(test *testing.T) {
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	var I []string
	tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))")
	I = []string{"A0", "A2"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(0, <-ch)
	I = []string{"A0", "A3"}
	go rekursion.RekursivEval(ch, tree, I)
	assert.Equal(1, <-ch)
}

/* ---------------------------------------------------------------- *
 * TESTCASE Atoms(·)
 * ---------------------------------------------------------------- */

func TestRekursivAtomsNoduplicates(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan []string)
	var tree syntaxbaum.SyntaxBaum
	var val []string
	tree = schema.ParseExpr("( A4 && ( A4 || A4 ))")
	go rekursion.RekursivAtoms(ch, tree)
	val = <-ch
	var n int = len(utils.FilterStrings(&val, func(x string) bool { return x == "A4" }))
	assert.Equal(1, n, "Atome dürfen nicht mehrfach vorkommen!")
}

func TestRekursivAtomsNononatoms(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	test.Skip("Syntax for generic expressions in ANTLR4 g4 needs to be implemented.")
	var assert = assert.New(test)
	var ch = make(chan []string)
	var tree syntaxbaum.SyntaxBaum
	var val []string
	tree = schema.ParseExpr("( {F} || A3 )")
	go rekursion.RekursivAtoms(ch, tree)
	val = <-ch
	utils.SortStrings(&val)
	assert.NotContains(val, "F", "Nichtatomare Formeln dürfen nicht vorkommen!")
}

func TestRekursivAtomsCalc1(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan []string)
	var tree syntaxbaum.SyntaxBaum
	var val []string
	tree = schema.ParseExpr("A0")
	go rekursion.RekursivAtoms(ch, tree)
	val = <-ch
	utils.SortStrings(&val)
	assert.Equal([]string{"A0"}, val)
}

func TestRekursivAtomsCalc2(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan []string)
	var tree syntaxbaum.SyntaxBaum
	var val []string
	tree = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )")
	go rekursion.RekursivAtoms(ch, tree)
	val = <-ch
	utils.SortStrings(&val)
	assert.Equal([]string{"A0", "A3", "A4", "A8"}, val)
}

/* ---------------------------------------------------------------- *
 * TESTCASE depth(·, ·)
 * ---------------------------------------------------------------- */

func TestRekursivDepthCalc1(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("A0")
	go rekursion.RekursivDepth(ch, tree)
	assert.Equal(0, <-ch)
}

func TestRekursivDepthCalc2(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("!! A8")
	go rekursion.RekursivDepth(ch, tree)
	assert.Equal(2, <-ch)
}

func TestRekursivDepthCalc3(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("( ! A0 && A3 )")
	go rekursion.RekursivDepth(ch, tree)
	assert.Equal(2, <-ch)
}

func TestRekursivDepthCalc4(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
	go rekursion.RekursivDepth(ch, tree)
	assert.Equal(4, <-ch)
}

func TestRekursivDepthCalc5(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
	go rekursion.RekursivDepth(ch, tree)
	assert.Equal(5, <-ch)
}

/* ---------------------------------------------------------------- *
 * TESTCASE length(·)
 * ---------------------------------------------------------------- */

func TestRekursivLengthCalc1(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("A0")
	go rekursion.RekursivLength(ch, tree)
	assert.Equal(1, <-ch)
}

func TestRekursivLengthCalc2(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("!! A8")
	go rekursion.RekursivLength(ch, tree)
	assert.Equal(3, <-ch)
}

func TestRekursivLengthCalc3(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("( ! A0 && A3 )")
	go rekursion.RekursivLength(ch, tree)
	assert.Equal(4, <-ch)
}

func TestRekursivLengthCalc4(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
	go rekursion.RekursivLength(ch, tree)
	assert.Equal(8, <-ch)
}

func TestRekursivLengthCalc5(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
	go rekursion.RekursivLength(ch, tree)
	assert.Equal(9, <-ch)
}

/* ---------------------------------------------------------------- *
 * TESTCASE #Parentheses(·)
 * ---------------------------------------------------------------- */

func TestRekursivParenthesesCalc1(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("A0")
	go rekursion.RekursivParentheses(ch, tree)
	assert.Equal(0, <-ch)
}

func TestRekursivParenthesesCalc2(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("!! A8")
	go rekursion.RekursivParentheses(ch, tree)
	assert.Equal(0, <-ch)
}

func TestRekursivParenthesesCalc3(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("( ! A0 && A3 )")
	go rekursion.RekursivParentheses(ch, tree)
	assert.Equal(2, <-ch)
}

func TestRekursivParenthesesCalc4(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
	go rekursion.RekursivParentheses(ch, tree)
	assert.Equal(6, <-ch)
}

func TestRekursivParenthesesCalc5(test *testing.T) {
	test.Skip("Methode noch nicht implementiert")
	var assert = assert.New(test)
	var ch = make(chan int)
	var tree syntaxbaum.SyntaxBaum
	tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
	go rekursion.RekursivParentheses(ch, tree)
	assert.Equal(6, <-ch)
}