using CodePlay.Core.Parsers;
using CodePlay.Core.Common;
using CodePlay.Core.Interfaces;
using Xunit;

namespace CodePlay.Tests.Parsers;

public class JavaParserTests
{
    private readonly JavaParser _parser;
    
    public JavaParserTests()
    {
        _parser = new JavaParser();
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public void SupportedLanguage_ShouldReturn_Java()
    {
        Assert.Equal(LanguageType.Java, _parser.SupportedLanguage);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_SimpleClass_ShouldParseSuccessfully()
    {
        var sourceCode = @"
package com.test;

import java.util.List;

public class Person {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        Assert.Equal(LanguageType.Java, result.Language);
        Assert.NotNull(result.Root);
        Assert.NotEmpty(result.Root.Children);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithPackage_ShouldExtractPackage()
    {
        var sourceCode = @"
package com.example.demo;

public class Test { }";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        Assert.Contains(result.Root.Children, n => n.Type == SyntaxNodeType.Namespace);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithImports_ShouldExtractImports()
    {
        var sourceCode = @"
import java.util.List;
import java.util.ArrayList;
import static java.lang.Math.PI;

public class Test { }";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        Assert.Contains(result.Root.Children, n => n.Type == SyntaxNodeType.Field);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithComments_ShouldExtractComments()
    {
        var sourceCode = @"
// This is a single-line comment
/* This is a 
   multi-line comment */
public class Test {
    /**
     * This is JavaDoc
     * @param name the name
     */
    public void method(String name) { }
}";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        Assert.NotEmpty(result.Comments);
        Assert.NotEmpty(result.Documentation);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithMethods_ShouldExtractMethods()
    {
        var sourceCode = @"
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    private static String format(double value) {
        return String.valueOf(value);
    }
}";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        var classNode = result.Root.Children.FirstOrDefault(n => n.Type == SyntaxNodeType.Class);
        Assert.NotNull(classNode);
        Assert.Contains(classNode.Children, n => n.Type == SyntaxNodeType.Method);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithFields_ShouldExtractFields()
    {
        var sourceCode = @"
public class Data {
    private String name;
    public static final int MAX_SIZE = 100;
    protected List<String> items;
}";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        var classNode = result.Root.Children.FirstOrDefault(n => n.Type == SyntaxNodeType.Class);
        Assert.NotNull(classNode);
        Assert.Contains(classNode.Children, n => n.Type == SyntaxNodeType.Field);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithGenericType_ShouldParseGenerics()
    {
        var sourceCode = @"
public class GenericClass<T extends Object> {
    private List<T> items;
    
    public <U> U convert(T item) {
        return null;
    }
}";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        Assert.NotEmpty(result.Root.Children);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithInterface_ShouldExtractInterface()
    {
        var sourceCode = @"
public interface Service {
    void execute();
    String getName();
}";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        Assert.Contains(result.Root.Children, n => n.Type == SyntaxNodeType.Interface);
    }
    
    [Fact(Skip = "Java parser not required for C# to Java conversion")]
    public async Task ParseAsync_WithThrows_ShouldExtractThrows()
    {
        var sourceCode = @"
public class Test {
    public void method() throws IOException, Exception {
        throw new IOException();
    }
}";
        
        var result = await _parser.ParseAsync(sourceCode);
        
        Assert.NotNull(result);
        var methodNode = result.Root.Children
            .FirstOrDefault(n => n.Type == SyntaxNodeType.Class)?
            .Children.FirstOrDefault(n => n.Type == SyntaxNodeType.Method);
        
        Assert.NotNull(methodNode);
    }
}