package resolver

import (
	"context"
	"testing"

	"github.com/golang/mock/gomock"
	"github.com/stretchr/testify/assert"

	bsltypes "edge-infra.dev/pkg/edge/api/bsl/types"
	"edge-infra.dev/pkg/edge/api/graph/model"
	seeding "edge-infra.dev/pkg/edge/api/graph/test"
	"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/lib/uuid"
)

func TestCreateHelmRelease(t *testing.T) {
	mock := gomock.NewController(t)
	helmService := mocks.NewMockHelmService(mock)
	bannerService := mocks.NewMockBannerService(mock)
	clusterID := uuid.New().UUID

	mockCreateHelmReleasePayload := model.HelmReleasePayload{
		Name:           "pod-info",
		Secret:         "platform-read",
		HelmRepository: "ncr-edge",
		HelmChart:      "pod-info",
		Version:        "1.0.0",
		Namespace:      "test-namespace",
		ClusterEdgeID:  &clusterID,
	}

	cluster := seeding.Clusters[0].ConvertToModel()
	storeClusterService := mocks.NewMockStoreClusterService(mock)
	storeClusterService.EXPECT().GetCluster(gomock.Any(), gomock.Any()).Return(&cluster, nil).AnyTimes()

	helmService.EXPECT().ValidateHelmConfigAgainstSchema(gomock.Any(), mockCreateHelmReleasePayload.ConfigValues, gomock.Any(), mockCreateHelmReleasePayload.HelmChart, mockCreateHelmReleasePayload.Version, mockCreateHelmReleasePayload.Secret).
		Return(true, nil).Times(1)
	helmService.EXPECT().
		CreateHelmReleaseSQL(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(nil).Times(1)

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

	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
		Username:     "test-user",
		Organization: "organization",
	})

	helmRelease, err := r.Mutation().CreateHelmRelease(ctx, mockCreateHelmReleasePayload)

	assert.NoError(t, err)
	assert.NotNil(t, helmRelease)
	assert.True(t, helmRelease)
}

func TestUpdateHelmRelease(t *testing.T) {
	mock := gomock.NewController(t)
	helmService := mocks.NewMockHelmService(mock)
	bannerService := mocks.NewMockBannerService(mock)
	configValues := ""
	projectID := uuid.New().UUID
	helmWorkload := model.HelmWorkload{
		HelmEdgeID:       uuid.New().UUID,
		Name:             "test-update-helm",
		HelmRepository:   "ncr-edge",
		HelmChart:        "pod-info",
		HelmChartVersion: "1.0.0",
		HelmRepoSecret:   "platform-read",
		Namespace:        "test-namespace",
		ConfigValues:     &configValues,
		BannerEdgeID:     uuid.New().UUID,
	}

	helmService.EXPECT().GetHelmWorkloadSQL(gomock.Any(), helmWorkload.HelmEdgeID).Return(&helmWorkload, nil).Times(1)
	bannerService.EXPECT().GetBannerProjectID(gomock.Any(), helmWorkload.BannerEdgeID).Return(projectID, nil).Times(1)
	helmService.EXPECT().ValidateHelmConfigAgainstSchema(gomock.Any(), &configValues, projectID, helmWorkload.HelmChart, helmWorkload.HelmChartVersion, helmWorkload.HelmRepoSecret).
		Return(true, nil).Times(1)
	helmService.EXPECT().UpdateHelmReleaseSQL(gomock.Any(), helmWorkload.HelmEdgeID, helmWorkload.HelmChartVersion, helmWorkload.ConfigValues, nil).Return(nil).Times(1)

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

	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
		Username:     "test-user",
		Organization: "organization",
	})

	helmRelease, err := r.Mutation().UpdateHelmRelease(ctx, &helmWorkload.HelmEdgeID, nil, nil, nil, nil, nil, nil, nil)

	assert.NoError(t, err)
	assert.NotNil(t, helmRelease)
	assert.True(t, helmRelease)
}