package privatelink

import (
	"context"
	"strconv"

	globaldedicatedv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/dedicated/v1"
	"github.com/tidbcloud/tidb-management-service/dedicated-global-service/domain/service/workflow/common"
	"github.com/tidbcloud/tidb-management-service/utilities/bizerr"
	"github.com/tidbcloud/tidb-management-service/utilities/workflow"
)

func (svc *service) DeleteService(
	ctx context.Context,
	req *globaldedicatedv1.DeletePrivateLinkServiceRequest,
) bizerr.BizError {
	ctx, span := tracer.Start(ctx, "Domain.DeletePrivateLinkServiceSvc")
	defer span.End()

	err := svc.transaction.Transaction(ctx, func(ctx context.Context) error {
		cluster, err := svc.clusterRepo.Get(ctx, req.ClusterId, false)
		if err != nil {
			return err
		}

		tidbGroup, err := svc.tidbGroupRepo.LoadDefault(ctx, req.ClusterId)
		if err != nil {
			return err
		}

		_, err = svc.privateLinkEndpointRepo.DeleteByTidbGroupID(ctx, req.ClusterId, tidbGroup.Id)
		if err != nil {
			return err
		}

		// Start async reconciliation workflow.
		workFlowErr := svc.workflow.RunDagWithBizId(
			ctx,
			common.DeletePrivateLinkService,
			strconv.FormatUint(cluster.OrganizationId, 10),
			strconv.FormatUint(cluster.ProjectId, 10),
			strconv.FormatUint(cluster.ClusterId, 10),
			map[string]string{
				workflow.KeyTraceId:             workflow.GetTraceId(ctx),
				common.KeyClusterId:             strconv.FormatUint(cluster.ClusterId, 10),
				common.KeyPrivateLinkServiceIds: strconv.FormatUint(tidbGroup.Id, 10),
			},
		)
		if workFlowErr != nil {
			return bizerr.WrapErrorWithCode(workFlowErr, bizerr.ErrCodeUnknown, "create async workflow failed")
		}
		return nil
	})
	if err != nil {
		return bizerr.WrapError(err, "delete PrivateLink service failed")
	}

	return nil
}