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;
using CodePlay.Core.Validators;

namespace CodePlay.Core.Services;

/// <summary>
/// 代码转换服务
/// </summary>
public class ConversionService
{
    private readonly Dictionary<(LanguageType, LanguageType), IConverter> _converters = new();
    private readonly ValidationPipeline _validationPipeline;
    
    public ConversionService()
    {
        // 注册转换器
        RegisterConverter(LanguageType.CSharp, LanguageType.Java, new CSharpToJavaConverter());
        RegisterConverter(LanguageType.Java, LanguageType.CSharp, new JavaToCSharpConverter());
        
        // 初始化验证流水线
        _validationPipeline = new ValidationPipeline();
    }
    
    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);
            
            // 执行验证（仅当目标语言是 C# 时）
            if (result.Success && request.TargetLanguage == LanguageType.CSharp && request.ValidationRounds > 0)
            {
                var validationSummary = await _validationPipeline.ValidateAsync(
                    result.TransformedCode, 
                    request.TargetLanguage, 
                    request.ValidationRounds,
                    cancellationToken);
                
                result.ValidationSummary = validationSummary;
                
                if (!validationSummary.Passed)
                {
                    result.Success = false;
                    result.ErrorMessage = $"Validation failed after {validationSummary.RoundsExecuted} rounds";
                }
            }
            
            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();
    }
}