package edgebsl

import (
	"context"
	"errors"
	"fmt"

	"edge-infra.dev/pkg/edge/api/graph/model"
	btypes "edge-infra.dev/pkg/edge/api/types"
)

// processAllEdgeOrganizations processes all the edge organizations.
func (b *BSL) processAllEdgeOrganizations(ctx context.Context, orgs []AllEdgeOrgsPageContent, sm btypes.SecretManagerService, tenantsNames map[string]struct{}) error {
	log := b.logger.WithValues("bsl operator", "processing edge organizations")
	for _, org := range orgs {
		org := org
		if err := b.processEdgeOrganization(ctx, &org, sm, tenantsNames); err != nil {
			log.Error(err, "failed to process org")
			return err
		}
	}
	return nil
}

// edgeOrganizationUserTypes returns a slice of edge user types (super admin and org admin).
func edgeOrganizationUserTypes(org *AllEdgeOrgsPageContent) []edgeUser {
	return []edgeUser{
		{
			userType:   "superAdmin",
			secretName: OrgNameToK8sName(org.OrganizationName),
			bffUser:    true,
		},
		{
			userType:   "orgAdmin",
			secretName: fmt.Sprintf("%s-org-admin", OrgNameToK8sName(org.OrganizationName)),
			bffUser:    false,
		},
	}
}

// createEdgeOrganizationUserTypes creates the edge user secret.
func (b *BSL) createEdgeOrganizationUserTypes(ctx context.Context, sm btypes.SecretManagerService, org *AllEdgeOrgsPageContent) error {
	log := b.logger.WithValues("bsl operator", "creating edge organization user", "organization name", org)
	users := edgeOrganizationUserTypes(org)
	for _, user := range users {
		log.Info("creating edge organization user", "edge user type", user.userType)
		if err := b.CreateUserAndSecret(ctx, sm, org.OrganizationName, &b.bslConfig, log, user.secretName, user.bffUser); err != nil {
			b.metrics.ErrorInc("bsl_error", org.OrganizationName, err.Error())
			log.Error(err, "failed to create user secret", "bffuser", user.bffUser)
			return err
		}
	}
	return nil
}

// processEdgeOrganization processes a single edge organization.
func (b *BSL) processEdgeOrganization(ctx context.Context, org *AllEdgeOrgsPageContent, sm btypes.SecretManagerService, tenantsNames map[string]struct{}) error {
	log := b.logger.WithValues("bsl operator", "processing edge organization", "organization name", org.OrganizationName)
	b.metrics.OrgProcessedInc(org.OrganizationName)
	log.Info(LogWithOrg(org.OrganizationName, "Processing organization"))
	//create edge user groups (will represent roles)
	if err := b.bslConfig.CreateEdgeOrgGroups(ctx, org.OrganizationName); err != nil {
		b.metrics.ErrorInc("bsl_error", org.OrganizationName, err.Error())
		log.Error(err, LogWithOrg(org.OrganizationName, "failed to create bsl edge org groups"))
	}

	if err := b.bslConfig.AssignRolesToGroups(ctx, org.OrganizationName); err != nil {
		b.metrics.ErrorInc("bsl_error", org.OrganizationName, err.Error())
		if !errors.Is(err, ErrorResourceAlreadyExists) {
			log.Error(err, LogWithOrg(org.OrganizationName, "failed to assign edge roles to groups"))
		}
	}

	if err := b.bslConfig.CleanUpGroupRoles(ctx, org.OrganizationName); err != nil {
		log.Error(err, LogWithOrg(org.OrganizationName, "failed to revoke edge roles from groups"))
		return err
	}

	if err := b.createEdgeOrganizationUserTypes(ctx, sm, org); err != nil {
		return err
	}

	//create enterprise unit type in org {{provisioning.uri}}/enterprise-types
	if err := b.bslConfig.CreateEnterpriseUnitType(ctx, org.OrganizationName, EnterpriseTypeName, EnterpriseTypeDescription); err != nil {
		if !(err.Error() == ErrorResourceAlreadyExists.Error()) {
			b.metrics.ErrorInc("bsl_error", org.OrganizationName, err.Error())
			log.Error(err, LogWithOrg(org.OrganizationName, "failed to create bff bsl enterprise unit type"))
		}
	}

	log.Info(LogWithOrg(org.OrganizationName, "Organization is successfully setup"))
	if _, ok := tenantsNames[OrgNameToK8sName(org.OrganizationName)]; !ok {
		_, err := b.TenantService.Create(ctx, &model.TenantInput{TenantBSLId: org.ID, OrgName: org.OrganizationName})
		if err != nil {
			log.Error(err, "An error occurred create tenants entry")
			b.metrics.ErrorInc("sql_error", org.OrganizationName, err.Error())
		} else {
			tenantsNames[OrgNameToK8sName(org.OrganizationName)] = struct{}{}
		}
	}

	return nil
}