share_code.go

package page

import (
	"context"
	"fmt"

	"github.com/ministryofjustice/opg-modernising-lpa/internal/actor"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/actor/actoruid"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/event"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/localize"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/lpastore"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/notify"
)

type ShareCodeSender struct {
	testCode       string
	shareCodeStore ShareCodeStore
	notifyClient   NotifyClient
	appPublicURL   string
	randomString   func(int) string
	eventClient    EventClient
}

func NewShareCodeSender(shareCodeStore ShareCodeStore, notifyClient NotifyClient, appPublicURL string, randomString func(int) string, eventClient EventClient) *ShareCodeSender {
	return &ShareCodeSender{
		shareCodeStore: shareCodeStore,
		notifyClient:   notifyClient,
		appPublicURL:   appPublicURL,
		randomString:   randomString,
		eventClient:    eventClient,
	}
}

func (s *ShareCodeSender) UseTestCode(shareCode string) {
	s.testCode = shareCode
}

type CertificateProviderInvite struct {
	LpaUID              string
	Type                actor.LpaType
	Donor               actor.Donor
	CertificateProvider actor.CertificateProvider
}

func (s *ShareCodeSender) SendCertificateProviderInvite(ctx context.Context, appData AppData, donor CertificateProviderInvite) error {
	shareCode, err := s.createShareCode(ctx, appData, donor.CertificateProvider.UID, actor.TypeCertificateProvider)
	if err != nil {
		return err
	}

	return s.sendEmail(ctx, donor.CertificateProvider.Email, donor.LpaUID, notify.CertificateProviderInviteEmail{
		CertificateProviderFullName: donor.CertificateProvider.FullName(),
		DonorFullName:               donor.Donor.FullName(),
		LpaType:                     localize.LowerFirst(appData.Localizer.T(donor.Type.String())),
		CertificateProviderStartURL: fmt.Sprintf("%s%s", s.appPublicURL, Paths.CertificateProviderStart),
		DonorFirstNames:             donor.Donor.FirstNames,
		DonorFirstNamesPossessive:   appData.Localizer.Possessive(donor.Donor.FirstNames),
		WhatLpaCovers:               appData.Localizer.T(donor.Type.WhatLPACoversTransKey()),
		ShareCode:                   shareCode,
	})
}

func (s *ShareCodeSender) SendCertificateProviderPrompt(ctx context.Context, appData AppData, donor *actor.DonorProvidedDetails) error {
	shareCode, err := s.createShareCode(ctx, appData, donor.CertificateProvider.UID, actor.TypeCertificateProvider)
	if err != nil {
		return err
	}

	if donor.CertificateProvider.CarryOutBy.IsPaper() {
		return s.sendPaperForm(ctx, donor.LpaUID, actor.TypeCertificateProvider, donor.CertificateProvider.UID, shareCode)
	}

	return s.sendEmail(ctx, donor.CertificateProvider.Email, donor.LpaUID, notify.CertificateProviderProvideCertificatePromptEmail{
		CertificateProviderFullName: donor.CertificateProvider.FullName(),
		DonorFullName:               donor.Donor.FullName(),
		LpaType:                     localize.LowerFirst(appData.Localizer.T(donor.Type.String())),
		CertificateProviderStartURL: fmt.Sprintf("%s%s", s.appPublicURL, Paths.CertificateProviderStart),
		ShareCode:                   shareCode,
	})
}

func (s *ShareCodeSender) SendAttorneys(ctx context.Context, appData AppData, donor *lpastore.Lpa) error {
	if err := s.sendTrustCorporation(ctx, appData, donor, donor.Attorneys.TrustCorporation); err != nil {
		return err
	}
	if err := s.sendReplacementTrustCorporation(ctx, appData, donor, donor.ReplacementAttorneys.TrustCorporation); err != nil {
		return err
	}

	for _, attorney := range donor.Attorneys.Attorneys {
		if err := s.sendOriginalAttorney(ctx, appData, donor, attorney); err != nil {
			return err
		}
	}

	for _, attorney := range donor.ReplacementAttorneys.Attorneys {
		if err := s.sendReplacementAttorney(ctx, appData, donor, attorney); err != nil {
			return err
		}
	}

	return nil
}

func (s *ShareCodeSender) sendOriginalAttorney(ctx context.Context, appData AppData, donor *lpastore.Lpa, attorney actor.Attorney) error {
	shareCode, err := s.createShareCode(ctx, appData, attorney.UID, actor.TypeAttorney)
	if err != nil {
		return err
	}

	if attorney.Email == "" {
		return s.sendPaperForm(ctx, donor.LpaUID, actor.TypeAttorney, attorney.UID, shareCode)
	}

	return s.sendEmail(ctx, attorney.Email, donor.LpaUID,
		notify.InitialOriginalAttorneyEmail{
			AttorneyFullName:          attorney.FullName(),
			DonorFirstNames:           donor.Donor.FirstNames,
			DonorFirstNamesPossessive: appData.Localizer.Possessive(donor.Donor.FirstNames),
			DonorFullName:             donor.Donor.FullName(),
			LpaType:                   localize.LowerFirst(appData.Localizer.T(donor.Type.String())),
			AttorneyStartPageURL:      fmt.Sprintf("%s%s", s.appPublicURL, Paths.Attorney.Start),
			ShareCode:                 shareCode,
		})
}

func (s *ShareCodeSender) sendReplacementAttorney(ctx context.Context, appData AppData, donor *lpastore.Lpa, attorney actor.Attorney) error {
	shareCode, err := s.createShareCode(ctx, appData, attorney.UID, actor.TypeReplacementAttorney)
	if err != nil {
		return err
	}

	if attorney.Email == "" {
		return s.sendPaperForm(ctx, donor.LpaUID, actor.TypeReplacementAttorney, attorney.UID, shareCode)
	}

	return s.sendEmail(ctx, attorney.Email, donor.LpaUID,
		notify.InitialReplacementAttorneyEmail{
			AttorneyFullName:          attorney.FullName(),
			DonorFirstNames:           donor.Donor.FirstNames,
			DonorFirstNamesPossessive: appData.Localizer.Possessive(donor.Donor.FirstNames),
			DonorFullName:             donor.Donor.FullName(),
			LpaType:                   localize.LowerFirst(appData.Localizer.T(donor.Type.String())),
			AttorneyStartPageURL:      fmt.Sprintf("%s%s", s.appPublicURL, Paths.Attorney.Start),
			ShareCode:                 shareCode,
		})
}

func (s *ShareCodeSender) sendTrustCorporation(ctx context.Context, appData AppData, donor *lpastore.Lpa, trustCorporation actor.TrustCorporation) error {
	if trustCorporation.Name == "" {
		return nil
	}

	shareCode, err := s.createShareCode(ctx, appData, trustCorporation.UID, actor.TypeTrustCorporation)
	if err != nil {
		return err
	}

	if trustCorporation.Email == "" {
		return s.sendPaperForm(ctx, donor.LpaUID, actor.TypeTrustCorporation, trustCorporation.UID, shareCode)
	}

	return s.sendEmail(ctx, trustCorporation.Email, donor.LpaUID,
		notify.InitialOriginalAttorneyEmail{
			AttorneyFullName:          trustCorporation.Name,
			DonorFirstNames:           donor.Donor.FirstNames,
			DonorFirstNamesPossessive: appData.Localizer.Possessive(donor.Donor.FirstNames),
			DonorFullName:             donor.Donor.FullName(),
			LpaType:                   localize.LowerFirst(appData.Localizer.T(donor.Type.String())),
			AttorneyStartPageURL:      fmt.Sprintf("%s%s", s.appPublicURL, Paths.Attorney.Start),
			ShareCode:                 shareCode,
		})
}

func (s *ShareCodeSender) sendReplacementTrustCorporation(ctx context.Context, appData AppData, donor *lpastore.Lpa, trustCorporation actor.TrustCorporation) error {
	if trustCorporation.Name == "" {
		return nil
	}

	shareCode, err := s.createShareCode(ctx, appData, trustCorporation.UID, actor.TypeReplacementTrustCorporation)
	if err != nil {
		return err
	}

	if trustCorporation.Email == "" {
		return s.sendPaperForm(ctx, donor.LpaUID, actor.TypeReplacementTrustCorporation, trustCorporation.UID, shareCode)
	}

	return s.sendEmail(ctx, trustCorporation.Email, donor.LpaUID,
		notify.InitialReplacementAttorneyEmail{
			AttorneyFullName:          trustCorporation.Name,
			DonorFirstNames:           donor.Donor.FirstNames,
			DonorFirstNamesPossessive: appData.Localizer.Possessive(donor.Donor.FirstNames),
			DonorFullName:             donor.Donor.FullName(),
			LpaType:                   localize.LowerFirst(appData.Localizer.T(donor.Type.String())),
			AttorneyStartPageURL:      fmt.Sprintf("%s%s", s.appPublicURL, Paths.Attorney.Start),
			ShareCode:                 shareCode,
		})
}

func (s *ShareCodeSender) createShareCode(ctx context.Context, appData AppData, actorUID actoruid.UID, actorType actor.Type) (string, error) {
	shareCode := s.randomString(12)
	if s.testCode != "" {
		shareCode = s.testCode
		s.testCode = ""
	}

	shareCodeData := actor.ShareCodeData{
		SessionID:             appData.SessionID,
		LpaID:                 appData.LpaID,
		ActorUID:              actorUID,
		IsReplacementAttorney: actorType == actor.TypeReplacementAttorney || actorType == actor.TypeReplacementTrustCorporation,
		IsTrustCorporation:    actorType == actor.TypeTrustCorporation || actorType == actor.TypeReplacementTrustCorporation,
	}

	if err := s.shareCodeStore.Put(ctx, actorType, shareCode, shareCodeData); err != nil {
		return "", fmt.Errorf("creating share failed: %w", err)
	}

	return shareCode, nil
}

func (s *ShareCodeSender) sendEmail(ctx context.Context, to string, lpaUID string, email notify.Email) error {
	if err := s.notifyClient.SendActorEmail(ctx, to, lpaUID, email); err != nil {
		return fmt.Errorf("email failed: %w", err)
	}

	return nil
}

func (s *ShareCodeSender) sendPaperForm(ctx context.Context, lpaUID string, actorType actor.Type, actorUID actoruid.UID, shareCode string) error {
	return s.eventClient.SendPaperFormRequested(ctx, event.PaperFormRequested{
		UID:        lpaUID,
		ActorType:  actorType.String(),
		ActorUID:   actorUID,
		AccessCode: shareCode,
	})
}