package toml

import (
	"fmt"
	"testing"

	"git.makaay.nl/mauricem/go-parsekit/parse"
)

type statesT struct {
	name string
	in   string
	out  interface{}
	err  string
}

type parseTest struct {
	input    interface{}
	expected []string
}

func testParseHandler(t *testing.T, p *parser, handler parse.Handler, test parseTest) {
	var err error
	defer func() {
		recovered := recover()
		results := []string{}
		for _, item := range p.Items {
			results = append(results, item.String())
		}
		if err != nil {
			results = append(results, fmt.Sprintf("Error: %s", err))
		}
		if recovered != nil {
			results = append(results, fmt.Sprintf("Panic: %s", recovered.(string)))
		}

		for i, e := range test.expected {
			if i > len(results)-1 {
				t.Errorf("No result at index %d for input %q, expected: %s", i, test.input, e)
				continue
			}
			r := results[i]
			if e != r {
				t.Errorf("Unexpected result at index %d for input %q:\nexpected: %s\nactual: %s\n", i, test.input, e, r)
			}
		}
		if len(results) > len(test.expected) {
			t.Errorf("Got more results than expected for input %q, surplus result(s):\n", test.input)
			for i := len(test.expected); i < len(results); i++ {
				t.Errorf("[%d] %s", i, results[i])
			}
		}
	}()
	err = parse.New(handler)(test.input)
}

func testAST(t *testing.T, code func() (error, *parser), expectedError string, expectedData string) {
	err, p := code()
	if expectedError == "" {
		if err != nil {
			t.Fatalf("Unexpected error: %s", err)
		}
	} else {
		if err == nil {
			t.Fatalf("An error was expected, but no error was returned")
		} else if err.Error() != expectedError {
			t.Fatalf("Unexpected error:\nexpected: %s\nactual: %s\n", expectedError, err.Error())
		}
	}
	if expectedData == "" {
		return
	}
	if expectedData != p.Root.String() {
		t.Fatalf("Unexpected data after parsing:\nexpected: %s\nactual: %s\n", expectedData, p.Root.String())
	}
}

type parseToASTTest struct {
	input         interface{}
	expected      string
	expectedError string
}

func testParseToAST(t *testing.T, p *parser, handler parse.Handler, test parseToASTTest) {
	var err error
	defer func() {
		recovered := recover()
		if recovered != nil {
			err = fmt.Errorf("Panic: %s", recovered.(string))
		}
		if err != nil && test.expectedError == "" {
			t.Errorf("Unexpected error for input %q: %s", test.input, err)
		} else if err != nil && test.expectedError != err.Error() {
			t.Errorf("Unexpected error for input %q:\nexpected: %s\nactual: %s\n", test.input, test.expectedError, err.Error())
		} else {
			result := p.Root.String()
			if test.expected != result {
				t.Errorf("Unexpected result for input %q:\nexpected: %s\nactual: %s\n", test.input, test.expected, result)
			}
		}
	}()
	err = parse.New(handler)(test.input)
}