codeplay/CodePlay.Core/Converters/CSharpToCppStrategy.cs

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

namespace CodePlay.Core.Converters;

public class CSharpToCppStrategy : IConversionStrategy
{
    public LanguageType SourceLanguage => LanguageType.CSharp;
    public LanguageType TargetLanguage => LanguageType.CPlusPlus;
    
    private readonly List<(string Src, string Tgt)> _mappings = new();
    
    public CSharpToCppStrategy() => InitMappings();
    
    void InitMappings()
    {
        _mappings.AddRange(new[] {
            ("string", "std::string"), ("String", "std::string"),
            ("int", "int"), ("long", "long"), ("bool", "bool"),
            ("double", "double"), ("float", "float"),
            ("List<", "std::vector<"), ("Dictionary<", "std::map<"),
            ("Console.WriteLine", "std::cout <<"),
            ("DateTime", "std::chrono::system_clock::time_point"),
            ("Exception", "std::exception"),
            ("Task<", "std::future<"), ("async Task", "std::future"),
            ("var ", "auto "),
        });
    }
    
    public SyntaxNode ConvertNode(SyntaxNode node, ConversionContext context)
    {
        var nn = new SyntaxNode {
            Type = node.Type, Text = Convert(node.Text),
            Metadata = new Dictionary<string, object?>(node.Metadata),
            Parent = node.Parent, Children = new List<SyntaxNode>(),
            IsUnconvertible = node.IsUnconvertible, TodoDescription = node.TodoDescription
        };
        foreach (var c in node.Children) { var cc = ConvertNode(c, context); cc.Parent = nn; nn.Children.Add(cc); }
        return nn;
    }
    
    string Convert(string t)
    {
        if (string.IsNullOrWhiteSpace(t)) return t;
        var r = t;
        
        if (r.Trim().StartsWith("namespace ")) r = r.Replace("namespace ", "namespace ") + " {";
        if (r.Trim().StartsWith("using ")) r = "#include <" + System.Text.RegularExpressions.Regex.Match(r, @"using\s+([\w.]+);").Groups[1].Value.Replace(".", "/") + ">";
        
        foreach (var (s, tgt) in _mappings) r = r.Replace(s, tgt);
        
        r = System.Text.RegularExpressions.Regex.Replace(r, @"(public|private|protected)\s+(\w+)\s+(\w+)\s*\{\s*get;\s*set;\s*\}", m =>
        {
            var mod = m.Groups[1].Value == "public" ? "" : m.Groups[1].Value + ":";
            var type = m.Groups[2].Value; var name = m.Groups[3].Value;
            return $"{mod}\n    {type} {name};\n";
        });
        
        r = r.Replace("async ", "").Replace("await ", "");
        r = System.Text.RegularExpressions.Regex.Replace(r, @"return\s+await\s+Task\.FromResult\(", "return std::async([]{ return ");
        r = r.Replace(".Where(", ".| std::views::filter(").Replace(".Select(", ".| std::views::transform(");
        r = r.Replace(".ToList()", ".to_vector()");
        r = System.Text.RegularExpressions.Regex.Replace(r, @"(\w+)\s*=>", m => $"{m.Groups[1].Value}");
        
        r = r.Replace("null", "nullptr").Replace("true", "true").Replace("false", "false");
        return r;
    }
    
    public string MapType(string s) { var r = s; foreach (var (src, tgt) in _mappings) r = r.Replace(src, tgt); return r; }
}