package services

/*
  TODO: TO BE DEPRECATED IN 0.25 @RS185722
*/
import (
	"context"
	"testing"

	"github.com/DATA-DOG/go-sqlmock"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"edge-infra.dev/pkg/edge/api/graph/model"
	sqlquery "edge-infra.dev/pkg/edge/api/sql"
)

var (
	testClassificationBannerEdgeID = "9c478a9c-b536-4ea9-9f1f-144c87094f6b"
	classificationEdgeIDs          = []string{"de4f477e-1f68-40f7-9f1f-f9c9dc08c250", "9c478a9c-b536-4ea9-94c7-144c87094f6b", "c93fd8fd-531f-42d3-8c96-e827fdbbe0ea", "56d36657-4107-4da5-9787-72b1c07d18a5", "a5aea7e7-2bd6-4f86-862e-6c540feaaae4"}
	classificationDescriptions     = []string{"test-description-1", "test-description-2", "test-description-3", "test-description-4", "test-description-5", "test-description-6", "test-description-7", "test-description-8", "test-description-9"}
	classificationPods             = []string{"test-pod1", "test-pod2", "test-pod3", "test-pod4", "test-pod5", "test-pod6", "test-pod7", "test-pod8", "test-pod9"}
	classificationContainers       = []string{"test-container1", "test-container2", "test-container3", "test-container4", "test-container5", "test-container6", "test-container7", "test-container8", "test-container9"}
	classificationTypes            = []string{"test-type1", "test-type2", "test-type3", "test-type4", "test-type5", "test-type6", "test-type7", "test-type8", "test-type9"}
	classificationClasses          = []string{"audit", "security"}
	classificationPatterns         = []string{"test-pattern1", "test-pattern2", "test-pattern3", "test-pattern4", "test-pattern5", "test-pattern6", "test-pattern7", "test-pattern8", "test-pattern9"}

	testClassifications = &model.LogClassification{
		Description: classificationDescriptions[0],
		Pod:         classificationPods[0],
		Container:   classificationContainers[0],
		Type:        classificationTypes[0],
		Class:       classificationClasses[0],
		Pattern:     classificationPatterns[0],
	}

	testClassifications2 = &model.LogClassification{
		Description: classificationDescriptions[1],
		Pod:         classificationPods[1],
		Container:   classificationContainers[1],
		Type:        classificationTypes[1],
		Class:       classificationClasses[1],
		Pattern:     classificationPatterns[1],
	}

	multiClassifications = []*model.LogClassification{
		{
			BannerEdgeID:            testClassificationBannerEdgeID,
			LogClassificationEdgeID: classificationEdgeIDs[2],
			Description:             classificationDescriptions[2],
			Pod:                     classificationPods[2],
			Container:               classificationContainers[2],
			Type:                    classificationTypes[2],
			Class:                   classificationClasses[0],
			Pattern:                 classificationPatterns[2],
		},
		{
			BannerEdgeID:            testClassificationBannerEdgeID,
			LogClassificationEdgeID: classificationEdgeIDs[3],
			Description:             classificationDescriptions[3],
			Pod:                     classificationPods[3],
			Container:               classificationContainers[3],
			Type:                    classificationTypes[3],
			Class:                   classificationClasses[0],
			Pattern:                 classificationPatterns[3],
		},
		{
			BannerEdgeID:            testClassificationBannerEdgeID,
			LogClassificationEdgeID: classificationEdgeIDs[4],
			Description:             classificationDescriptions[4],
			Pod:                     classificationPods[4],
			Container:               classificationContainers[4],
			Type:                    classificationTypes[4],
			Class:                   classificationClasses[1],
			Pattern:                 classificationPatterns[4],
		},
	}

	logClassificationRows = sqlmock.NewRows([]string{"banner_edge_id", "classification_edge_id", "classification_description", "pod", "container", "log_type", "log_class", "pattern"})
)

func TestGetClassification(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	require.NoError(t, err)
	defer db.Close()

	mock.ExpectQuery(sqlquery.GetLogClassification).
		WithArgs(testClassificationBannerEdgeID, classificationEdgeIDs[0]).
		WillReturnRows(logClassificationRows.
			AddRow(testClassificationBannerEdgeID, classificationEdgeIDs[0], classificationDescriptions[0], classificationPods[0], classificationContainers[0], classificationTypes[0], classificationClasses[0], classificationPatterns[0]))

	service := NewLogClassificationService(db)
	logClassification, err := service.GetLogClassification(context.Background(), testClassificationBannerEdgeID, classificationEdgeIDs[0])

	assert.NoError(t, err)
	assert.NotEmpty(t, logClassification)

	assert.Equal(t, testClassificationBannerEdgeID, logClassification.BannerEdgeID)
	assert.Equal(t, classificationDescriptions[0], logClassification.Description)
	assert.Equal(t, classificationPods[0], logClassification.Pod)
	assert.Equal(t, classificationContainers[0], logClassification.Container)
	assert.Equal(t, classificationTypes[0], logClassification.Type)
	assert.Equal(t, classificationClasses[0], logClassification.Class)
	assert.Equal(t, classificationPatterns[0], logClassification.Pattern)
}

func TestDeleteClassification(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	require.NoError(t, err)
	defer db.Close()

	mock.ExpectExec(sqlquery.DeleteLogClassification).WithArgs(testClassificationBannerEdgeID, classificationEdgeIDs[0]).
		WillReturnResult(sqlmock.NewResult(1, 1))

	service := NewLogClassificationService(db)

	if deleted, err := service.DeleteLogClassification(context.Background(), testClassificationBannerEdgeID, classificationEdgeIDs[0]); !deleted && err != nil {
		t.Errorf("error was not expected while deleting classification: %s", err)
	}
}

func TestCreateClassification(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	require.NoError(t, err)
	defer db.Close()

	mock.ExpectBegin()
	mock.ExpectExec(sqlquery.CreateLogClassification).
		WithArgs(testClassificationBannerEdgeID, classificationEdgeIDs[0], testClassifications.Description, testClassifications.Pod, testClassifications.Container, testClassifications.Type, testClassifications.Class, "").
		WillReturnResult(sqlmock.NewResult(1, 1))

	mock.ExpectCommit()

	service := NewLogClassificationService(db)

	createClassificationInput := model.CreateClassificationInput{
		Description: classificationDescriptions[0],
		Pod:         classificationPods[0],
		Container:   classificationContainers[0],
		Type:        classificationTypes[0],
		Class:       model.LogClassSelectionAudit,
		Pattern:     "",
	}

	result, err := service.CreateLogClassification(context.Background(), testClassificationBannerEdgeID, classificationEdgeIDs[0], createClassificationInput)

	assert.NoError(t, err)
	assert.Equal(t, testClassificationBannerEdgeID, result.BannerEdgeID)
	assert.Equal(t, classificationEdgeIDs[0], result.LogClassificationEdgeID)
	assert.Equal(t, classificationDescriptions[0], result.Description)
	assert.Equal(t, classificationPods[0], result.Pod)
	assert.Equal(t, classificationContainers[0], result.Container)
	assert.Equal(t, classificationTypes[0], result.Type)
	assert.Equal(t, classificationClasses[0], result.Class)
	assert.Equal(t, "", result.Pattern)
}

func TestUpdateClassification(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	require.NoError(t, err)
	defer db.Close()

	mock.ExpectQuery(sqlquery.GetLogClassification).
		WithArgs(testClassificationBannerEdgeID, classificationEdgeIDs[1]).
		WillReturnRows(logClassificationRows.
			AddRow(testClassificationBannerEdgeID, classificationEdgeIDs[1], classificationDescriptions[0], classificationPods[0], classificationContainers[0], classificationTypes[0], classificationClasses[0], classificationPatterns[0]))

	mock.ExpectBegin()
	mock.ExpectExec(sqlquery.UpdateLogClassification).
		WithArgs(testClassificationBannerEdgeID, classificationEdgeIDs[1], testClassifications2.Description, testClassifications2.Pod, testClassifications2.Container, testClassifications2.Type, testClassifications2.Class, testClassifications2.Pattern).
		WillReturnResult(sqlmock.NewResult(1, 1))

	mock.ExpectCommit()

	service := NewLogClassificationService(db)

	testClass := model.LogClassSelectionSecurity
	updateClassificationInput := &model.UpdateClassificationInput{
		Description: &classificationDescriptions[1],
		Pod:         &classificationPods[1],
		Container:   &classificationContainers[1],
		Type:        &classificationTypes[1],
		Class:       &testClass,
		Pattern:     &classificationPatterns[1],
	}

	result, err := service.UpdateLogClassification(context.Background(), testClassificationBannerEdgeID, classificationEdgeIDs[1], updateClassificationInput)

	assert.NoError(t, err)
	assert.Equal(t, classificationEdgeIDs[1], result.LogClassificationEdgeID)
	assert.Equal(t, classificationDescriptions[1], result.Description)
	assert.Equal(t, classificationPods[1], result.Pod)
	assert.Equal(t, classificationContainers[1], result.Container)
	assert.Equal(t, classificationTypes[1], result.Type)
	assert.Equal(t, classificationClasses[1], result.Class)
	assert.Equal(t, classificationPatterns[1], result.Pattern)

	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

func TestGetClassificationByBanner(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	require.NoError(t, err)
	defer db.Close()

	mock.ExpectQuery(sqlquery.GetLogClassificationsByBanner).
		WithArgs(testClassificationBannerEdgeID).
		WillReturnRows(logClassificationRows.
			AddRow(testClassificationBannerEdgeID, classificationEdgeIDs[2], classificationDescriptions[2], classificationPods[2], classificationContainers[2], classificationTypes[2], classificationClasses[0], classificationPatterns[2]).
			AddRow(testClassificationBannerEdgeID, classificationEdgeIDs[3], classificationDescriptions[3], classificationPods[3], classificationContainers[3], classificationTypes[3], classificationClasses[0], classificationPatterns[3]).
			AddRow(testClassificationBannerEdgeID, classificationEdgeIDs[4], classificationDescriptions[4], classificationPods[4], classificationContainers[4], classificationTypes[4], classificationClasses[1], classificationPatterns[4]))

	service := NewLogClassificationService(db)
	logClassifications, err := service.GetLogClassificationsByBanner(context.Background(), testClassificationBannerEdgeID)

	assert.NoError(t, err)
	assert.NotEmpty(t, logClassifications)

	for index, classification := range logClassifications {
		assert.Equal(t, testClassificationBannerEdgeID, classification.BannerEdgeID)
		assert.Equal(t, multiClassifications[index].LogClassificationEdgeID, classification.LogClassificationEdgeID)
		assert.Equal(t, multiClassifications[index].Description, classification.Description)
		assert.Equal(t, multiClassifications[index].Pod, classification.Pod)
		assert.Equal(t, multiClassifications[index].Container, classification.Container)
		assert.Equal(t, multiClassifications[index].Type, classification.Type)
		assert.Equal(t, multiClassifications[index].Class, classification.Class)
		assert.Equal(t, multiClassifications[index].Pattern, classification.Pattern)
	}
}