Chamilo\CoreBundle\AiProvider\AiProviderFactory::__construct()

Complexity

Conditions	24
Paths	108

Size

Total Lines	128
Code Lines	69

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function __construct(
        private readonly HttpClientInterface $httpClient,
        private readonly SettingsManager $settingsManager,
        private readonly AiRequestsRepository $aiRequestsRepository,
        private readonly Security $security
    ) {
        $config = $this->readProvidersConfig();

        // Default provider = first key in config (if any)
        $this->defaultProvider = array_key_first($config) ?? 'openai';

        // Provider name -> class prefix
        $possibleProviders = [
            'openai' => 'OpenAi',
            'deepseek' => 'DeepSeek',
            'grok' => 'Grok',
            'mistral' => 'Mistral',
            'gemini' => 'Gemini',
        ];

        // Suffix used only if you create type-specific classes (optional)
        $typeSuffix = [
            'text' => '',
            'image' => 'Image',
            'video' => 'Video',
            'document' => 'Document',
            'document_process' => 'DocumentProcess',
        ];

        // Expected interface per known type
        $typeInterface = [
            'text' => AiProviderInterface::class,
            'image' => AiImageProviderInterface::class,
            'video' => AiVideoProviderInterface::class,
            'document' => AiDocumentProviderInterface::class,
            // 'document_process' intentionally not validated (no interface yet)
        ];

        $this->providers = [];
        $this->providersByType = [];

        foreach ($config as $providerName => $providerConfig) {
            if (!isset($possibleProviders[$providerName])) {
                error_log('[AI] Unsupported provider in config: "'.$providerName.'". Skipping.');
                continue;
            }

            if (!\is_array($providerConfig)) {
                error_log('[AI] Provider config for "'.$providerName.'" must be an array. Skipping.');
                continue;
            }

            $providerPrefix = $possibleProviders[$providerName];

            // Base provider class (e.g. OpenAiProvider)
            $baseClass = 'Chamilo\\CoreBundle\\AiProvider\\'.$providerPrefix.'Provider';
            $baseObject = $this->instantiateProvider($baseClass);

            // If base class cannot be instantiated, we can still allow type-specific classes.
            if (!$baseObject && !class_exists($baseClass)) {
                error_log('[AI] Base provider class not found: '.$baseClass.'.');
            } elseif (!$baseObject) {
                error_log('[AI] Base provider class exists but could not be instantiated: '.$baseClass.'.');
            }

            foreach ($typeSuffix as $type => $suffix) {
                // Only types explicitly present in provider config are considered enabled
                if (!array_key_exists($type, $providerConfig)) {
                    continue;
                }

                $typeClass = 'Chamilo\\CoreBundle\\AiProvider\\'.$providerPrefix.$suffix.'Provider';

                // Known types: we can fallback to base provider if it implements the right interface
                if (isset($typeInterface[$type])) {
                    $iface = $typeInterface[$type];
                    $obj = null;

                    // 1) Prefer type-specific class if exists (optional architecture)
                    if ($typeClass !== $baseClass && class_exists($typeClass)) {
                        $obj = $this->instantiateProvider($typeClass);

                        if ($obj && !($obj instanceof $iface)) {
                            error_log('[AI] Provider "'.$providerName.'" type-class "'.$typeClass.'" does not implement '.$iface.'. Falling back to base provider.');
                            $obj = null;
                        }
                    }

                    // 2) Fallback to base provider
                    if (!$obj) {
                        if ($baseObject && ($baseObject instanceof $iface)) {
                            $obj = $baseObject;

                            if ($typeClass !== $baseClass && !class_exists($typeClass)) {
                                error_log('[AI] Provider "'.$providerName.'" uses base provider for type "'.$type.'" (no dedicated type class found).');
                            }
                        } else {
                            error_log('[AI] Provider "'.$providerName.'" is configured for type "'.$type.'" but no usable implementation was found (expected '.$iface.').');
                            continue;
                        }
                    }

                    $this->providers[$providerName][$type] = $obj;
                    $this->providersByType[$type][$providerName] = $obj;
                    continue;
                }

                // Unknown type (e.g. document_process): do NOT fallback to base provider.
                // Require a dedicated class to avoid claiming support when methods don't exist.
                if ($typeClass !== $baseClass && class_exists($typeClass)) {
                    $obj = $this->instantiateProvider($typeClass);

                    if (!$obj) {
                        error_log('[AI] Provider "'.$providerName.'" is configured for unknown type "'.$type.'" but could not instantiate "'.$typeClass.'".');
                        continue;
                    }

                    $this->providers[$providerName][$type] = $obj;
                    $this->providersByType[$type][$providerName] = $obj;
                } else {
                    error_log('[AI] Provider "'.$providerName.'" is configured for unknown type "'.$type.'" but no dedicated class was found (expected "'.$typeClass.'").');
                }
            }
        }

        // Ensure default provider exists when config is not empty
        if (!empty($config) && !isset($this->providers[$this->defaultProvider])) {
            throw new InvalidArgumentException("The default AI provider '{$this->defaultProvider}' is not configured properly.");
        }