package unittest_test

import (
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"path"
	"testing"

	. "github.com/lrills/helm-unittest/unittest"
	"github.com/stretchr/testify/assert"
)

var tmpNunitTestDir, _ = ioutil.TempDir("", testSuiteTests)

func createNUnitTestCase(name, description, failureContent string, executed bool) NUnitTestCase {
	testCase := NUnitTestCase{
		Name:        name,
		Description: description,
		Success:     "true",
		Asserts:     "0",
		Result:      "Success",
	}

	if len(failureContent) > 0 {
		testCase.Failure = &NUnitFailure{
			Message:    "Failed",
			StackTrace: failureContent,
		}
		testCase.Success = "false"
		testCase.Result = "Failed"
	}

	if executed {
		testCase.Executed = "true"
	} else {
		testCase.Executed = "false"
	}

	return testCase
}

func validateNUnitTestSuite(assert *assert.Assertions, expected, actual []NUnitTestSuite) {

	if expected != nil && actual != nil {
		actualLength := len(actual)
		assert.Equal(len(expected), actualLength)

		for i := 0; i < actualLength; i++ {
			assert.Equal(expected[i].Name, actual[i].Name)
			assert.Equal(expected[i].Description, actual[i].Description)
			assert.Equal(expected[i].Success, actual[i].Success)
			assert.Equal(expected[i].Executed, actual[i].Executed)
			assert.Equal(expected[i].Result, actual[i].Result)

			// Validate the testcases
			validatNUnitTestCase(assert, expected[i].TestCases, actual[i].TestCases)

			// Recursive validation loop.
			validateNUnitTestSuite(assert, expected[i].TestSuites, actual[i].TestSuites)
		}
	} else {
		// Verify if both are nil, otherwise it's still a failure.
		assert.True(expected == nil && actual == nil)
	}
}

func validatNUnitTestCase(assert *assert.Assertions, expected, actual []NUnitTestCase) {

	if expected != nil && actual != nil {
		actualLength := len(actual)
		assert.Equal(len(expected), actualLength)

		for i := 0; i < actualLength; i++ {
			assert.Equal(expected[i].Name, actual[i].Name)
			assert.Equal(expected[i].Description, actual[i].Description)
			assert.Equal(expected[i].Success, actual[i].Success)
			assert.Equal(expected[i].Asserts, actual[i].Asserts)
			assert.Equal(expected[i].Executed, actual[i].Executed)
			assert.Equal(expected[i].Result, actual[i].Result)

			if expected[i].Failure != nil || actual[i].Failure != nil {
				assert.Equal(expected[i].Failure.Message, actual[i].Failure.Message)
				assert.Equal(expected[i].Failure.StackTrace, actual[i].Failure.StackTrace)
			} else {
				// Verify if both are nil, otherwise it's still a failure.
				assert.True(expected[i].Failure == nil && actual[i].Failure == nil)
			}
		}
	} else {
		// Verify if both are nil, otherwise it's still a failure.
		assert.True(expected == nil && actual == nil)
	}
}

func TestWriteTestOutputAsNUnitMinimalSuccess(t *testing.T) {
	assert := assert.New(t)
	outputFile := path.Join(tmpNunitTestDir, "NUnit_Test_Output.xml")
	testSuiteDisplayName := "TestingSuite"
	testCaseDisplayName := "TestCaseSucces"

	expected := NUnitTestResults{
		Environment: NUnitEnvironment{},
		CultureInfo: NUnitCultureInfo{},
		TestSuite: []NUnitTestSuite{
			{
				Type:        TestFixture,
				Name:        testSuiteDisplayName,
				Description: outputFile,
				Success:     "true",
				Executed:    "true",
				Result:      "Success",
				TestCases: []NUnitTestCase{
					createNUnitTestCase(
						testCaseDisplayName,
						fmt.Sprintf("%s.%s", testSuiteDisplayName, testCaseDisplayName),
						"",
						true,
					),
				},
			},
		},
		Name:   "helm-unittest",
		Total:  1,
		Errors: 0,
	}

	given := []*TestSuiteResult{
		{
			DisplayName: testSuiteDisplayName,
			FilePath:    outputFile,
			Passed:      true,
			TestsResult: []*TestJobResult{
				createTestJobResult(testCaseDisplayName, "", true, nil),
			},
		},
	}

	sut := NewNUnitReportXML()
	bytevalue := loadFormatterTestcase(assert, outputFile, given, sut)

	var actual NUnitTestResults
	xml.Unmarshal(bytevalue, &actual)

	assert.Equal(expected.Total, actual.Total)
	assert.Equal(expected.Errors, actual.Errors)
	assert.Equal(expected.Failures, actual.Failures)
	validateNUnitTestSuite(assert, expected.TestSuite, actual.TestSuite)
}

func TestWriteTestOutputAsNUnitWithFailures(t *testing.T) {
	assert := assert.New(t)
	outputFile := path.Join(tmpNunitTestDir, "NUnit_Test_Failure_Output.xml")
	testSuiteDisplayName := "TestingSuite"
	testCaseSuccessDisplayName := "TestCaseSuccess"
	testCaseFailureDisplayName := "TestCaseFailure"
	assertionFailure := "AssertionFailure"
	assertionType := "equal"
	assertIndex := 0
	failureContent := fmt.Sprintf("\t\t - asserts[%d]%s `%s` fail \n\t\t\t %s \n", assertIndex, "", assertionType, assertionFailure)

	expected := NUnitTestResults{
		Environment: NUnitEnvironment{},
		CultureInfo: NUnitCultureInfo{},
		TestSuite: []NUnitTestSuite{
			{
				Type:        TestFixture,
				Name:        testSuiteDisplayName,
				Description: outputFile,
				Success:     "false",
				Executed:    "true",
				Result:      "Failed",
				TestCases: []NUnitTestCase{
					createNUnitTestCase(
						testCaseSuccessDisplayName,
						fmt.Sprintf("%s.%s", testSuiteDisplayName, testCaseSuccessDisplayName),
						"",
						true,
					),
					createNUnitTestCase(
						testCaseFailureDisplayName,
						fmt.Sprintf("%s.%s", testSuiteDisplayName, testCaseFailureDisplayName),
						failureContent,
						true,
					),
				},
			},
		},
		Name:     "helm-unittest",
		Total:    2,
		Errors:   0,
		Failures: 1,
	}

	assertionResults := []*AssertionResult{
		createAssertionResult(0, false, false, assertionType, assertionFailure, ""),
	}

	given := []*TestSuiteResult{
		{
			DisplayName: testSuiteDisplayName,
			FilePath:    outputFile,
			Passed:      false,
			TestsResult: []*TestJobResult{
				createTestJobResult(testCaseSuccessDisplayName, "", true, nil),
				createTestJobResult(testCaseFailureDisplayName, "", false, assertionResults),
			},
		},
	}

	sut := NewNUnitReportXML()
	bytevalue := loadFormatterTestcase(assert, outputFile, given, sut)

	var actual NUnitTestResults
	xml.Unmarshal(bytevalue, &actual)

	assert.Equal(expected.Total, actual.Total)
	assert.Equal(expected.Errors, actual.Errors)
	assert.Equal(expected.Failures, actual.Failures)
	validateNUnitTestSuite(assert, expected.TestSuite, actual.TestSuite)
}

func TestWriteTestOutputAsNUnitWithFailuresAndErrors(t *testing.T) {
	assert := assert.New(t)
	outputFile := path.Join(tmpNunitTestDir, "NUnit_Test_Failure_And_Errors_Output.xml")
	testSuiteDisplayName := "TestingSuite"
	testCaseSuccessDisplayName := "TestCaseSuccess"
	testCaseFailureDisplayName := "TestCaseFailure"
	testCaseErrorDisplayName := "TestCaseError"
	assertionFailure := "AssertionFailure"
	assertionType := "equal"
	assertIndex := 0
	failureContent := fmt.Sprintf("\t\t - asserts[%d]%s `%s` fail \n\t\t\t %s \n", assertIndex, "", assertionType, assertionFailure)
	errorMessage := "Throw an error."
	failureErrorContent := fmt.Sprintf("%s\n%s", errorMessage, failureContent)

	expected := NUnitTestResults{
		Environment: NUnitEnvironment{},
		CultureInfo: NUnitCultureInfo{},
		TestSuite: []NUnitTestSuite{
			{
				Type:        TestFixture,
				Name:        testSuiteDisplayName,
				Description: outputFile,
				Success:     "false",
				Executed:    "true",
				Result:      "Failed",
				TestCases: []NUnitTestCase{
					createNUnitTestCase(
						testCaseSuccessDisplayName,
						fmt.Sprintf("%s.%s", testSuiteDisplayName, testCaseSuccessDisplayName),
						"",
						true,
					),
					createNUnitTestCase(
						testCaseFailureDisplayName,
						fmt.Sprintf("%s.%s", testSuiteDisplayName, testCaseFailureDisplayName),
						failureContent,
						true,
					),
					createNUnitTestCase(
						testCaseErrorDisplayName,
						fmt.Sprintf("%s.%s", testSuiteDisplayName, testCaseErrorDisplayName),
						failureErrorContent,
						false,
					),
				},
			},
		},
		Name:     "helm-unittest",
		Total:    3,
		Errors:   1,
		Failures: 1,
	}

	assertionResults := []*AssertionResult{
		createAssertionResult(0, false, false, assertionType, assertionFailure, ""),
	}

	given := []*TestSuiteResult{
		{
			DisplayName: testSuiteDisplayName,
			FilePath:    outputFile,
			Passed:      false,
			TestsResult: []*TestJobResult{
				createTestJobResult(testCaseSuccessDisplayName, "", true, nil),
				createTestJobResult(testCaseFailureDisplayName, "", false, assertionResults),
				createTestJobResult(testCaseErrorDisplayName, errorMessage, false, assertionResults),
			},
		},
	}

	sut := NewNUnitReportXML()
	bytevalue := loadFormatterTestcase(assert, outputFile, given, sut)

	var actual NUnitTestResults
	xml.Unmarshal(bytevalue, &actual)

	assert.Equal(expected.Total, actual.Total)
	assert.Equal(expected.Errors, actual.Errors)
	assert.Equal(expected.Failures, actual.Failures)
	validateNUnitTestSuite(assert, expected.TestSuite, actual.TestSuite)
}

func TestWriteTestOutputAsNUnitWithErrors(t *testing.T) {
	assert := assert.New(t)
	outputFile := path.Join(tmpNunitTestDir, "NUnit_Test_Errors_Output.xml")
	testSuiteDisplayName := "TestingSuite"
	errorMessage := "Throw an error."

	expected := NUnitTestResults{
		Environment: NUnitEnvironment{},
		CultureInfo: NUnitCultureInfo{},
		TestSuite: []NUnitTestSuite{
			{
				Type:        TestFixture,
				Name:        testSuiteDisplayName,
				Description: outputFile,
				Success:     "false",
				Executed:    "false",
				Result:      "Failed",
				Failure: &NUnitFailure{
					Message:    "Error",
					StackTrace: errorMessage,
				},
			},
		},
		Name:     "helm-unittest",
		Total:    1,
		Errors:   1,
		Failures: 0,
	}

	given := []*TestSuiteResult{
		{
			DisplayName: testSuiteDisplayName,
			FilePath:    outputFile,
			Passed:      false,
			ExecError:   fmt.Errorf("%s", errorMessage),
		},
	}

	sut := NewNUnitReportXML()
	bytevalue := loadFormatterTestcase(assert, outputFile, given, sut)

	var actual NUnitTestResults
	xml.Unmarshal(bytevalue, &actual)

	assert.Equal(expected.Total, actual.Total)
	assert.Equal(expected.Errors, actual.Errors)
	assert.Equal(expected.Failures, actual.Failures)
	validateNUnitTestSuite(assert, expected.TestSuite, actual.TestSuite)
}