gitcaddy-ai/src/GitCaddy.AI.Service/Configuration/AIProviderFactory.cs

// Copyright 2026 MarketAlly. All rights reserved.
// SPDX-License-Identifier: BSL-1.1

using MarketAlly.AIPlugin;
using MarketAlly.AIPlugin.Conversation;
using Microsoft.Extensions.Options;

namespace GitCaddy.AI.Service.Configuration;

/// <summary>
/// Factory for creating AI provider conversations using MarketAlly.AIPlugin.
/// </summary>
public class AIProviderFactory : IAIProviderFactory
{
    private readonly ILogger<AIProviderFactory> _logger;
    private readonly AIServiceOptions _serviceOptions;
    private readonly ProviderOptions _providerOptions;

    public AIProviderFactory(
        ILogger<AIProviderFactory> logger,
        IOptions<AIServiceOptions> serviceOptions,
        IOptions<ProviderOptions> providerOptions)
    {
        _logger = logger;
        _serviceOptions = serviceOptions.Value;
        _providerOptions = providerOptions.Value;
    }

    public AIConversationBuilder CreateConversation()
    {
        return CreateConversation(_serviceOptions.DefaultProvider, _serviceOptions.DefaultModel);
    }

    public AIConversationBuilder CreateConversation(string provider)
    {
        var model = GetDefaultModelForProvider(provider);
        return CreateConversation(provider, model);
    }

    public AIConversationBuilder CreateConversation(string provider, string model)
    {
        var aiProvider = ParseProvider(provider);
        var config = GetProviderConfig(provider);

        if (string.IsNullOrEmpty(config.ApiKey))
        {
            throw new InvalidOperationException($"API key not configured for provider: {provider}");
        }

        _logger.LogDebug("Creating conversation with provider {Provider}, model {Model}", provider, model);

        var builder = AIConversationBuilder.Create()
            .UseProvider(aiProvider, config.ApiKey)
            .UseModel(model)
            .WithMaxTokens(_serviceOptions.MaxTokens)
            .WithTemperature(_serviceOptions.Temperature);

        return builder;
    }

    private static AIProvider ParseProvider(string provider)
    {
        return provider.ToLowerInvariant() switch
        {
            "claude" or "anthropic" => AIProvider.Claude,
            "openai" or "gpt" => AIProvider.OpenAI,
            "gemini" or "google" => AIProvider.Gemini,
            "mistral" => AIProvider.Mistral,
            "qwen" or "alibaba" => AIProvider.Qwen,
            _ => throw new ArgumentException($"Unknown provider: {provider}")
        };
    }

    private ProviderConfig GetProviderConfig(string provider)
    {
        return provider.ToLowerInvariant() switch
        {
            "claude" or "anthropic" => _providerOptions.Claude,
            "openai" or "gpt" => _providerOptions.OpenAI,
            "gemini" or "google" => _providerOptions.Gemini,
            _ => throw new ArgumentException($"Unknown provider: {provider}")
        };
    }

    private static string GetDefaultModelForProvider(string provider)
    {
        return provider.ToLowerInvariant() switch
        {
            "claude" or "anthropic" => "claude-sonnet-4-20250514",
            "openai" or "gpt" => "gpt-4o",
            "gemini" or "google" => "gemini-2.0-flash",
            "mistral" => "mistral-large-latest",
            "qwen" or "alibaba" => "qwen-max",
            _ => throw new ArgumentException($"Unknown provider: {provider}")
        };
    }
}