package consume

import (
	"encoding/json"
	"query-service/internal/adapters/brokeradapter"
	mockbrokerdriver "query-service/internal/drivers/brokerdriver/mock"
	mockkeyvaluedriver "query-service/internal/drivers/keyvaluedriver/mock"
	mockconvertquery "query-service/internal/usecases/convertquery/mock"
	"query-service/internal/usecases/produce"
	mockrequest "query-service/internal/usecases/request/mock"
	"testing"

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

func TestStart(t *testing.T) {
	// // Create broker adapter
	// brokerAdapter := brokeradapter.CreateGateway()
	// // Create a mock broker
	// mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
	// // Create mock key value store
	// keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
	// // Create new producer service
	// producerService := produce.NewService(mockBroker, keyValueStore)
	// // Create new convert query service
	// convertQueryService := convertquery.NewService()
	// // Create new request sender service
	// requestSenderService := request.NewService()
	// // Create new service
	// service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)
}

func TestHandleCorrectMessage(t *testing.T) {
	// Create broker adapter
	brokerAdapter := brokeradapter.CreateGateway()
	// Create a mock broker
	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
	// Create mock key value store
	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
	// Create new producer service
	producerService := produce.NewService(mockBroker, keyValueStore)
	producerService.Start()
	// Create new convert query service
	convertQueryService := mockconvertquery.NewService()
	// Create new request sender service
	requestSenderService := mockrequest.NewService()
	// Create new service
	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)

	// Create mock session and mock queue
	mockSession := "mock-session"
	mockQueue := "mock-queue"

	// Set the test-session sessionID queue to mock-queue in key value store
	keyValueStore.Set(&mockSession, &mockQueue)

	// Create headers containing a sessionID
	headers := make(map[string]interface{})
	headers["sessionID"] = mockSession
	mockMessage := brokeradapter.Message{
		Headers: headers,
		Body:    []byte("test message"),
	}

	// Assert that there have not been any messages sent yet
	assert.Empty(t, mockBroker.Messages)

	// Send the mock message
	service.HandleMessage(&mockMessage)

	// Assert that there now are two messages that have been sent with routing key mock-queue
	assert.Len(t, mockBroker.Messages[mockQueue], 2)

	// Assert that the first message is of type 'query_translation_result' and has 'Query converted' as value
	var translationMessage map[string]interface{}
	json.Unmarshal(mockBroker.Messages[mockQueue][0].Body, &translationMessage)
	assert.Equal(t, "query_translation_result", translationMessage["type"])
	assert.Equal(t, "Query converted", translationMessage["values"])

	// Assert that the second message is of type 'query_result' and contains no values
	var resultMessage map[string]interface{}
	json.Unmarshal(mockBroker.Messages[mockQueue][1].Body, &resultMessage)
	assert.Equal(t, "query_result", resultMessage["type"])
	assert.Empty(t, resultMessage["values"])
}

// Unit test message received with no session ID
func TestHandleMessageNoSessionID(t *testing.T) {
	// Create broker adapter
	brokerAdapter := brokeradapter.CreateGateway()
	// Create a mock broker
	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
	// Create mock key value store
	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
	// Create new producer service
	producerService := produce.NewService(mockBroker, keyValueStore)
	// Create new convert query service
	convertQueryService := mockconvertquery.NewService()
	// Create new request sender service
	requestSenderService := mockrequest.NewService()
	// Create new service
	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)

	// Create headers containing a sessionID
	headers := make(map[string]interface{})
	mockMessage := brokeradapter.Message{
		Headers: headers,
		Body:    []byte("test message"),
	}

	// Assert that there have not been any messages sent yet
	assert.Empty(t, mockBroker.Messages)

	// Send the mock message
	service.HandleMessage(&mockMessage)

	// Assert that there was no message published
	assert.Empty(t, mockBroker.Messages)
}

// Unit test receival of message and not being able to parse it
func TestFailToConvertQuery(t *testing.T) {
	// Create broker adapter
	brokerAdapter := brokeradapter.CreateGateway()
	// Create a mock broker
	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
	// Create mock key value store
	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
	// Create new producer service
	producerService := produce.NewService(mockBroker, keyValueStore)
	producerService.Start()
	// Create new convert query service
	convertQueryService := mockconvertquery.NewService()
	// Create new request sender service
	requestSenderService := mockrequest.NewService()
	// Create new service
	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)

	// Create mock session and mock queue
	mockSession := "mock-session"
	mockQueue := "mock-queue"

	// Set the test-session sessionID queue to mock-queue in key value store
	keyValueStore.Set(&mockSession, &mockQueue)

	// Create headers containing a sessionID
	headers := make(map[string]interface{})
	headers["sessionID"] = mockSession
	mockMessage := brokeradapter.Message{
		Headers: headers,
		Body:    []byte("test message"),
	}

	// Make it so that the conversion service throws an error
	convertQueryService.ToggleError()

	// Assert that there have not been any messages sent yet
	assert.Empty(t, mockBroker.Messages)

	// Send the mock message
	service.HandleMessage(&mockMessage)

	// Assert that there was an error message published
	var errorMsg map[string]interface{}
	json.Unmarshal(mockBroker.Messages[mockQueue][0].Body, &errorMsg)
	assert.Equal(t, "query_translation_error", errorMsg["type"])
}

// Test AQL querying error handling
func TestArangoError(t *testing.T) {
	// Create broker adapter
	brokerAdapter := brokeradapter.CreateGateway()
	// Create a mock broker
	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
	// Create mock key value store
	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
	// Create new producer service
	producerService := produce.NewService(mockBroker, keyValueStore)
	producerService.Start()
	// Create new convert query service
	convertQueryService := mockconvertquery.NewService()
	// Create new request sender service
	requestSenderService := mockrequest.NewService()
	// Create new service
	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)

	// Create mock session and mock queue
	mockSession := "mock-session"
	mockQueue := "mock-queue"

	// Set the test-session sessionID queue to mock-queue in key value store
	keyValueStore.Set(&mockSession, &mockQueue)

	// Create headers containing a sessionID
	headers := make(map[string]interface{})
	headers["sessionID"] = mockSession
	mockMessage := brokeradapter.Message{
		Headers: headers,
		Body:    []byte("test message"),
	}

	// Make it so that the request sender service throws an error
	requestSenderService.ToggleError()

	// Assert that there have not been any messages sent yet
	assert.Empty(t, mockBroker.Messages)

	// Send the mock message
	service.HandleMessage(&mockMessage)

	// Assert that there was an error message published
	var errorMsg map[string]interface{}
	json.Unmarshal(mockBroker.Messages[mockQueue][1].Body, &errorMsg)
	assert.Equal(t, "query_database_error", errorMsg["type"])
}