package resolver

import (
	"context"
	"testing"

	"github.com/golang/mock/gomock"
	"github.com/stretchr/testify/assert"
	"helm.sh/helm/v3/pkg/repo"

	bsltypes "edge-infra.dev/pkg/edge/api/bsl/types"
	"edge-infra.dev/pkg/edge/api/graph/mapper"
	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/api/middleware"
	"edge-infra.dev/pkg/edge/api/mocks"
	"edge-infra.dev/pkg/edge/api/types"
	"edge-infra.dev/pkg/edge/constants"
	"edge-infra.dev/pkg/edge/externalsecrets"
)

var pID = "projectID"

func TestCreateHelmRepo(t *testing.T) {
	defaultWorkload := string(constants.TenantNamespaceSelector)
	name := "test-secret-name"
	url := "test-url"
	mock := gomock.NewController(t)
	gcpService := mocks.NewMockGCPService(mock)
	gcpService.EXPECT().AddSecret(gomock.Any(), name, constants.DefaultOwnerFilter, constants.HelmRepositorySecretType, gomock.Any(), pID, &defaultWorkload, nil).
		Return(nil).Times(1)

	bannerService := mocks.NewMockBannerService(mock)
	bannerService.EXPECT().GetBannerProjectID(gomock.Any(), "bannerEdgeID").
		Return(pID, nil).Times(2)

	helmService := mocks.NewMockHelmService(mock)
	helmService.EXPECT().GetHelmRepositoryIndex(url, pID, pID).
		Return(&repo.IndexFile{}, nil).Times(1)
	helmService.EXPECT().GenerateHelmReleaseExternalSecrets(gomock.Any(), pID, mapper.HelmReleaseNamespace, []string{"test-secret-name"}).
		Return([]*externalsecrets.ExternalSecret{}, nil).Times(1)
	helmService.EXPECT().SendExternalSecretToChariot(gomock.Any(), pID, "", gomock.Any()).
		Return(nil).Times(1)
	helmService.EXPECT().CreateBannerHelmRepository(gomock.Any(), name, url, &name, pID).
		Return(nil).Times(1)

	c := &types.Config{BSP: bsltypes.BSPConfig{OrganizationPrefix: "test_prefix-"}}
	r := &Resolver{
		GCPService:    gcpService,
		BannerService: bannerService,
		HelmService:   helmService,
		Config:        c,
	}

	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
		Username:     "test-user",
		Organization: "organization",
	})
	resp, err := r.Mutation().CreateHelmRepository(ctx, name, "bannerEdgeID", url, &pID, &pID)
	assert.NoError(t, err)
	assert.True(t, resp)
	resp, err = r.Mutation().CreateHelmRepository(ctx, constants.NCRCharts, "bannerEdgeID", url, &pID, &pID)
	assert.Error(t, err)
	assert.False(t, resp)
}

func TestDeleteHelmRepo(t *testing.T) {
	name := "test-secret-name"
	mock := gomock.NewController(t)
	gcpService := mocks.NewMockGCPService(mock)
	gcpService.EXPECT().DeleteSecret(gomock.Any(), name, pID).
		Return(true, nil).Times(1)

	bannerService := mocks.NewMockBannerService(mock)
	bannerService.EXPECT().GetBannerProjectID(gomock.Any(), "bannerEdgeID").
		Return(pID, nil).Times(1)

	helmService := mocks.NewMockHelmService(mock)
	helmService.EXPECT().DeleteHelmRepo(gomock.Any(), name, pID, "bannerEdgeID").
		Return(nil).Times(1)

	c := &types.Config{BSP: bsltypes.BSPConfig{OrganizationPrefix: "test_prefix-"}}
	r := &Resolver{
		GCPService:    gcpService,
		BannerService: bannerService,
		HelmService:   helmService,
		Config:        c,
	}

	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
		Username:     "test-user",
		Organization: "organization",
	})
	resp, err := r.Mutation().DeleteHelmRepository(ctx, name, "bannerEdgeID")
	assert.NoError(t, err)
	assert.True(t, resp)
	resp, err = r.Mutation().DeleteHelmRepository(ctx, constants.NCRCharts, "bannerEdgeID")
	assert.Error(t, err)
	assert.False(t, resp)
}

func TestGetHelmRepos(t *testing.T) {
	defaultOwnerFilter := constants.DefaultOwnerFilter
	helmRepoType := constants.HelmRepositorySecretType
	helmRepo1 := mapper.GetTestHelmRepositorySecret()
	helmRepo2 := mapper.GetTestHelmRepositorySecret()
	repos := []*model.SecretManagerResponse{helmRepo1, helmRepo2}
	mock := gomock.NewController(t)
	gcpService := mocks.NewMockGCPService(mock)
	//GetSecrets(ctx, nil, &defaultOwnerFilter, &helmRepoType, true, projectID)
	gcpService.EXPECT().GetSecrets(gomock.Any(), nil, &defaultOwnerFilter, &helmRepoType, true, pID).
		Return(repos, nil).Times(1)

	bannerService := mocks.NewMockBannerService(mock)
	bannerService.EXPECT().GetBannerProjectID(gomock.Any(), "bannerEdgeID").
		Return(pID, nil).Times(1)

	c := &types.Config{BSP: bsltypes.BSPConfig{OrganizationPrefix: "test_prefix-"}}
	r := &Resolver{
		GCPService:    gcpService,
		BannerService: bannerService,
		Config:        c,
	}

	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
		Username:     "test-user",
		Organization: "organization",
	})
	resp, err := r.Query().HelmRepositories(ctx, "bannerEdgeID")
	assert.NoError(t, err)
	assert.Equal(t, 2, len(resp))
	for i, releaseModel := range resp {
		mapper.VerifyHelmRepositoryEqualModel(repos[i], releaseModel, t)
	}
}