honeyDueAPI/internal/push/client.go

package push

import (
	"context"
	"time"

	"github.com/rs/zerolog/log"

	"github.com/treytartt/honeydue-api/internal/config"
)

// Platform constants
const (
	PlatformIOS     = "ios"
	PlatformAndroid = "android"
)

// Timeout for individual push notification send operations.
const pushSendTimeout = 15 * time.Second

// Client provides a unified interface for sending push notifications
type Client struct {
	apns       *APNsClient
	fcm        *FCMClient
	enabled    bool
	apnsBreaker *CircuitBreaker
	fcmBreaker  *CircuitBreaker
}

// NewClient creates a new unified push notification client
func NewClient(cfg *config.PushConfig, enabled bool) (*Client, error) {
	client := &Client{
		enabled:     enabled,
		apnsBreaker: NewCircuitBreaker("apns"),
		fcmBreaker:  NewCircuitBreaker("fcm"),
	}

	// Initialize APNs client (iOS)
	if cfg.APNSKeyPath != "" && cfg.APNSKeyID != "" && cfg.APNSTeamID != "" {
		apnsClient, err := NewAPNsClient(cfg)
		if err != nil {
			log.Warn().Err(err).Msg("Failed to initialize APNs client - iOS push disabled")
		} else {
			client.apns = apnsClient
			log.Info().Msg("APNs client initialized successfully")
		}
	} else {
		log.Warn().Msg("APNs not configured - iOS push disabled")
	}

	// Initialize FCM client (Android) - requires project ID + service account credentials
	if cfg.FCMProjectID != "" && (cfg.FCMServiceAccountPath != "" || cfg.FCMServiceAccountJSON != "") {
		fcmClient, err := NewFCMClient(cfg)
		if err != nil {
			log.Warn().Err(err).Msg("Failed to initialize FCM v1 client - Android push disabled")
		} else {
			client.fcm = fcmClient
			log.Info().Msg("FCM v1 client initialized successfully")
		}
	} else {
		log.Warn().Msg("FCM not configured (need FCM_PROJECT_ID + FCM_SERVICE_ACCOUNT_PATH or FCM_SERVICE_ACCOUNT_JSON) - Android push disabled")
	}

	return client, nil
}

// SendToIOS sends a push notification to iOS devices.
// The call is guarded by a circuit breaker and uses a context timeout.
func (c *Client) SendToIOS(ctx context.Context, tokens []string, title, message string, data map[string]string) error {
	if !c.enabled {
		log.Debug().Msg("Push notifications disabled by feature flag")
		return nil
	}
	if c.apns == nil {
		log.Warn().Msg("APNs client not initialized, skipping iOS push")
		return nil
	}
	if !c.apnsBreaker.Allow() {
		log.Warn().Str("breaker", c.apnsBreaker.Name()).Msg("APNs circuit breaker is open, skipping iOS push")
		return ErrCircuitOpen
	}

	sendCtx, cancel := context.WithTimeout(ctx, pushSendTimeout)
	defer cancel()

	err := c.apns.Send(sendCtx, tokens, title, message, data)
	if err != nil {
		c.apnsBreaker.RecordFailure()
		log.Warn().Err(err).Str("breaker_state", c.apnsBreaker.State()).Msg("APNs send failed, recorded circuit breaker failure")
		return err
	}
	c.apnsBreaker.RecordSuccess()
	return nil
}

// SendToAndroid sends a push notification to Android devices.
// The call is guarded by a circuit breaker and uses a context timeout.
func (c *Client) SendToAndroid(ctx context.Context, tokens []string, title, message string, data map[string]string) error {
	if !c.enabled {
		log.Debug().Msg("Push notifications disabled by feature flag")
		return nil
	}
	if c.fcm == nil {
		log.Warn().Msg("FCM client not initialized, skipping Android push")
		return nil
	}
	if !c.fcmBreaker.Allow() {
		log.Warn().Str("breaker", c.fcmBreaker.Name()).Msg("FCM circuit breaker is open, skipping Android push")
		return ErrCircuitOpen
	}

	sendCtx, cancel := context.WithTimeout(ctx, pushSendTimeout)
	defer cancel()

	err := c.fcm.Send(sendCtx, tokens, title, message, data)
	if err != nil {
		c.fcmBreaker.RecordFailure()
		log.Warn().Err(err).Str("breaker_state", c.fcmBreaker.State()).Msg("FCM send failed, recorded circuit breaker failure")
		return err
	}
	c.fcmBreaker.RecordSuccess()
	return nil
}

// SendToAll sends a push notification to both iOS and Android devices
func (c *Client) SendToAll(ctx context.Context, iosTokens, androidTokens []string, title, message string, data map[string]string) error {
	if !c.enabled {
		log.Debug().Msg("Push notifications disabled by feature flag")
		return nil
	}
	var lastErr error

	if len(iosTokens) > 0 {
		if err := c.SendToIOS(ctx, iosTokens, title, message, data); err != nil {
			log.Error().Err(err).Msg("Failed to send iOS notifications")
			lastErr = err
		}
	}

	if len(androidTokens) > 0 {
		if err := c.SendToAndroid(ctx, androidTokens, title, message, data); err != nil {
			log.Error().Err(err).Msg("Failed to send Android notifications")
			lastErr = err
		}
	}

	return lastErr
}

// IsIOSEnabled returns true if iOS push is configured
func (c *Client) IsIOSEnabled() bool {
	return c.apns != nil
}

// IsAndroidEnabled returns true if Android push is configured
func (c *Client) IsAndroidEnabled() bool {
	return c.fcm != nil
}

// SendActionableNotification sends notifications with action button support.
// iOS receives a category for actionable notifications, Android handles actions via data payload.
// Both platforms are guarded by their respective circuit breakers.
func (c *Client) SendActionableNotification(ctx context.Context, iosTokens, androidTokens []string, title, message string, data map[string]string, iosCategoryID string) error {
	if !c.enabled {
		log.Debug().Msg("Push notifications disabled by feature flag")
		return nil
	}
	var lastErr error

	if len(iosTokens) > 0 {
		if c.apns == nil {
			log.Warn().Msg("APNs client not initialized, skipping iOS actionable push")
		} else if !c.apnsBreaker.Allow() {
			log.Warn().Str("breaker", c.apnsBreaker.Name()).Msg("APNs circuit breaker is open, skipping iOS actionable push")
			lastErr = ErrCircuitOpen
		} else {
			sendCtx, cancel := context.WithTimeout(ctx, pushSendTimeout)
			err := c.apns.SendWithCategory(sendCtx, iosTokens, title, message, data, iosCategoryID)
			cancel()
			if err != nil {
				c.apnsBreaker.RecordFailure()
				log.Error().Err(err).Msg("Failed to send iOS actionable notifications")
				lastErr = err
			} else {
				c.apnsBreaker.RecordSuccess()
			}
		}
	}

	if len(androidTokens) > 0 {
		// Android handles actions via data payload - existing send works
		if err := c.SendToAndroid(ctx, androidTokens, title, message, data); err != nil {
			log.Error().Err(err).Msg("Failed to send Android notifications")
			lastErr = err
		}
	}

	return lastErr
}

// HealthCheck checks if the push services are available
func (c *Client) HealthCheck(ctx context.Context) error {
	// For direct clients, we can't easily health check without sending a notification
	// Return nil if at least one platform is configured
	if c.apns != nil || c.fcm != nil {
		return nil
	}
	return nil
}