codeplay/CodePlay.Core/Services/ConversionService.cs

using CodePlay.Core.Interfaces;
using CodePlay.Core.Models;
using CodePlay.Core.Common;
using CodePlay.Core.Parsers;
using CodePlay.Core.Converters;

namespace CodePlay.Core.Services;

/// <summary>
/// 代码转换服务
/// </summary>
public class ConversionService
{
    private readonly Dictionary<(LanguageType, LanguageType), IConverter> _converters = new();
    
    public ConversionService()
    {
        // 注册转换器
        RegisterConverter(LanguageType.CSharp, LanguageType.Java, new CSharpToJavaConverter());
        RegisterConverter(LanguageType.Java, LanguageType.CSharp, new JavaToCSharpConverter());
    }
    
    private void RegisterConverter(LanguageType source, LanguageType target, IConverter converter)
    {
        _converters[(source, target)] = converter;
    }
    
    /// <summary>
    /// 转换代码
    /// </summary>
    public async Task<ConversionResult> ConvertAsync(ConversionRequest request, CancellationToken cancellationToken = default)
    {
        var key = (request.SourceLanguage, request.TargetLanguage);
        
        if (!_converters.TryGetValue(key, out var converter))
        {
            return new ConversionResult
            {
                Success = false,
                ErrorMessage = $"Conversion from {request.SourceLanguage} to {request.TargetLanguage} is not supported"
            };
        }
        
        try
        {
            // 解析源代码
            var parser = CreateParser(request.SourceLanguage);
            if (parser == null)
            {
                return new ConversionResult
                {
                    Success = false,
                    ErrorMessage = $"Parser for {request.SourceLanguage} is not available"
                };
            }
            
            var syntaxTree = await parser.ParseAsync(request.SourceCode, cancellationToken);
            
            // 执行转换
            var result = await converter.ConvertAsync(syntaxTree, request.TargetLanguage, request.Options, cancellationToken);
            
            return result;
        }
        catch (Exception ex)
        {
            return new ConversionResult
            {
                Success = false,
                ErrorMessage = $"Conversion failed: {ex.Message}"
            };
        }
    }
    
    private IParser? CreateParser(LanguageType language)
    {
        return language switch
        {
            LanguageType.CSharp => new CSharpParser(),
            LanguageType.Java => new JavaParser(),
            _ => null
        };
    }
    
    /// <summary>
    /// 检查是否支持指定的语言转换
    /// </summary>
    public bool IsConversionSupported(LanguageType source, LanguageType target)
    {
        return _converters.ContainsKey((source, target));
    }
    
    /// <summary>
    /// 获取支持的语言转换列表
    /// </summary>
    public List<(LanguageType Source, LanguageType Target)> GetSupportedConversions()
    {
        return _converters.Keys.ToList();
    }
}