codeplay/CodePlay.Core/Converters/JavaToCSharpConverter.cs

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

namespace CodePlay.Core.Converters;

/// <summary>
/// Java 到 C# 代码转换器
/// </summary>
public class JavaToCSharpConverter : IConverter
{
    private readonly JavaToCSharpStrategy _strategy;
    private readonly CSharpCodeGenerator _codeGenerator;
    
    public JavaToCSharpConverter()
    {
        _strategy = new JavaToCSharpStrategy();
        _codeGenerator = new CSharpCodeGenerator();
    }
    
    /// <summary>
    /// 转换语法树
    /// </summary>
    public async Task<ConversionResult> ConvertAsync(
        Interfaces.SyntaxTree syntaxTree, 
        LanguageType targetLanguage, 
        ConversionOptions? options = null, 
        CancellationToken cancellationToken = default)
    {
        var result = new ConversionResult
        {
            Success = false,
            Warnings = new List<ConversionWarning>(),
            Report = new ConversionReport()
        };
        
        if (targetLanguage != LanguageType.CSharp)
        {
            result.ErrorMessage = "This converter only supports Java to C# conversion";
            return result;
        }
        
        try
        {
            var context = new ConversionContext
            {
                SourceLanguage = LanguageType.Java,
                TargetLanguage = LanguageType.CSharp,
                Options = options
            };
            
            // 转换根节点
            var convertedRoot = _strategy.ConvertNode(syntaxTree.Root, context);
            
            // 创建新的语法树
            var convertedTree = new Interfaces.SyntaxTree
            {
                Language = LanguageType.CSharp,
                Root = convertedRoot,
                SourceCode = syntaxTree.SourceCode
            };
            
            // 保留注释和文档
            if (options?.KeepComments == true)
            {
                convertedTree.Documentation = syntaxTree.Documentation
                    .Select(d => new SyntaxDocumentation
                    {
                        ElementName = d.ElementName,
                        Content = ConvertDocumentation(d.Content),
                        Format = DocFormat.XmlDoc
                    }).ToList();
            }
            
            // 生成 C# 代码
            var generatedCode = _codeGenerator.Generate(convertedTree);
            
            result.TransformedCode = generatedCode;
            result.Success = true;
            
            // 生成报告
            if (result.Report != null)
            {
                result.Report.LinesConverted = syntaxTree.SourceCode?.Split('\n').Length ?? 0;
                result.Report.ClassesConverted = CountClasses(syntaxTree.Root);
                result.Report.MethodsConverted = CountMethods(syntaxTree.Root);
                result.Report.TodoItems = context.TodoItems;
                result.Report.Issues = context.Issues;
                result.Report.TransformationLog = context.Logs;
            }
            
            context.Logs.Add(new TransformationLog
            {
                Timestamp = DateTime.UtcNow,
                Operation = "Conversion",
                Details = "Java to C# conversion completed",
                Level = LogLevel.Info
            });
            
            result.Warnings = context.Issues
                .Select(i => new ConversionWarning
                {
                    Code = $"WARN_{i.Type}",
                    Message = i.Description,
                    Suggestion = i.Suggestion
                }).ToList();
        }
        catch (Exception ex)
        {
            result.ErrorMessage = ex.Message;
            result.Success = false;
        }
        
        return await Task.FromResult(result);
    }
    
    private string ConvertDocumentation(string javaDocContent)
    {
        // JavaDoc 到 XML Doc 转换
        var content = javaDocContent
            .Replace("/**", "///")
            .Replace("*/", "")
            .Replace("*", "///")
            .Replace("@param ", "<param name=\"")
            .Replace("@return", "<returns>")
            .Replace("@throws ", "<exception cref=\"")
            .Replace("@see ", "<seealso cref=\"");
        
        return content;
    }
    
    private int CountClasses(Interfaces.SyntaxNode node)
    {
        int count = 0;
        if (node.Type == SyntaxNodeType.Class) count++;
        count += node.Children.Sum(CountClasses);
        return count;
    }
    
    private int CountMethods(Interfaces.SyntaxNode node)
    {
        int count = 0;
        if (node.Type == SyntaxNodeType.Method) count++;
        count += node.Children.Sum(CountMethods);
        return count;
    }
}