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

namespace CodePlay.Tests.Converters;

/// <summary>
/// C# 转 Java 边界测试用例组
/// </summary>
public class CSharpToJavaEdgeCaseTests
{
    private readonly CSharpParser _parser = new();
    private readonly CSharpToJavaConverter _converter = new();

    #region 空代码和极小代码
    
    [Fact]
    public async Task ConvertAsync_EmptyCode_ShouldReturnEmpty()
    {
        var sourceCode = "";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_OnlyWhitespace_ShouldReturnEmpty()
    {
        var sourceCode = "  \n\n  \t  ";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_SingleLineComment_ShouldPreserve()
    {
        var sourceCode = "// This is a comment";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(
            syntaxTree, 
            LanguageType.Java, 
            new ConversionOptions { KeepComments = true });
        
        Assert.True(result.Success);
    }
    
    #endregion
    
    #region 复杂泛型
    
    [Fact]
    public async Task ConvertAsync_NestedGenerics_ShouldMapCorrectly()
    {
        var sourceCode = @"
using System.Collections.Generic;
namespace Test {
    public class Model {
        public Dictionary<string, List<int>> Mapping { get; set; }
    }
}";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
        Assert.Contains("HashMap", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_GenericClassWithConstraint_ShouldConvert()
    {
        var sourceCode = @"
namespace Test {
    public class Repository<T> where T : class {
        public T Get() { return default; }
    }
}";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
    }
    
    #endregion
    
    #region 复杂 LINQ 操作
    
    [Fact]
    public async Task ConvertAsync_LinqGroupBy_ShouldConvertLambda()
    {
        var sourceCode = @"
var result = list.GroupBy(x => x.Category).Select(g => g.Key).ToList();
";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
        Assert.Contains(".collect(Collectors.toList())", result.TransformedCode);
        Assert.Contains("->", result.TransformedCode); // Lambda converted
    }
    
    [Fact]
    public async Task ConvertAsync_LinqMultipleOperations_ShouldConvertChained()
    {
        var sourceCode = @"
var result = list.Where(x => x > 0).OrderBy(x => x).Select(x => x * 2).Distinct().ToList();
";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
        Assert.Contains(".filter(", result.TransformedCode);
        Assert.Contains(".sorted(", result.TransformedCode);
        Assert.Contains(".distinct()", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_LinqFirstOrDefault_ShouldConvertLambda()
    {
        var sourceCode = @"
var first = list.FirstOrDefault(x => x.IsActive);
";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
        Assert.Contains("->", result.TransformedCode);
    }
    
    #endregion
    
    #region 注释和文档字符串保留
    
    [Fact]
    public async Task ConvertAsync_XmlDocComment_ShouldConvertToJavadoc()
    {
        var sourceCode = @"
namespace Test {
    /// <summary>
    /// A person class
    /// </summary>
    public class Person { }
}";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(
            syntaxTree, 
            LanguageType.Java, 
            new ConversionOptions { KeepComments = true, KeepDocStrings = true });
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_SingleLineComments_ShouldPreserve()
    {
        var sourceCode = @"
namespace Test {
    public class Test {
        // This is a test comment
        public void Method() {
            // Another comment
        }
    }
}";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(
            syntaxTree, 
            LanguageType.Java, 
            new ConversionOptions { KeepComments = true });
        
        Assert.True(result.Success);
        Assert.Contains("// This is a test comment", result.TransformedCode);
        Assert.Contains("// Another comment", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_BlockComment_ShouldPreserve()
    {
        var sourceCode = @"
namespace Test {
    /* This is a block comment */
    public class Test { }
}";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(
            syntaxTree, 
            LanguageType.Java, 
            new ConversionOptions { KeepComments = true });
        
        Assert.True(result.Success);
        Assert.Contains("/* This is a block comment */", result.TransformedCode);
    }
    
    #endregion
    
    #region 超大代码块
    
    [Fact]
    public async Task ConvertAsync_LargeCodeBlock_ShouldConvertAll()
    {
        var sourceCode = @"
using System;
using System.Collections.Generic;
using System.Linq;

namespace LargeApp {
    public class LargeModel {
        public string Name { get; set; }
        public int Age { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedAt { get; set; }
        public List<string> Tags { get; set; }
        public Dictionary<string, int> Scores { get; set; }
        
        public int CalculateScore(int baseScore) {
            return baseScore * 2 + Age;
        }
        
        public IEnumerable<string> GetActiveTags() {
            return Tags.Where(t => t.Length > 3).OrderBy(t => t).ToList();
        }
        
        public async System.Threading.Tasks.Task<string> GetDataAsync() {
            return await System.Threading.Tasks.Task.FromResult(""data"");
        }
    }
}";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
        Assert.Contains("package LargeApp;", result.TransformedCode);
        Assert.Contains("ArrayList<String>", result.TransformedCode);
        Assert.Contains("HashMap<String, Integer>", result.TransformedCode);
    }
    
    #endregion
    
    #region 错误路径和异常处理
    
    [Fact]
    public async Task ConvertAsync_InvalidOptionSyntax_ShouldParse()
    {
        var sourceCode = @"
namespace Test {
    public class Test {
        public int x { get => value; }
    }
}";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.True(result.Success);
    }
    
    [Theory]
    [InlineData("   ")]
    [InlineData("\t\n")]
    [InlineData("")]
    public async Task ConvertAsync_EmptyVariants_ShouldNotCrash(string input)
    {
        var syntaxTree = await _parser.ParseAsync(input);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.NotNull(result);
    }
    
    #endregion
}