client.go

/****************************************************************************
 * Copyright 2025, Optimizely, Inc. and contributors                        *
 *                                                                          *
 * Licensed under the Apache License, Version 2.0 (the "License");          *
 * you may not use this file except in compliance with the License.         *
 * You may obtain a copy of the License at                                  *
 *                                                                          *
 *    http://www.apache.org/licenses/LICENSE-2.0                            *
 *                                                                          *
 * Unless required by applicable law or agreed to in writing, software      *
 * distributed under the License is distributed on an "AS IS" BASIS,        *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 * See the License for the specific language governing permissions and      *
 * limitations under the License.                                           *
 ***************************************************************************/

// Package cmab provides CMAB client implementation
package cmab

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"math"
	"net/http"
	"time"

	"github.com/optimizely/go-sdk/v2/pkg/config"
	"github.com/optimizely/go-sdk/v2/pkg/entities"
	"github.com/optimizely/go-sdk/v2/pkg/event"
	"github.com/optimizely/go-sdk/v2/pkg/logging"
)

// CMABPredictionEndpoint is the endpoint for CMAB predictions
var CMABPredictionEndpoint = "https://prediction.cmab.optimizely.com/predict/%s"

const (
	// DefaultMaxRetries is the default number of retries for CMAB requests
	DefaultMaxRetries = 3
	// DefaultInitialBackoff is the default initial backoff duration
	DefaultInitialBackoff = 100 * time.Millisecond
	// DefaultMaxBackoff is the default maximum backoff duration
	DefaultMaxBackoff = 10 * time.Second
	// DefaultBackoffMultiplier is the default multiplier for exponential backoff
	DefaultBackoffMultiplier = 2.0
)

// Attribute represents an attribute in a CMAB request
type Attribute struct {
	ID    string      `json:"id"`
	Value interface{} `json:"value"`
	Type  string      `json:"type"`
}

// Instance represents an instance in a CMAB request
type Instance struct {
	VisitorID    string      `json:"visitorId"`
	ExperimentID string      `json:"experimentId"`
	Attributes   []Attribute `json:"attributes"`
	CmabUUID     string      `json:"cmabUUID"`
}

// Request represents a request to the CMAB API
type Request struct {
	Instances []Instance `json:"instances"`
}

// Prediction represents a prediction in a CMAB response
type Prediction struct {
	VariationID string `json:"variation_id"`
}

// Response represents a response from the CMAB API
type Response struct {
	Predictions []Prediction `json:"predictions"`
}

// RetryConfig defines configuration for retry behavior
type RetryConfig struct {
	// MaxRetries is the maximum number of retry attempts
	MaxRetries int
	// InitialBackoff is the initial backoff duration
	InitialBackoff time.Duration
	// MaxBackoff is the maximum backoff duration
	MaxBackoff time.Duration
	// BackoffMultiplier is the multiplier for exponential backoff
	BackoffMultiplier float64
}

// DefaultCmabClient implements the CmabClient interface
type DefaultCmabClient struct {
	httpClient     *http.Client
	retryConfig    *RetryConfig
	logger         logging.OptimizelyLogProducer
	eventProcessor event.Processor
	projectConfig  config.ProjectConfig
}

// ClientOptions defines options for creating a CMAB client
type ClientOptions struct {
	HTTPClient     *http.Client
	RetryConfig    *RetryConfig
	Logger         logging.OptimizelyLogProducer
	EventProcessor event.Processor
	ProjectConfig  config.ProjectConfig
}

// NewDefaultCmabClient creates a new instance of DefaultCmabClient
func NewDefaultCmabClient(options ClientOptions) *DefaultCmabClient {
	httpClient := options.HTTPClient
	if httpClient == nil {
		httpClient = &http.Client{
			Timeout: 10 * time.Second,
		}
	}

	// retry is optional:
	// retryConfig can be nil - in that case, no retries will be performed
	retryConfig := options.RetryConfig

	logger := options.Logger
	if logger == nil {
		logger = logging.GetLogger("", "DefaultCmabClient")
	}

	return &DefaultCmabClient{
		httpClient:     httpClient,
		retryConfig:    retryConfig,
		logger:         logger,
		eventProcessor: options.EventProcessor,
		projectConfig:  options.ProjectConfig,
	}
}

// FetchDecision fetches a decision from the CMAB API
func (c *DefaultCmabClient) FetchDecision(
	ctx context.Context,
	ruleID string,
	userID string,
	attributes map[string]interface{},
	cmabUUID string,
) (string, error) {
	// If no context is provided, create a background context
	if ctx == nil {
		ctx = context.Background()
	}

	// Create the URL
	url := fmt.Sprintf(CMABPredictionEndpoint, ruleID)

	// Convert attributes to CMAB format
	cmabAttributes := make([]Attribute, 0, len(attributes))
	for key, value := range attributes {
		cmabAttributes = append(cmabAttributes, Attribute{
			ID:    key,
			Value: value,
			Type:  "custom_attribute",
		})
	}

	// Create the request body
	requestBody := Request{
		Instances: []Instance{
			{
				VisitorID:    userID,
				ExperimentID: ruleID,
				Attributes:   cmabAttributes,
				CmabUUID:     cmabUUID,
			},
		},
	}

	// Serialize the request body
	bodyBytes, err := json.Marshal(requestBody)
	if err != nil {
		return "", fmt.Errorf("failed to marshal CMAB request: %w", err)
	}

	// If no retry config, just do a single fetch
	if c.retryConfig == nil {
		return c.doFetch(ctx, url, bodyBytes)
	}

	// Retry sending request with exponential backoff
	for i := 0; i <= c.retryConfig.MaxRetries; i++ {
		// Check if context is done
		if ctx.Err() != nil {
			return "", fmt.Errorf("context canceled or timed out: %w", ctx.Err())
		}

		// Make the request
		result, err := c.doFetch(ctx, url, bodyBytes)
		if err == nil {
			return result, nil
		}

		// If this is the last retry, return the error
		if i == c.retryConfig.MaxRetries {
			return "", fmt.Errorf("failed to fetch CMAB decision after %d attempts: %w",
				c.retryConfig.MaxRetries, err)
		}

		// Calculate backoff duration
		backoffDuration := c.retryConfig.InitialBackoff * time.Duration(math.Pow(c.retryConfig.BackoffMultiplier, float64(i)))
		if backoffDuration > c.retryConfig.MaxBackoff {
			backoffDuration = c.retryConfig.MaxBackoff
		}

		c.logger.Debug(fmt.Sprintf("CMAB request retry %d/%d, backing off for %v",
			i+1, c.retryConfig.MaxRetries, backoffDuration))

		// Wait for backoff duration with context awareness
		select {
		case <-ctx.Done():
			return "", fmt.Errorf("context canceled or timed out during backoff: %w", ctx.Err())
		case <-time.After(backoffDuration):
			// Continue with retry
		}

		c.logger.Warning(fmt.Sprintf("CMAB API request failed (attempt %d/%d): %v",
			i+1, c.retryConfig.MaxRetries, err))
	}

	// This should never be reached due to the return in the loop above
	return "", fmt.Errorf("unexpected error in retry loop")
}

// doFetch performs a single fetch operation to the CMAB API
func (c *DefaultCmabClient) doFetch(ctx context.Context, url string, bodyBytes []byte) (string, error) {
	// Create the request
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(bodyBytes))
	if err != nil {
		return "", fmt.Errorf("failed to create CMAB request: %w", err)
	}

	// Set headers
	req.Header.Set("Content-Type", "application/json")

	// Execute the request
	resp, err := c.httpClient.Do(req)
	if err != nil {
		return "", fmt.Errorf("CMAB request failed: %w", err)
	}
	defer resp.Body.Close()

	// Check status code
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return "", fmt.Errorf("CMAB API returned non-success status code: %d", resp.StatusCode)
	}

	// Read response body
	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("failed to read CMAB response body: %w", err)
	}

	// Parse response
	var cmabResponse Response
	if err := json.Unmarshal(respBody, &cmabResponse); err != nil {
		return "", fmt.Errorf("failed to unmarshal CMAB response: %w", err)
	}

	// Validate response
	if !c.validateResponse(cmabResponse) {
		return "", fmt.Errorf("invalid CMAB response: missing predictions or variation_id")
	}

	// Return the variation ID
	return cmabResponse.Predictions[0].VariationID, nil
}

// validateResponse validates the CMAB response
func (c *DefaultCmabClient) validateResponse(response Response) bool {
	return len(response.Predictions) > 0 && response.Predictions[0].VariationID != ""
}

// EventProcessor is an interface for processing events
type EventProcessor interface {
	Process(userEvent interface{}) bool
}

// LogImpression logs a CMAB impression event
func (c *DefaultCmabClient) LogImpression(
	ctx context.Context,
	eventProcessor EventProcessor,
	projectConfig config.ProjectConfig,
	ruleID string,
	userID string,
	variationKey string,
	variationID string,
	attributes map[string]interface{},
	cmabUUID string,
) error {
	// Instead of directly creating an event, we'll delegate this to the client
	// that has access to the event package
	return fmt.Errorf("CMAB impression logging not implemented")
}

// TrackCMABDecision tracks a CMAB decision event
func (c *DefaultCmabClient) TrackCMABDecision(
	ruleID string,
	userID string,
	variationID string,
	variationKey string,
	attributes map[string]interface{},
	cmabUUID string,
) {
	if c.eventProcessor == nil || c.projectConfig == nil {
		c.logger.Debug("Event processor or project config not available, not tracking impression")
		return
	}

	// Get experiment from project config
	experiment, err := c.projectConfig.GetExperimentByID(ruleID)
	if err != nil {
		c.logger.Error("Error getting experiment", err)
		return
	}

	// Create variation object
	variation := entities.Variation{
		ID:  variationID,
		Key: variationKey,
	}

	// Create user context
	userContext := entities.UserContext{
		ID:         userID,
		Attributes: attributes,
	}

	// Look for associated feature flag (if any)
	flagKey := ""
	featureList := c.projectConfig.GetFeatureList()
	for _, feature := range featureList {
		for _, featureExperiment := range feature.FeatureExperiments {
			if featureExperiment.ID == ruleID {
				flagKey = feature.Key
				break
			}
		}
		if flagKey != "" {
			break
		}
	}

	// Create user event with CMAB impression
	userEvent, shouldDispatch := event.CreateCMABImpressionUserEvent(
		c.projectConfig,
		experiment,
		&variation,
		userContext,
		flagKey,
		experiment.Key, // ruleKey
		"experiment",   // ruleType
		true,
		cmabUUID,
	)

	// Process the event if it should be dispatched
	if shouldDispatch {
		c.eventProcessor.ProcessEvent(userEvent)
	}
}