package services

import (
	"context"
	"testing"

	"github.com/DATA-DOG/go-sqlmock"
	"github.com/lib/pq"
	"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 (
	clusterEdgeIDs = []string{"e4a10c8e-74b2-4b5e-b489-4019afe12b80", "e4a10c8e-74b2-4b5e-b489-4019afe12b81"}
	logReplayIDs   = []string{"6b8bd6f2-f6f8-41d8-ba3e-32aab9e61550", "6b8bd6f2-f6f8-41d8-ba3e-32aab9e61551"}

	testFormattedStartTime  = "2024-04-25T19:34:12Z"
	testFormattedEndTime    = "2024-04-25T23:34:12Z"
	testFormattedUpdateTime = "2024-04-25T23:34:12Z"

	testStartTime  = "2024-04-25T15:34:12-04:00"
	testEndTime    = "2024-04-25T19:34:12-04:00"
	testUpdateTime = "2024-04-25T23:34:12Z"

	namespacesList       = []string{"test-1", "test-2"}
	longerNamespacesList = []string{"test-1", "test-2", "test-3"}
	logLevels            = []string{"DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"}
	lrStatuses           = []string{"NOT_STARTED", "PENDING", "SUCCEEDED", "FAILED", "TIMEOUT"}
	lrjJSONPaths         = []string{"$.status.active", "$.status.ready", "$.status.succeeded", "$.status.failed"}
	lrjNames             = []string{"lr-6b8bd6f2-f6f8-41d8-ba3e-32aab9e61550", "lr-6b8bd6f2-f6f8-41d8-ba3e-32aab9e61551"}

	emptyString     = ""
	zeroValue       = "0"
	oneValue        = "0"
	defaultQueued   = false
	defaultExecuted = false

	logReplayRowsUpdated = []string{"log_replay_id", "cluster_edge_id", "namespaces", "log_level", "start_time", "end_time", "queued", "executed", "status", "updated_at"}
	logReplayJobs        = []string{"jsonpath", "value", "missing", "name", "queued", "executed", "status", "updated_at", "log_replay_id"}
)

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

	//namespacesListPq := pq.StringArray(namespacesList)

	mock.ExpectQuery(sqlquery.GetLogReplay).
		WithArgs(logReplayIDs[0]).
		WillReturnRows(mock.NewRows(logReplayRowsUpdated).
			AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime))

	service := NewLogReplayService(db)

	logReplay, err := service.GetLogReplay(context.Background(), logReplayIDs[0])

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

	assert.Equal(t, logReplayIDs[0], logReplay.LogReplayID)
	assert.Equal(t, clusterEdgeIDs[0], logReplay.ClusterEdgeID)
	assert.ElementsMatch(t, namespacesList, logReplay.Namespaces)
	assert.Equal(t, logLevels[0], logReplay.LogLevel)
	assert.Equal(t, testFormattedStartTime, logReplay.StartTime)
	assert.Equal(t, testFormattedEndTime, logReplay.EndTime)
	assert.False(t, logReplay.Queued)
	assert.False(t, logReplay.Executed)
	assert.Equal(t, lrStatuses[0], logReplay.Status)
}

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

	mock.ExpectQuery(sqlquery.GetLogReplays).
		WithArgs(clusterEdgeIDs[0]).
		WillReturnRows(mock.NewRows(logReplayRowsUpdated).
			AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(&namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime).
			AddRow(logReplayIDs[1], clusterEdgeIDs[0], pq.Array(&namespacesList), logLevels[1], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime))

	service := NewLogReplayService(db)

	logReplays, err := service.GetLogReplays(context.Background(), clusterEdgeIDs[0], nil)

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

	for i := range logReplays {
		assert.Equal(t, logReplayIDs[i], logReplays[i].LogReplayID)
		assert.Equal(t, clusterEdgeIDs[0], logReplays[i].ClusterEdgeID)
		assert.ElementsMatch(t, namespacesList, logReplays[i].Namespaces)
		assert.Equal(t, logLevels[i], logReplays[i].LogLevel)
		assert.Equal(t, testFormattedStartTime, logReplays[i].StartTime)
		assert.Equal(t, testFormattedEndTime, logReplays[i].EndTime)
		assert.False(t, logReplays[i].Queued)
		assert.False(t, logReplays[i].Executed)
		assert.Equal(t, lrStatuses[i], logReplays[i].Status)
	}
}

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

	mock.ExpectQuery(sqlquery.GetLogReplaysNotExecuted).
		WithArgs(clusterEdgeIDs[0]).
		WillReturnRows(mock.NewRows(logReplayRowsUpdated).
			AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(&namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime).
			AddRow(logReplayIDs[1], clusterEdgeIDs[0], pq.Array(&namespacesList), logLevels[1], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime))

	service := NewLogReplayService(db)

	logReplays, err := service.GetLogReplays(context.Background(), clusterEdgeIDs[0], &trueValue)

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

	for i := range logReplays {
		assert.Equal(t, logReplayIDs[i], logReplays[i].LogReplayID)
		assert.Equal(t, clusterEdgeIDs[0], logReplays[i].ClusterEdgeID)
		assert.ElementsMatch(t, namespacesList, logReplays[i].Namespaces)
		assert.Equal(t, logLevels[i], logReplays[i].LogLevel)
		assert.Equal(t, testFormattedStartTime, logReplays[i].StartTime)
		assert.Equal(t, testFormattedEndTime, logReplays[i].EndTime)
		assert.False(t, logReplays[i].Queued)
		assert.False(t, logReplays[i].Executed)
		assert.Equal(t, lrStatuses[i], logReplays[i].Status)
		assert.Equal(t, testFormattedUpdateTime, logReplays[i].UpdatedAt)
	}
}
func TestGetLogReplayJobs(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	require.NoError(t, err)
	defer db.Close()

	testCases := []struct {
		name                  string
		clusterEdgeID         string
		mocksQuery            func() []*sqlmock.ExpectedQuery
		expectedLogReplayJobs []*model.LogReplayJob
		expectedErr           string
	}{
		{
			name:          "Test 1 - 1 LogReplayJob",
			clusterEdgeID: clusterEdgeIDs[0],
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplayJobs).
						WithArgs(clusterEdgeIDs[0]).
						WillReturnRows(mock.NewRows(logReplayJobs).
							AddRow(lrjJSONPaths[0], emptyString, true, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0]).
							AddRow(lrjJSONPaths[1], oneValue, false, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0]).
							AddRow(lrjJSONPaths[2], zeroValue, false, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0]).
							AddRow(lrjJSONPaths[3], emptyString, true, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0])),
				}
			},
			expectedLogReplayJobs: []*model.LogReplayJob{
				{
					Jsonpath:    lrjJSONPaths[0],
					Value:       emptyString,
					Missing:     true,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
				{
					Jsonpath:    lrjJSONPaths[1],
					Value:       oneValue,
					Missing:     false,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
				{
					Jsonpath:    lrjJSONPaths[2],
					Value:       zeroValue,
					Missing:     false,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
				{
					Jsonpath:    lrjJSONPaths[3],
					Value:       emptyString,
					Missing:     true,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
			},
			expectedErr: "",
		},
		{
			name:          "Test 2 - 2 LogReplayJob",
			clusterEdgeID: clusterEdgeIDs[0],
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplayJobs).
						WithArgs(clusterEdgeIDs[0]).
						WillReturnRows(mock.NewRows(logReplayJobs).
							AddRow(lrjJSONPaths[0], emptyString, true, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0]).
							AddRow(lrjJSONPaths[1], oneValue, false, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0]).
							AddRow(lrjJSONPaths[2], zeroValue, false, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0]).
							AddRow(lrjJSONPaths[3], emptyString, true, lrjNames[0], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[0]).
							AddRow(lrjJSONPaths[0], emptyString, true, lrjNames[1], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[1]).
							AddRow(lrjJSONPaths[1], emptyString, true, lrjNames[1], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[1]).
							AddRow(lrjJSONPaths[2], emptyString, true, lrjNames[1], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[1]).
							AddRow(lrjJSONPaths[3], oneValue, false, lrjNames[1], defaultQueued, defaultExecuted, lrStatuses[1], testUpdateTime, logReplayIDs[1])),
				}
			},
			expectedLogReplayJobs: []*model.LogReplayJob{
				{
					Jsonpath:    lrjJSONPaths[0],
					Value:       emptyString,
					Missing:     true,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
				{
					Jsonpath:    lrjJSONPaths[1],
					Value:       oneValue,
					Missing:     false,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
				{
					Jsonpath:    lrjJSONPaths[2],
					Value:       zeroValue,
					Missing:     false,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
				{
					Jsonpath:    lrjJSONPaths[3],
					Value:       emptyString,
					Missing:     true,
					Name:        lrjNames[0],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[0],
				},
				{
					Jsonpath:    lrjJSONPaths[0],
					Value:       emptyString,
					Missing:     true,
					Name:        lrjNames[1],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[1],
				},
				{
					Jsonpath:    lrjJSONPaths[1],
					Value:       emptyString,
					Missing:     true,
					Name:        lrjNames[1],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[1],
				},
				{
					Jsonpath:    lrjJSONPaths[2],
					Value:       emptyString,
					Missing:     true,
					Name:        lrjNames[1],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[1],
				},
				{
					Jsonpath:    lrjJSONPaths[3],
					Value:       oneValue,
					Missing:     false,
					Name:        lrjNames[1],
					Queued:      defaultQueued,
					Executed:    defaultExecuted,
					Status:      lrStatuses[1],
					UpdatedAt:   testFormattedUpdateTime,
					LogReplayID: logReplayIDs[1],
				},
			},
			expectedErr: "",
		},
	}

	service := NewLogReplayService(db)

	for _, test := range testCases {
		test.mocksQuery()

		t.Run(test.name, func(t *testing.T) {
			logReplayJobs, err := service.GetLogReplayJobs(context.Background(), clusterEdgeIDs[0])

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

			for index, item := range logReplayJobs {
				assert.Equal(t, test.expectedLogReplayJobs[index].Jsonpath, item.Jsonpath)
				assert.Equal(t, test.expectedLogReplayJobs[index].Value, item.Value)
				assert.Equal(t, test.expectedLogReplayJobs[index].Name, item.Name)
				assert.Equal(t, test.expectedLogReplayJobs[index].Status, item.Status)
				assert.Equal(t, test.expectedLogReplayJobs[index].UpdatedAt, item.UpdatedAt)
				assert.Equal(t, test.expectedLogReplayJobs[index].LogReplayID, item.LogReplayID)
			}
		})
	}
}

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

	mock.ExpectExec(sqlquery.DeleteLogReplay).WithArgs(logReplayIDs[0]).
		WillReturnResult(sqlmock.NewResult(1, 1))

	service := NewLogReplayService(db)

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

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

	testCases := []struct {
		name          string
		clusterEdgeID string
		payload       *model.CreateLogReplayPayload
		mocksExec     func() []*sqlmock.ExpectedExec
		expectedErr   string
	}{
		{
			name:          "Test 1 - Log Level DEBUG Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[0],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 2 - Log Level INFO Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[1],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[1], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 3 - Log Level NOTICE Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[2],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[2], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 4 - Log Level WARNING Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[3],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[3], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 5 - Log Level ERROR Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[4],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[4], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 6 - Log Level CRITICAL Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[5],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[5], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 7 - Log Level ALERT Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[6],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[6], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 8 - Log Level EMERGENCY Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[7],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[7], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 9 - Incorrect Start Time Format",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  "2024-04-25T15:34:12.101Z",
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[0],
			},
			expectedErr: "error validating ",
		},
		{
			name:          "Test 10 - Incorrect End Time Format",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: namespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    "2024-04-25T15:34:12.101Z",
				LogLevel:   model.AllLogLevels[0],
			},
			expectedErr: "error validating ",
		},
		{
			name:          "Test 11 - Longer Namespaces List Passed In",
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.CreateLogReplayPayload{
				Namespaces: longerNamespacesList,
				StartTime:  testFormattedStartTime,
				EndTime:    testFormattedEndTime,
				LogLevel:   model.AllLogLevels[0],
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.CreateLogReplay).
						WithArgs(clusterEdgeIDs[0], pq.Array(longerNamespacesList), logLevels[0], testFormattedStartTime, testFormattedEndTime, defaultQueued, defaultExecuted, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
	}

	service := NewLogReplayService(db)

	for _, test := range testCases {
		if test.expectedErr == "" {
			test.mocksExec()

			t.Run(test.name, func(t *testing.T) {
				result, err := service.CreateLogReplay(context.Background(), test.clusterEdgeID, *test.payload)
				assert.NoError(t, err)
				assert.True(t, result)
			})
		} else {
			t.Run(test.name, func(t *testing.T) {
				result, err := service.CreateLogReplay(context.Background(), test.clusterEdgeID, *test.payload)
				assert.ErrorContains(t, err, test.expectedErr)
				assert.False(t, result)
			})
		}
	}
}

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

	testCases := []struct {
		name          string
		logReplayID   string
		clusterEdgeID string
		payload       *model.UpdateLogReplayPayload
		mocksQuery    func() []*sqlmock.ExpectedQuery
		mocksExec     func() []*sqlmock.ExpectedExec
		expectedErr   string
	}{
		{
			name:          "Test 1 - Only Queued Passed IN",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Queued: &trueValue,
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], true, false, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 2 - Only executed Passed IN",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Executed: &trueValue,
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], false, true, lrStatuses[0]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 3 - Only Status Passed IN: PENDING",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Status: &model.AllLogReplayStatus[1],
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], false, false, lrStatuses[1]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 4 - Only Status Passed IN: SUCCEEDED",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Status: &model.AllLogReplayStatus[2],
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], false, false, lrStatuses[2]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 5 - Only Status Passed IN: SUCCEEDED",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Status: &model.AllLogReplayStatus[2],
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], false, false, lrStatuses[2]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 6 - Only Status Passed IN: FAILED",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Status: &model.AllLogReplayStatus[3],
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], false, false, lrStatuses[3]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		{
			name:          "Test 7 - Only Status Passed IN: TIMEOUT",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Status: &model.AllLogReplayStatus[4],
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], false, false, lrStatuses[4]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		//nolint
		{
			name:          "Test 8 - Only Executed and Status (SUCCEEDED)",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Executed: &trueValue,
				Status:   &model.AllLogReplayStatus[2],
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], false, true, lrStatuses[2]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
		//nolint
		{
			name:          "Test 9 - Only QUEUED and Status (PENDING)",
			logReplayID:   logReplayIDs[0],
			clusterEdgeID: clusterEdgeIDs[0],
			payload: &model.UpdateLogReplayPayload{
				Queued: &trueValue,
				Status: &model.AllLogReplayStatus[1],
			},
			mocksQuery: func() []*sqlmock.ExpectedQuery {
				return []*sqlmock.ExpectedQuery{
					mock.ExpectQuery(sqlquery.GetLogReplay).
						WithArgs(logReplayIDs[0]).
						WillReturnRows(mock.NewRows(logReplayRowsUpdated).
							AddRow(logReplayIDs[0], clusterEdgeIDs[0], pq.Array(namespacesList), logLevels[0], testStartTime, testEndTime, defaultQueued, defaultExecuted, lrStatuses[0], testUpdateTime)),
				}
			},
			mocksExec: func() []*sqlmock.ExpectedExec {
				return []*sqlmock.ExpectedExec{
					mock.ExpectExec(sqlquery.UpdateLogReplay).
						WithArgs(logReplayIDs[0], clusterEdgeIDs[0], true, false, lrStatuses[1]).
						WillReturnResult(sqlmock.NewResult(1, 1))}
			},
			expectedErr: "",
		},
	}

	service := NewLogReplayService(db)

	for _, test := range testCases {
		t.Run(test.name, func(t *testing.T) {
			test.mocksQuery()
			test.mocksExec()
			result, err := service.UpdateLogReplay(context.Background(), logReplayIDs[0], test.clusterEdgeID, *test.payload)
			assert.NoError(t, err)
			assert.True(t, result)
		})
	}
}