honeyDueAPI/internal/push/client.go

package push

import (
	"context"

	"github.com/rs/zerolog/log"

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

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

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

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

	// 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)
	if cfg.FCMServerKey != "" {
		fcmClient, err := NewFCMClient(cfg)
		if err != nil {
			log.Warn().Err(err).Msg("Failed to initialize FCM client - Android push disabled")
		} else {
			client.fcm = fcmClient
			log.Info().Msg("FCM client initialized successfully")
		}
	} else {
		log.Warn().Msg("FCM not configured - Android push disabled")
	}

	return client, nil
}

// SendToIOS sends a push notification to iOS devices
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
	}
	return c.apns.Send(ctx, tokens, title, message, data)
}

// SendToAndroid sends a push notification to Android devices
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
	}
	return c.fcm.Send(ctx, tokens, title, message, data)
}

// 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
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 err := c.apns.SendWithCategory(ctx, iosTokens, title, message, data, iosCategoryID); err != nil {
				log.Error().Err(err).Msg("Failed to send iOS actionable notifications")
				lastErr = err
			}
		}
	}

	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
}