SMS

package domain

import (
	"context"
	"errors"
	"regexp"
)

var ErrInvalidPhoneNumber = errors.New("phone number is not a valid E.164 number")

var e164Pattern = regexp.MustCompile(`^\+[1-9]\d{7,14}$`)

func NormalizePhone(raw string) (string, error) {
	if !e164Pattern.MatchString(raw) {
		return "", ErrInvalidPhoneNumber
	}
	return raw, nil
}

type SMSMessage struct {
	TenantID string
	To       string // always E.164 by the time it reaches this struct
	Body     string
}

type SMSSender interface {
	Send(ctx context.Context, msg SMSMessage) (ProviderMessageID, error)
}

CREATE TABLE notification_preferences (
    organization_id uuid NOT NULL,
    resident_id uuid NOT NULL,
    channel text NOT NULL,       -- 'email' | 'sms' | 'push'
    category text NOT NULL,      -- 'payment_reminders' | 'maintenance_updates' | ...
    opted_in boolean NOT NULL DEFAULT true,
    updated_at timestamptz NOT NULL DEFAULT now(),
    PRIMARY KEY (organization_id, resident_id, channel, category)
);

package application

import (
	"context"
	"errors"

	"github.com/hoa-platform/backend/services/notification-service/internal/domain"
)

var ErrRecipientOptedOut = errors.New("recipient has opted out of this category on this channel")

type PreferenceChecker interface {
	IsOptedIn(ctx context.Context, tenantID, residentID, channel, category string) (bool, error)
}

type SendSMS struct {
	sender      domain.SMSSender
	preferences PreferenceChecker
}

func NewSendSMS(sender domain.SMSSender, preferences PreferenceChecker) *SendSMS {
	return &SendSMS{sender: sender, preferences: preferences}
}

func (s *SendSMS) Execute(ctx context.Context, tenantID, residentID, category, phone, body string) error {
	optedIn, err := s.preferences.IsOptedIn(ctx, tenantID, residentID, "sms", category)
	if err != nil {
		return err
	}
	if !optedIn {
		return ErrRecipientOptedOut
	}

	normalized, err := domain.NormalizePhone(phone)
	if err != nil {
		return err
	}

	_, err = s.sender.Send(ctx, domain.SMSMessage{TenantID: tenantID, To: normalized, Body: body})
	return err
}

package application

import (
	"sync"
	"time"
)

// PerProcessBudget is a deliberately simple guardrail: it caps SMS volume
// per organization within THIS process only. Two replicas of
// notification-service each enforce their own limit, so the effective
// organization-wide budget is (limit × replica count), not limit alone.
// This gap is closed once Redis Integration proves the shared-counter
// need in the TTL lesson — introducing Redis here, before that need is
// demonstrated, would be solving a problem this service does not yet
// have evidence for.
type PerProcessBudget struct {
	mu       sync.Mutex
	limit    int
	window   time.Duration
	counts   map[string]int
	resetAt  map[string]time.Time
}

func NewPerProcessBudget(limit int, window time.Duration) *PerProcessBudget {
	return &PerProcessBudget{limit: limit, window: window, counts: map[string]int{}, resetAt: map[string]time.Time{}}
}

func (b *PerProcessBudget) Allow(organizationID string) bool {
	b.mu.Lock()
	defer b.mu.Unlock()

	now := time.Now()
	if now.After(b.resetAt[organizationID]) {
		b.counts[organizationID] = 0
		b.resetAt[organizationID] = now.Add(b.window)
	}
	if b.counts[organizationID] >= b.limit {
		return false
	}
	b.counts[organizationID]++
	return true
}