codeplay/CodePlay.Core/Strategies/CSharpToJavaStrategy.cs

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

namespace CodePlay.Core.Strategies;

public class CSharpToJavaStrategy : IConversionStrategy
{
    public LanguageType SourceLanguage => LanguageType.CSharp;
    public LanguageType TargetLanguage => LanguageType.Java;
    
    private static readonly Dictionary<string, string> TypeMappings = new()
    {
        { "string", "String" }, { "int", "int" }, { "long", "long" },
        { "float", "float" }, { "double", "double" }, { "bool", "boolean" },
        { "decimal", "BigDecimal" }, { "object", "Object" }, { "void", "void" },
        { "DateTime", "LocalDateTime" }, { "Guid", "UUID" },
        { "Task", "CompletableFuture" }, { "Stream", "InputStream" },
        { "List<string>", "List<String>" }, { "Dictionary<string,string>", "Map<String,String>" }
    };
    
    public string MapType(string sourceType)
    {
        if (string.IsNullOrEmpty(sourceType)) return sourceType;
        return TypeMappings.TryGetValue(sourceType, out var mapped) ? mapped : sourceType;
    }
    
    public SyntaxNode ConvertNode(SyntaxNode node, ConversionContext context)
    {
        var convertedNode = new SyntaxNode
        {
            Type = node.Type,
            Text = node.Text,
            Metadata = new Dictionary<string, object?>(node.Metadata),
            IsUnconvertible = node.IsUnconvertible
        };
        
        if (node.Metadata.ContainsKey("type"))
        {
            convertedNode.Metadata["type"] = MapType(node.Metadata["type"]?.ToString() ?? "");
        }
        
        foreach (var child in node.Children)
        {
            convertedNode.Children.Add(ConvertNode(child, context));
        }
        
        return convertedNode;
    }
}