<?php

declare ( strict_types = 1 );

namespace App\AI ;

enum TaskType : string {
    case SIMPLE_SUMMARY = 'simple_summary' ;
    case HEADLINE_SUGGEST = 'headline_suggest' ;
    case SEO_META = 'seo_meta' ;
    case CONTENT_GENERATION = 'content_generation' ;
    case FACT_CHECKING = 'fact_checking' ;
    case TRANSLATION = 'translation' ;
}

class CascadeRouter {
    private const ROUTES = [
        TaskType::SIMPLE_SUMMARY->value => [
            'groq:llama-3.1-70b',
            'gemini:flash'
        ],
        TaskType::HEADLINE_SUGGEST->value => [
            'gemini:flash',
            'gpt:4o-mini'
        ],
        TaskType::SEO_META->value => [
            'groq:llama-3.1-70b'
        ],
        TaskType::CONTENT_GENERATION->value => [
            'claude:sonnet',
            'gpt:4o'
        ],
        TaskType::FACT_CHECKING->value => [
            'claude:sonnet'
        ], // 정확도가 중요함 (accuracy critical)
        TaskType::TRANSLATION->value => [
            'gemini:flash',
            'deepseek:chat'
        ],
    ];

    public function __construct (
        private readonly ProviderRegistry $registry ,
        private readonly QualityGate $qualityGate ,
    ) {}

    public function route (
        TaskType $task ,
        string $prompt
    ): AIResponse {
        $models = self::ROUTES[$task->value];
        $errors = [];

        foreach ($models as $modelId) {
            try {
                $provider = $this->registry->get($modelId);
                $response = $provider->complete($prompt);

                if ($this->qualityGate->meetsBar($response, $task)) {
                    return $response;
                }
            } catch (RateLimitException | ProviderDownException $e) {
                $errors[] = "$modelId : " . $e->getMessage();
                continue;
            }
        }

        throw new AllModelsFailedException(
            "All models failed for $task->value : " . implode('; ', $errors)
        );
    }
}

<?php

namespace App\AI\Provider;

interface AIProviderInterface
{
    public function complete(string $prompt, array $options = []): AIResponse;
    public function getName(): string;
    public function getCostPerMillionTokens(): array;
    // ['input' => x, 'output' => y]
    public function getMaxContextLength(): int;
    public function supportsStreaming(): bool;
}

class OpenAIProvider implements AIProviderInterface
{
    public function __construct(
        private readonly string $apiKey,
        private readonly string $model = 'gpt-4o-mini',
        private readonly HttpClient $http,
    ) {}

    public function complete(string $prompt, array $options = []): AIResponse
    {
        $response = $this->http->post('https://api.openai.com/v1/chat/completions', [
            'headers' => [
                'Authorization' => "Bearer {$this->apiKey}",
            ],
            'json' => [
                'model' => $this->model,
                'messages' => [['role' => 'user', 'content' => $prompt]],
                'temperature' => $options['temperature'] ?? 0.7,
                'max_tokens' => $options['max_tokens'] ?? 1000,
            ],
        ]);

        $data = $response->json();

        return new AIResponse(
            content: $data['choices'][0]['message']['content'],
            tokensUsed: $data['usage']['total_tokens'],
            cost: $this->calculateCost($data['usage']),
            model: $this->model,
        );
    }
}

class AnthropicProvider implements AIProviderInterface
{
    public function __construct(
        private readonly string $apiKey,
        private readonly string $model = 'claude-sonnet-4-6',
        private readonly HttpClient $http,
    ) {}

    public function complete(string $prompt, array $options = []): AIResponse
    {
        $response = $this->http->post('https://api.anthropic.com/v1/messages', [
            'headers' => [
                'x-api-key' => $this->apiKey,
                'anthropic-version' => '2023-06-01',
            ],
            'json' => [
                'model' => $this->model,
                'max_tokens' => $options['max_tokens'] ??

class CachedProvider implements AIProviderInterface {
    public function __construct (
        private readonly AIProviderInterface $inner ,
        private readonly Redis $cache ,
        private readonly int $ttl = 86400 * 7, // 1주일
    ) {}

    public function complete ( string $prompt , array $options = []): AIResponse {
        $cacheKey = 'ai:' . md5 ( $prompt . serialize ( $options ) . $this->inner->getName ());
        if ( $cached = $this->cache->get ( $cacheKey )) {
            return AIResponse::fromCache ( unserialize ( $cached ));
        }
        $response = $this->inner->complete ( $prompt , $options );
        $this->cache->setex ( $cacheKey , $this->ttl , serialize ( $response->toArray ()));
        return $response ;
    }
}

<?php

namespace App\News\Agency;

interface AgencyAdapterInterface
{
    public function fetchArticles(int $limit = 50): iterable;
    public function mapCategory(string $agencyCategory): ?int;
    public function downloadAssets(Article $article): void;
}

class AgencyFactory
{
    public static function create(string $code, PDO $pdo, array $config): AgencyAdapterInterface
    {
        return match ($code) {
            'AA' => new AAAdapter($pdo, $config),
            'DHA' => new DHAAdapter($pdo, $config),
            'IHA' => new IHAAdapter($pdo, $config),
            'ANKA' => new ANKAAdapter($pdo, $config),
            'THA' => new THAAdapter($pdo, $config),
            'HIBYA' => new HIBYAAdapter($pdo, $config),
            'IGFA' => new IGFAAdapter($pdo, $config),
            'BHA' => new BHAAdapter($pdo, $config),
            default => throw new \InvalidArgumentException("Unknown agency: $code"),
        };
    }
}