wpmind/includes/Routing/Strategies/CompositeStrategy.php

<?php
/**
 * Composite Strategy - 复合路由策略
 *
 * 组合多个策略，按权重计算综合得分
 *
 * @package WPMind
 * @since 1.9.0
 */

declare(strict_types=1);

namespace WPMind\Routing\Strategies;

use WPMind\Routing\AbstractStrategy;
use WPMind\Routing\RoutingContext;
use WPMind\Routing\RoutingStrategyInterface;

class CompositeStrategy extends AbstractStrategy
{
    /** @var array<array{strategy: RoutingStrategyInterface, weight: float}> */
    private array $strategies = [];

    /** @var string 策略名称 */
    private string $name;

    /** @var string 显示名称 */
    private string $displayName;

    /** @var string 描述 */
    private string $description;

    /**
     * @param string $name 策略名称
     * @param string $displayName 显示名称
     * @param string $description 描述
     */
    public function __construct(
        string $name = 'composite',
        string $displayName = '综合策略',
        string $description = '综合多个因素进行路由决策'
    ) {
        $this->name = $name;
        $this->displayName = $displayName;
        $this->description = $description;
    }

    /**
     * 添加子策略
     *
     * @param RoutingStrategyInterface $strategy 策略实例
     * @param float $weight 权重 (0-1)
     * @return self
     */
    public function add_strategy(RoutingStrategyInterface $strategy, float $weight): self
    {
        $this->strategies[] = [
            'strategy' => $strategy,
            'weight' => max(0, min(1, $weight)),
        ];
        return $this;
    }

    public function get_name(): string
    {
        return $this->name;
    }

    public function get_display_name(): string
    {
        return $this->displayName;
    }

    public function get_description(): string
    {
        return $this->description;
    }

    /**
     * 计算 Provider 的综合得分
     *
     * 按权重汇总各子策略的得分
     */
    public function calculate_score(string $providerId, RoutingContext $context): float
    {
        if (empty($this->strategies)) {
            return 50.0;
        }

        $totalWeight = array_sum(array_column($this->strategies, 'weight'));
        if ($totalWeight <= 0) {
            return 50.0;
        }

        $weightedScore = 0;
        foreach ($this->strategies as $item) {
            $score = $item['strategy']->calculate_score($providerId, $context);
            $normalizedWeight = $item['weight'] / $totalWeight;
            $weightedScore += $score * $normalizedWeight;
        }

        return $weightedScore;
    }

    /**
     * 获取子策略列表
     *
     * @return array<array{name: string, weight: float}>
     */
    public function get_strategies(): array
    {
        return array_map(fn($item) => [
            'name' => $item['strategy']->get_name(),
            'display_name' => $item['strategy']->get_display_name(),
            'weight' => $item['weight'],
        ], $this->strategies);
    }

    /**
     * 创建预设的平衡策略
     *
     * 成本、延迟、可用性各占 1/3
     */
    public static function create_balanced(): self
    {
        return (new self('balanced', '平衡策略', '平衡考虑成本、延迟和可用性'))
            ->add_strategy(new CostStrategy(), 0.33)
            ->add_strategy(new LatencyStrategy(), 0.33)
            ->add_strategy(new AvailabilityStrategy(), 0.34);
    }

    /**
     * 创建预设的性能优先策略
     *
     * 延迟 50%，可用性 30%，成本 20%
     */
    public static function create_performance(): self
    {
        return (new self('performance', '性能优先', '优先考虑响应速度和稳定性'))
            ->add_strategy(new LatencyStrategy(), 0.50)
            ->add_strategy(new AvailabilityStrategy(), 0.30)
            ->add_strategy(new CostStrategy(), 0.20);
    }

    /**
     * 创建预设的经济策略
     *
     * 成本 60%，可用性 30%，延迟 10%
     */
    public static function create_economic(): self
    {
        return (new self('economic', '经济策略', '优先考虑成本，兼顾稳定性'))
            ->add_strategy(new CostStrategy(), 0.60)
            ->add_strategy(new AvailabilityStrategy(), 0.30)
            ->add_strategy(new LatencyStrategy(), 0.10);
    }
}