package connect_v1

// This file will be automatically regenerated based on the schema, any resolver
// implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen version v0.17.94

import (
	"context"
	"errors"

	"go.gearno.de/kit/log"
	"go.probo.inc/probo/pkg/coredata"
	"go.probo.inc/probo/pkg/iam"
	"go.probo.inc/probo/pkg/page"
	"go.probo.inc/probo/pkg/server/api/authn"
	"go.probo.inc/probo/pkg/server/api/connect/v1/schema"
	"go.probo.inc/probo/pkg/server/api/connect/v1/types"
	"go.probo.inc/probo/pkg/server/gqlutils"
	"go.probo.inc/probo/pkg/server/gqlutils/types/cursor"
)

// Permission is the resolver for the permission field.
func (r *connectorResolver) Permission(ctx context.Context, obj *types.Connector, action string) (bool, error) {
	return r.Resolver.Permission(ctx, obj, action)
}

// CreateSCIMConfiguration is the resolver for the createSCIMConfiguration field.
func (r *mutationResolver) CreateSCIMConfiguration(ctx context.Context, input types.CreateSCIMConfigurationInput) (*types.CreateSCIMConfigurationPayload, error) {
	if _, err := r.authorize(ctx, input.OrganizationID, iam.ActionSCIMConfigurationCreate); err != nil {
		return nil, err
	}

	config, token, err := r.iam.OrganizationService.CreateSCIMConfiguration(ctx, input.OrganizationID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot create scim configuration", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	var bridge *types.SCIMBridge

	if input.ConnectorID != nil {
		scimBridge, err := r.iam.OrganizationService.CreateSCIMBridge(ctx, input.OrganizationID, config.ID, *input.ConnectorID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot create scim bridge", log.Error(err))
			return nil, gqlutils.Internal(ctx)
		}

		bridge = types.NewSCIMBridge(scimBridge)
	}

	payload := &types.CreateSCIMConfigurationPayload{
		ScimConfiguration: types.NewSCIMConfiguration(config),
		ScimBridge:        bridge,
		Token:             token,
	}

	return payload, nil
}

// DeleteSCIMConfiguration is the resolver for the deleteSCIMConfiguration field.
func (r *mutationResolver) DeleteSCIMConfiguration(ctx context.Context, input types.DeleteSCIMConfigurationInput) (*types.DeleteSCIMConfigurationPayload, error) {
	if _, err := r.authorize(ctx, input.OrganizationID, iam.ActionSCIMConfigurationDelete); err != nil {
		return nil, err
	}

	err := r.iam.OrganizationService.DeleteSCIMConfiguration(ctx, input.OrganizationID, input.ScimConfigurationID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot delete scim configuration", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteSCIMConfigurationPayload{DeletedScimConfigurationID: input.ScimConfigurationID}, nil
}

// RegenerateSCIMToken is the resolver for the regenerateSCIMToken field.
func (r *mutationResolver) RegenerateSCIMToken(ctx context.Context, input types.RegenerateSCIMTokenInput) (*types.RegenerateSCIMTokenPayload, error) {
	if _, err := r.authorize(ctx, input.ScimConfigurationID, iam.ActionSCIMConfigurationUpdate); err != nil {
		return nil, err
	}

	config, token, err := r.iam.OrganizationService.RegenerateSCIMToken(ctx, input.OrganizationID, input.ScimConfigurationID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot regenerate scim token", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.RegenerateSCIMTokenPayload{
		ScimConfiguration: types.NewSCIMConfiguration(config),
		Token:             token,
	}, nil
}

// UpdateSCIMBridge is the resolver for the updateSCIMBridge field.
func (r *mutationResolver) UpdateSCIMBridge(ctx context.Context, input types.UpdateSCIMBridgeInput) (*types.UpdateSCIMBridgePayload, error) {
	if _, err := r.authorize(ctx, input.ScimBridgeID, iam.ActionSCIMBridgeUpdate); err != nil {
		return nil, err
	}

	bridge, err := r.iam.OrganizationService.UpdateSCIMBridge(ctx, input.OrganizationID, input.ScimBridgeID, input.ExcludedUserNames)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot update scim bridge excluded user names", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateSCIMBridgePayload{
		ScimBridge: types.NewSCIMBridge(bridge),
	}, nil
}

// RequestSCIMEventExport is the resolver for the requestSCIMEventExport field.
func (r *mutationResolver) RequestSCIMEventExport(ctx context.Context, input types.RequestSCIMEventExportInput) (*types.RequestSCIMEventExportPayload, error) {
	scope, err := r.authorize(ctx, input.OrganizationID, iam.ActionSCIMEventExport)
	if err != nil {
		return nil, err
	}

	identity := authn.IdentityFromContext(ctx)

	logExport, err := r.iam.OrganizationService.RequestLogExport(
		ctx,
		scope,
		iam.RequestLogExportRequest{
			OrganizationID: input.OrganizationID,
			Type:           coredata.ExportJobTypeSCIMEvent,
			FromTime:       input.FromTime,
			ToTime:         input.ToTime,
			RecipientEmail: identity.EmailAddress,
			RecipientName:  identity.FullName,
		},
	)
	if err != nil {
		if _, ok := errors.AsType[*iam.ErrInvalidLogExportTimeRange](err); ok {
			return nil, gqlutils.Invalid(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot request SCIM event export", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.RequestSCIMEventExportPayload{
		ExportJobID: logExport.ID,
	}, nil
}

// ScimConfiguration is the resolver for the scimConfiguration field.
func (r *sCIMBridgeResolver) ScimConfiguration(ctx context.Context, obj *types.SCIMBridge) (*types.SCIMConfiguration, error) {
	if _, err := r.authorize(ctx, obj.ScimConfiguration.ID, iam.ActionSCIMConfigurationGet); err != nil {
		return nil, err
	}

	if gqlutils.OnlyIDSelected(ctx) {
		return &types.SCIMConfiguration{
			ID: obj.ScimConfiguration.ID,
		}, nil
	}

	scimConfiguration, err := r.iam.GetSCIMConfiguration(ctx, obj.ScimConfiguration.ID)
	if err != nil {
		if _, ok := errors.AsType[*iam.ErrNoSCIMConfigurationFound](err); ok {
			return nil, nil
		}

		return nil, err
	}

	return types.NewSCIMConfiguration(scimConfiguration), nil
}

// Connector is the resolver for the connector field.
func (r *sCIMBridgeResolver) Connector(ctx context.Context, obj *types.SCIMBridge) (*types.Connector, error) {
	if obj.Connector == nil {
		return nil, nil
	}

	// Authorize based on the SCIM configuration (connector accessed via bridge is a sub-resource)
	if _, err := r.authorize(ctx, obj.ScimConfiguration.ID, iam.ActionSCIMConfigurationGet); err != nil {
		return nil, err
	}

	if gqlutils.OnlyIDSelected(ctx) {
		return &types.Connector{
			ID: obj.Connector.ID,
		}, nil
	}

	// Use metadata-only loading since we don't need the encrypted connection data
	connector, err := r.iam.OrganizationService.GetConnectorMetadataByID(ctx, obj.Connector.ID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot get connector", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewConnector(connector), nil
}

// Permission is the resolver for the permission field.
func (r *sCIMBridgeResolver) Permission(ctx context.Context, obj *types.SCIMBridge, action string) (bool, error) {
	return r.Resolver.Permission(ctx, obj, action)
}

// EndpointURL is the resolver for the endpointUrl field.
func (r *sCIMConfigurationResolver) EndpointURL(ctx context.Context, obj *types.SCIMConfiguration) (string, error) {
	return r.baseURL.WithPath("/api/connect/v1/scim/2.0").MustString(), nil
}

// Organization is the resolver for the organization field.
func (r *sCIMConfigurationResolver) Organization(ctx context.Context, obj *types.SCIMConfiguration) (*types.Organization, error) {
	if _, err := r.authorize(ctx, obj.Organization.ID, iam.ActionOrganizationGet); err != nil {
		return nil, err
	}

	if gqlutils.OnlyIDSelected(ctx) {
		return &types.Organization{
			ID: obj.Organization.ID,
		}, nil
	}

	organization, err := r.iam.OrganizationService.GetOrganization(ctx, obj.Organization.ID)
	if err != nil {
		if _, ok := errors.AsType[*iam.ErrOrganizationNotFound](err); ok {
			return nil, nil
		}

		r.logger.ErrorCtx(ctx, "cannot get organization for scim configuration", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return types.NewOrganization(organization), nil
}

// Bridge is the resolver for the bridge field.
func (r *sCIMConfigurationResolver) Bridge(ctx context.Context, obj *types.SCIMConfiguration) (*types.SCIMBridge, error) {
	if obj.Bridge == nil {
		return nil, nil
	}

	if _, err := r.authorize(ctx, obj.Bridge.ID, iam.ActionSCIMConfigurationGet); err != nil {
		return nil, err
	}

	bridge, err := r.iam.OrganizationService.GetSCIMBridgeByID(ctx, obj.Bridge.ID)
	if err != nil {
		if _, ok := errors.AsType[*iam.ErrSCIMBridgeNotFound](err); ok {
			return nil, nil
		}

		r.logger.ErrorCtx(ctx, "cannot get scim bridge", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return types.NewSCIMBridge(bridge), nil
}

// Events is the resolver for the events field.
func (r *sCIMConfigurationResolver) Events(ctx context.Context, obj *types.SCIMConfiguration, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.SCIMEventOrderBy) (*types.SCIMEventConnection, error) {
	if _, err := r.authorize(ctx, obj.ID, iam.ActionSCIMEventList); err != nil {
		return nil, err
	}

	pageOrderBy := page.OrderBy[coredata.SCIMEventOrderField]{
		Field:     coredata.SCIMEventOrderFieldCreatedAt,
		Direction: page.OrderDirectionDesc,
	}
	if orderBy != nil {
		pageOrderBy.Field = coredata.SCIMEventOrderField(orderBy.Field)
		pageOrderBy.Direction = page.OrderDirection(orderBy.Direction)
	}

	cursor := cursor.NewCursor(first, after, last, before, pageOrderBy)

	events, err := r.iam.OrganizationService.ListSCIMEventsByConfigID(ctx, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list scim events", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewSCIMEventConnection(events, r, obj.ID), nil
}

// Permission is the resolver for the permission field.
func (r *sCIMConfigurationResolver) Permission(ctx context.Context, obj *types.SCIMConfiguration, action string) (bool, error) {
	return r.Resolver.Permission(ctx, obj, action)
}

// Permission is the resolver for the permission field.
func (r *sCIMEventResolver) Permission(ctx context.Context, obj *types.SCIMEvent, action string) (bool, error) {
	return r.Resolver.Permission(ctx, obj, action)
}

// TotalCount is the resolver for the totalCount field.
func (r *sCIMEventConnectionResolver) TotalCount(ctx context.Context, obj *types.SCIMEventConnection) (*int, error) {
	if _, err := r.authorize(ctx, obj.ParentID, iam.ActionSCIMEventList); err != nil {
		return nil, err
	}

	switch obj.Resolver.(type) {
	case *sCIMConfigurationResolver:
		count, err := r.iam.OrganizationService.CountSCIMEvents(ctx, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count scim events", log.Error(err))
			return nil, gqlutils.Internal(ctx)
		}

		return &count, nil
	}

	r.logger.ErrorCtx(ctx, "unsupported resolver", log.Any("resolver", obj.Resolver))

	return nil, gqlutils.Internal(ctx)
}

// Connector returns schema.ConnectorResolver implementation.
func (r *Resolver) Connector() schema.ConnectorResolver { return &connectorResolver{r} }

// SCIMBridge returns schema.SCIMBridgeResolver implementation.
func (r *Resolver) SCIMBridge() schema.SCIMBridgeResolver { return &sCIMBridgeResolver{r} }

// SCIMConfiguration returns schema.SCIMConfigurationResolver implementation.
func (r *Resolver) SCIMConfiguration() schema.SCIMConfigurationResolver {
	return &sCIMConfigurationResolver{r}
}

// SCIMEvent returns schema.SCIMEventResolver implementation.
func (r *Resolver) SCIMEvent() schema.SCIMEventResolver { return &sCIMEventResolver{r} }

// SCIMEventConnection returns schema.SCIMEventConnectionResolver implementation.
func (r *Resolver) SCIMEventConnection() schema.SCIMEventConnectionResolver {
	return &sCIMEventConnectionResolver{r}
}

type (
	connectorResolver           struct{ *Resolver }
	sCIMBridgeResolver          struct{ *Resolver }
	sCIMConfigurationResolver   struct{ *Resolver }
	sCIMEventResolver           struct{ *Resolver }
	sCIMEventConnectionResolver struct{ *Resolver }
)