package services

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

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

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

func TestTenantService_List(t *testing.T) {
	db, sqlMock := setup(t)
	defer db.Close()

	mockTentant := &model.Tenant{
		TenantBSLId:  "5dcabc872e4f4c37975fa3ff16022910",
		TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
		OrgName:      "test-bsl-org-1",
	}

	type test struct {
		testName         string
		mockSQLQuery     func() *sqlmock.ExpectedQuery
		expectedLen      int
		expectedTenantID string
	}

	bspCfg := types.BSPConfig{}

	bslClient := bsl.NewBSLClient(bspCfg)

	service := NewTenantService(db, bslClient, nil)

	tests := []test{
		{
			testName:         "listTenants",
			expectedLen:      1,
			expectedTenantID: mockTentant.TenantEdgeID,
			mockSQLQuery: func() *sqlmock.ExpectedQuery {
				return sqlMock.ExpectQuery(sqlquery.TenantListQuery).
					WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
						AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
			},
		},
	}

	for _, tc := range tests {
		tc.mockSQLQuery()
		t.Run(tc.testName, func(t *testing.T) {
			tenants, err := service.List(context.Background())
			assert.Equal(t, len(tenants), tc.expectedLen)
			assert.Equal(t, tenants[0].TenantEdgeID, tc.expectedTenantID)

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

func TestTenantService_GetByTenantID(t *testing.T) {
	db, sqlMock := setup(t)
	defer db.Close()

	mockTentant := &model.Tenant{
		TenantBSLId:  "5dcabc872e4f4c37975fa3ff16022910",
		TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
		OrgName:      "test-bsl-org-1",
	}

	type test struct {
		testName         string
		mockSQLQuery     func() *sqlmock.ExpectedQuery
		expectedLen      int
		expectedTenantID string
	}

	bspCfg := types.BSPConfig{}

	bslClient := bsl.NewBSLClient(bspCfg)

	service := NewTenantService(db, bslClient, nil)

	tests := []test{
		{
			testName:         "getTenantByID",
			expectedLen:      1,
			expectedTenantID: mockTentant.TenantEdgeID,
			mockSQLQuery: func() *sqlmock.ExpectedQuery {
				return sqlMock.ExpectQuery(sqlquery.TenantGetQuery).
					WithArgs(mockTentant.TenantEdgeID).
					WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
						AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
			},
		},
	}

	for _, tc := range tests {
		tc.mockSQLQuery()
		t.Run(tc.testName, func(t *testing.T) {
			tenant, err := service.Get(context.Background(), mockTentant.TenantEdgeID)

			assert.Equal(t, tc.expectedTenantID, tenant.TenantEdgeID)
			assert.NoError(t, err)
		})
	}
}

func TestTenantService_GetTenantByBannerIDOrByClusterEdgeID(t *testing.T) {
	db, sqlMock := setup(t)
	defer db.Close()

	mockTentant := &model.Tenant{
		TenantBSLId:  "5dcabc872e4f4c37975fa3ff16022910",
		TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
		OrgName:      "test-bsl-org-1",
	}

	type test struct {
		testName         string
		mockSQLQuery     func() *sqlmock.ExpectedQuery
		service          func() (*model.Tenant, error)
		expectedTenantID string
	}

	bspCfg := types.BSPConfig{}

	bslClient := bsl.NewBSLClient(bspCfg)

	service := NewTenantService(db, bslClient, nil)

	tests := []test{

		{
			testName:         "getTenantByBannerID",
			expectedTenantID: mockTentant.TenantEdgeID,
			service: func() (*model.Tenant, error) {
				return service.GetTenantByBannerID(context.Background(), testBannerID)
			},
			mockSQLQuery: func() *sqlmock.ExpectedQuery {
				return sqlMock.ExpectQuery(sqlquery.GetTenantByBannerEdgeID).
					WithArgs(testBannerID).
					WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
						AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
			},
		},
		{
			testName:         "getTenantByClusterEdgeID",
			expectedTenantID: mockTentant.TenantEdgeID,
			service: func() (*model.Tenant, error) {
				return service.GetTenantByClusterEdgeID(context.Background(), testClusterEdgeID)
			},
			mockSQLQuery: func() *sqlmock.ExpectedQuery {
				return sqlMock.ExpectQuery(sqlquery.GetTenantByClusterEdgeID).
					WithArgs(testClusterEdgeID).
					WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
						AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
			},
		},
	}

	for _, tc := range tests {
		tc.mockSQLQuery()
		t.Run(tc.testName, func(t *testing.T) {
			tenant, err := tc.service()
			assert.Equal(t, tc.expectedTenantID, tenant.TenantEdgeID)
			assert.NoError(t, err)
		})
	}
}

func TestTenantService_Create(t *testing.T) {
	db, sqlMock := setup(t)
	sqlMock.MatchExpectationsInOrder(false)

	defer db.Close()

	mockTentant := &model.Tenant{
		TenantBSLId:  "5dcabc872e4f4c37975fa3ff16022910",
		TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
		OrgName:      "test-bsl-org-1",
	}

	type test struct {
		testName         string
		mockSQLQuery     func() *sqlmock.ExpectedQuery
		mockSQLInsert    func() *sqlmock.ExpectedExec
		expectedTenantID string
	}

	bspCfg := types.BSPConfig{}

	bslClient := bsl.NewBSLClient(bspCfg)

	service := NewTenantService(db, bslClient, nil)

	tests := []test{
		{
			testName:         "createTenant",
			expectedTenantID: mockTentant.TenantEdgeID,
			mockSQLInsert: func() *sqlmock.ExpectedExec {
				return sqlMock.ExpectExec(sqlquery.TenantInsertQuery).
					WithArgs(mockTentant.TenantBSLId, mockTentant.OrgName).
					WillReturnResult(sqlmock.NewResult(1, 1))
			},
			mockSQLQuery: func() *sqlmock.ExpectedQuery {
				return sqlMock.ExpectQuery(sqlquery.TenantGetNoIDQuery).
					WithArgs(mockTentant.TenantBSLId, mockTentant.OrgName).
					WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
						AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
			},
		},
	}

	for _, tc := range tests {
		tc.mockSQLInsert()
		tc.mockSQLQuery()

		t.Run(tc.testName, func(t *testing.T) {
			tenant, err := service.Create(context.Background(), &model.TenantInput{
				OrgName:     mockTentant.OrgName,
				TenantBSLId: mockTentant.TenantBSLId,
			})

			assert.Equal(t, tc.expectedTenantID, tenant.TenantEdgeID)
			assert.NoError(t, err)
		})
	}
}

func TestTenantService_GetOktaTenants(t *testing.T) {
	testOktaToken := "test-okta-token"

	db, sqlMock := setup(t)
	sqlMock.MatchExpectationsInOrder(false)

	defer db.Close()

	mockTenants := []*model.Tenant{
		{
			TenantBSLId:  "5dcabc872e4f4c37975fa3ff16022910",
			TenantEdgeID: "578fbb65-3ae7-466e-9241-fb5e2aee306d",
			OrgName:      "test-bsl-org-1",
		},
		{
			TenantBSLId:  "5dcabc874e4f4c37975fa3ff16022911",
			TenantEdgeID: "773083cd-476e-40fb-a174-7a761c33acdd",
			OrgName:      "test-bsl-org-2",
		},
		{
			TenantBSLId:  "7dcabc872e4f4c37975fa3ff16022912",
			TenantEdgeID: "569e1a86-bb52-4b9d-95d5-9fb3892a2496",
			OrgName:      "test-bsl-org-3",
		},
	}

	svr := GetMockBspServer(testOrg, testOrgID, testUser, "", "", "")

	bspCfg := types.BSPConfig{
		Endpoint: svr.URL,
		Root:     "/customers/",
	}

	for _, mockTenant := range mockTenants {
		sqlMock.ExpectQuery(sqlquery.TenantGetByName).
			WithArgs(mockTenant.OrgName).
			WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
				AddRow(mockTenant.TenantEdgeID, mockTenant.TenantBSLId, mockTenant.OrgName))
	}

	bslClient := bsl.NewBSLClient(bspCfg)

	service := NewTenantService(db, bslClient, &bspCfg)

	tenants, err := service.GetOktaTenants(context.Background(), testOktaToken)
	assert.NoError(t, err)
	assert.Len(t, tenants, 3)
}

func setup(t *testing.T) (*sql.DB, sqlmock.Sqlmock) {
	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)
	}

	return db, mock
}