package services

import (
	"context"
	"database/sql/driver"
	"testing"

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

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

var (
	namespaces = []model.Namespace{
		{
			NamespaceEdgeID: "b83ba6a5-5954-4d0b-85b3-fd5d51388bc1",
			BannerEdgeID:    "d8ce5b2b-17a9-442a-a326-92479dd9475c",
			Name:            "test-namespace-1",
			Workload:        model.WorkloadTypeTenant,
		},
		{
			NamespaceEdgeID: "938593f4-68ca-4a89-8ded-94505ee7e740",
			BannerEdgeID:    "d8ce5b2b-17a9-442a-a326-92479dd9475c",
			Name:            "test-namespace-2",
			Workload:        model.WorkloadTypeTenant,
		},
		{
			NamespaceEdgeID: "678d2136-c366-441f-a463-4bbbddec4f74",
			BannerEdgeID:    "752136c0-66a8-49f3-9217-2a7ecb851c68",
			Name:            "test-namespace-3",
			Workload:        model.WorkloadTypeTenant,
		},
	}
	namespaceColumns = []string{"namespace_edge_id", "banner_edge_id", "name", "workload"}
)

func TestCreateNamespace(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockNamespace := namespaces[0]

	mock.ExpectBegin()
	mockDBNamespaceCreate(mock, mockNamespace, sqlmock.NewResult(1, 1))
	mock.ExpectCommit()

	service := NewNamespaceService(db)

	createNamespace := getNamespaceCreateInput(mockNamespace)
	_, createErr := service.CreateNamespaceEntry(context.Background(), createNamespace)
	mockErr := mock.ExpectationsWereMet()

	assert.NoError(t, createErr)
	assert.NoError(t, mockErr)
}

func TestDeleteNamespace(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	bannerEdgeID := namespaces[0].BannerEdgeID
	name := namespaces[0].Name

	mockDBNamespaceDelete(mock, bannerEdgeID, name, sqlmock.NewResult(1, 1))
	service := NewNamespaceService(db)

	if err := service.DeleteNamespaceEntry(context.Background(), bannerEdgeID, name); err != nil {
		t.Errorf("error was not expected while deleting namespace: %s", err)
	}

	assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetBannerNamespaces(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockNamespace := namespaces[0]

	mockDBGetBannerNamespaces(mock, mockNamespace.BannerEdgeID, mockNamespace.Name, []model.Namespace{mockNamespace})

	service := NewNamespaceService(db)

	returnNamespaces, err := service.GetBannerNamespaces(context.Background(), mockNamespace.BannerEdgeID, &mockNamespace.Name)

	assert.NoError(t, err)
	assert.NoError(t, mock.ExpectationsWereMet())
	assert.NotNil(t, returnNamespaces)
	assert.Equal(t, 1, len(returnNamespaces))
	assert.Equal(t, mockNamespace, *returnNamespaces[0])
}

func TestGetAllBannerNamespaces(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockNamespaces := namespaces[0:2]
	bannerEdgeID := mockNamespaces[0].BannerEdgeID

	mockDBGetAllBannerNamespaces(mock, bannerEdgeID, mockNamespaces)

	service := NewNamespaceService(db)

	returnNamespaces, err := service.GetBannerNamespaces(context.Background(), bannerEdgeID, nil)

	assert.NoError(t, err)
	assert.NoError(t, mock.ExpectationsWereMet())
	assert.NotNil(t, returnNamespaces)
	assert.Equal(t, len(mockNamespaces), len(returnNamespaces))
	assert.Equal(t, mockNamespaces[0], *returnNamespaces[0])
	assert.Equal(t, mockNamespaces[1], *returnNamespaces[1])
}

func TestGetClusterNamespaces(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockClusterNamespaces := namespaces[0:2]
	clusterEdgeID := "78613f69-785b-4a37-aa9a-e9e6aa341058"
	name := namespaces[0].Name

	mockDBGetClusterNamespaces(mock, clusterEdgeID, name, mockClusterNamespaces)

	service := NewNamespaceService(db)

	_, err = service.GetClusterNamespaces(context.Background(), clusterEdgeID, &name)

	assert.NoError(t, err)
	assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetAllClusterNamespaces(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockClusterNamespaces := namespaces[0:1]
	clusterEdgeID := "78613f69-785b-4a37-aa9a-e9e6aa341058"

	mockDBGetAllClusterNamespaces(mock, clusterEdgeID, mockClusterNamespaces)

	service := NewNamespaceService(db)

	_, err = service.GetClusterNamespaces(context.Background(), clusterEdgeID, nil)

	assert.NoError(t, err)
	assert.NoError(t, mock.ExpectationsWereMet())
}

func mockDBNamespaceCreate(mock sqlmock.Sqlmock, mockNamespace model.Namespace, result driver.Result) {
	input := []driver.Value{
		sqlmock.AnyArg(),
		mockNamespace.BannerEdgeID,
		mockNamespace.Name,
		mockNamespace.Workload,
	}

	mock.ExpectExec(sqlquery.NamespaceCreateQuery).
		WithArgs(input...).
		WillReturnResult(result)
}

func mockDBNamespaceDelete(mock sqlmock.Sqlmock, bannerEdgeID string, name string, result driver.Result) {
	input := []driver.Value{
		bannerEdgeID,
		name,
	}

	mock.ExpectExec(sqlquery.NamespaceDeleteQuery).
		WithArgs(input...).
		WillReturnResult(result)
}

func mockDBGetBannerNamespaces(mock sqlmock.Sqlmock, bannerEdgeID string, name string, returnNamespaces []model.Namespace) {
	rows := mock.NewRows(namespaceColumns)

	if len(returnNamespaces) != 0 {
		for _, returnNamespace := range returnNamespaces {
			rows.AddRow(returnNamespace.NamespaceEdgeID, returnNamespace.BannerEdgeID, returnNamespace.Name, returnNamespace.Workload)
		}
	}

	input := []driver.Value{
		bannerEdgeID,
		name,
	}

	mock.ExpectQuery(sqlquery.GetBannerNamespacesQuery).
		WithArgs(input...).
		WillReturnRows(rows)
}

func mockDBGetAllBannerNamespaces(mock sqlmock.Sqlmock, bannerEdgeID string, returnNamespaces []model.Namespace) {
	rows := mock.NewRows(namespaceColumns)

	if len(returnNamespaces) != 0 {
		for _, returnNamespace := range returnNamespaces {
			rows.AddRow(returnNamespace.NamespaceEdgeID, returnNamespace.BannerEdgeID, returnNamespace.Name, returnNamespace.Workload)
		}
	}

	input := []driver.Value{
		bannerEdgeID,
	}

	mock.ExpectQuery(sqlquery.GetAllBannerNamespacesQuery).
		WithArgs(input...).
		WillReturnRows(rows)
}

func mockDBGetClusterNamespaces(mock sqlmock.Sqlmock, clusterEdgeID string, name string, returnClusterNamespaces []model.Namespace) {
	rows := mock.NewRows(namespaceColumns)

	if len(returnClusterNamespaces) != 0 {
		for _, returnClusterNamespace := range returnClusterNamespaces {
			rows.AddRow(returnClusterNamespace.NamespaceEdgeID, returnClusterNamespace.BannerEdgeID, returnClusterNamespace.Name, returnClusterNamespace.Workload)
		}
	}

	input := []driver.Value{
		clusterEdgeID,
		name,
	}

	mock.ExpectQuery(sqlquery.GetClusterNamespacesQuery).
		WithArgs(input...).
		WillReturnRows(rows)
}

func mockDBGetAllClusterNamespaces(mock sqlmock.Sqlmock, clusterEdgeID string, returnClusterNamespaces []model.Namespace) {
	rows := mock.NewRows(namespaceColumns)

	if len(returnClusterNamespaces) != 0 {
		for _, returnClusterNamespace := range returnClusterNamespaces {
			rows.AddRow(returnClusterNamespace.NamespaceEdgeID, returnClusterNamespace.BannerEdgeID, returnClusterNamespace.Name, returnClusterNamespace.Workload)
		}
	}

	input := []driver.Value{
		clusterEdgeID,
	}

	mock.ExpectQuery(sqlquery.GetAllClusterNamespacesQuery).
		WithArgs(input...).
		WillReturnRows(rows)
}

func getNamespaceCreateInput(createNamespace model.Namespace) *model.NamespaceCreateInput {
	return &model.NamespaceCreateInput{
		BannerEdgeID: createNamespace.BannerEdgeID,
		Name:         createNamespace.Name,
		Workload:     createNamespace.Workload,
	}
}