package adrianmikula.jakartamigration.config;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* Service for charging Apify billing events.
*
* When the MCP server is deployed as an Apify Actor, this service
* triggers billable events for premium features.
*
* Apify uses Pay-Per-Event (PPE) model where specific events trigger charges.
* Events are configured in the Apify dashboard and charged to the user.
*
* Usage:
* <pre>
* apifyBillingService.chargeEvent("migration-plan-created");
* </pre>
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class ApifyBillingService {
private final ApifyLicenseProperties apifyProperties;
/**
* Maximum total charge allowed (from Apify environment variable).
* If null, no limit is enforced.
*/
@Value("${ACTOR_MAX_TOTAL_CHARGE_USD:}")
private String maxTotalChargeUsd;
/**
* Track total charges for this execution.
*/
private double totalCharges = 0.0;
/**
* Track event counts for logging.
*/
private final Map<String, Integer> eventCounts = new ConcurrentHashMap<>();
/**
* Check if Apify billing is enabled.
* Billing is only enabled when:
* 1. Apify validation is enabled
* 2. Running in Apify environment (ACTOR_ID is set)
*/
public boolean isBillingEnabled() {
if (!apifyProperties.getEnabled()) {
return false;
}
// Check if running in Apify environment
String actorId = System.getenv("ACTOR_ID");
if (actorId == null || actorId.isBlank()) {
return false;
}
return true;
}
/**
* Charge for a billable event.
*
* This method calls Apify's Actor.charge() API to trigger a billing event.
* The event must be configured in the Apify dashboard with a price.
*
* @param eventName The name of the event to charge (must match Apify dashboard configuration)
* @return true if charge was successful, false otherwise
*/
public boolean chargeEvent(String eventName) {
if (!isBillingEnabled()) {
log.debug("Apify billing disabled, skipping charge for event: {}", eventName);
return false;
}
try {
// Check spending limit
if (maxTotalChargeUsd != null && !maxTotalChargeUsd.isBlank()) {
double maxCharge = Double.parseDouble(maxTotalChargeUsd);
if (totalCharges >= maxCharge) {
log.warn("Maximum charge limit reached (${}), skipping event: {}", maxCharge, eventName);
return false;
}
}
// Call Apify Actor.charge() API
// Note: In Java, we need to use Apify SDK or HTTP client
// For now, we'll use a simple HTTP call to Apify's internal API
chargeEventViaApi(eventName);
// Track charges
totalCharges += getEventPrice(eventName); // Will be 0 if not configured
eventCounts.merge(eventName, 1, Integer::sum);
log.info("Charged for event: {} (total charges: ${})", eventName, totalCharges);
return true;
} catch (Exception e) {
log.error("Failed to charge for event: {}", eventName, e);
// Don't fail the operation if billing fails
return false;
}
}
/**
* Charge for an event via Apify API.
*
* In Apify environment, we use Apify's internal API to charge for events.
* The Apify platform automatically tracks these events for billing.
*
* @param eventName Event name
*/
private void chargeEventViaApi(String eventName) {
// In Apify environment, events are tracked via:
// 1. Apify Java SDK (if available): Actor.charge(eventName)
// 2. HTTP API: POST to Apify's internal billing endpoint
// 3. Environment variable: ACTOR_CHARGE_EVENT_NAME (set by Apify)
// Get Apify environment variables
String actorId = System.getenv("ACTOR_ID");
String runId = System.getenv("ACTOR_RUN_ID");
if (actorId == null || runId == null) {
log.warn("Apify environment variables not set, cannot charge event: {}", eventName);
return;
}
// Log the charge event (Apify platform will track this)
// In production, you can use Apify Java SDK or HTTP client
log.info("Charging Apify event: {} (Actor: {}, Run: {})", eventName, actorId, runId);
// Option 1: Use Apify Java SDK (when available)
// Actor.charge(eventName);
// Option 2: Use HTTP client to call Apify's internal API
// This would require WebClient configured for Apify API
// For now, Apify platform tracks events via logs and environment
// Note: Apify platform automatically tracks events when:
// - Event name is logged in specific format
// - Actor.charge() is called (via SDK)
// - HTTP API is called to billing endpoint
// The event will be charged according to dashboard configuration
}
/**
* Get the configured price for an event.
* This would typically come from Apify dashboard configuration.
*
* @param eventName Event name
* @return Event price in USD (0 if not configured)
*/
private double getEventPrice(String eventName) {
// In production, this could be fetched from Apify API or configuration
// For now, return 0 (prices are configured in Apify dashboard)
return 0.0;
}
/**
* Get total charges for this execution.
*/
public double getTotalCharges() {
return totalCharges;
}
/**
* Get event counts for this execution.
*/
public Map<String, Integer> getEventCounts() {
return Map.copyOf(eventCounts);
}
/**
* Reset charge tracking (useful for testing).
*/
public void reset() {
totalCharges = 0.0;
eventCounts.clear();
log.debug("Billing service reset");
}
}
