using System.Collections.Concurrent;
using com.github.javaparser.ast.expr;
using com.github.javaparser.ast.type;
using JavaToCSharp.Expressions;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Ast = com.github.javaparser.ast;
using Type = com.github.javaparser.ast.type.Type;

namespace JavaToCSharp;

public static class TypeHelper
{
    // Mutated at conversion time via AddOrUpdateTypeNameConversions (e.g. to register interface
    // renames when StartInterfaceNamesWithI is set) while other threads read it in ConvertType,
    // so this must be a concurrent collection to keep parallel conversions safe.
    private static readonly ConcurrentDictionary<string, string> _typeNameConversions = new()
    {
        // Primitives and their boxed counterparts. Java's boxed types are nullable references while
        // the C# equivalents are value types, so a null-valued Java variable will need manual review.
        ["boolean"] = "bool",
        ["Boolean"] = "bool",
        ["Byte"] = "sbyte", // java's byte is signed, unlike C#'s
        ["Character"] = "char",
        ["Double"] = "double",
        ["Float"] = "float",
        ["Integer"] = "int",
        ["Long"] = "long",
        ["Short"] = "short",

        // Other simple types
        ["AutoCloseable"] = "IDisposable",
        ["BigDecimal"] = "decimal",
        ["Closeable"] = "IDisposable",
        ["ICloseable"] = "IDisposable",
        ["Object"] = "object",
        ["String"] = "string",
        ["StringBuffer"] = "StringBuilder",

        // Collection interfaces map to the .NET interfaces so that variables declared against an
        // abstraction stay abstract; the concrete java implementations below supply the `new` types.
        ["Collection"] = "ICollection",
        ["Comparable"] = "IComparable",
        ["Comparator"] = "IComparer",
        ["Iterable"] = "IEnumerable",
        ["Iterator"] = "IEnumerator",
        ["List"] = "IList",
        ["Map"] = "IDictionary",
        ["NavigableMap"] = "IDictionary",
        ["NavigableSet"] = "ISet",
        ["Set"] = "ISet",
        ["SortedMap"] = "IDictionary",
        ["SortedSet"] = "ISet",

        // Concrete collection implementations. These are what `new Foo<>()` expressions resolve to,
        // so they must name instantiable .NET types rather than interfaces.
        ["ArrayList"] = "List",
        ["HashMap"] = "Dictionary",
        ["LinkedHashMap"] = "Dictionary",
        ["LinkedHashSet"] = "HashSet",
        ["TreeMap"] = "SortedDictionary",
        ["TreeSet"] = "SortedSet",

        // Exceptions
        ["AccessDeniedException"] = "UnauthorizedAccessException",
        ["AlreadyClosedException"] = "ObjectDisposedException",
        ["ArrayIndexOutOfBoundsException"] = "IndexOutOfRangeException",
        ["AssertionError"] = "InvalidOperationException",
        ["ClassCastException"] = "InvalidCastException",
        ["CloneNotSupportedException"] = "NotSupportedException",
        ["EOFException"] = "EndOfStreamException",
        ["Error"] = "Exception",
        ["IllegalArgumentException"] = "ArgumentException",
        ["IllegalStateException"] = "InvalidOperationException",
        ["IndexOutOfBoundsException"] = "IndexOutOfRangeException",
        ["InterruptedException"] = "OperationCanceledException",
        ["NoSuchElementException"] = "InvalidOperationException",
        ["NoSuchFileException"] = "FileNotFoundException",
        ["NullPointerException"] = "NullReferenceException",
        ["NumberFormatException"] = "FormatException",
        ["OutOfMemoryError"] = "OutOfMemoryException",
        ["RuntimeException"] = "Exception",
        ["StackOverflowError"] = "StackOverflowException",
        ["Throwable"] = "Exception",
        ["UncheckedIOException"] = "IOException",
        ["UnsupportedOperationException"] = "NotSupportedException",
    };

    public static void AddOrUpdateTypeNameConversions(string key, string value)
    {
        _typeNameConversions[key] = value;
    }

    public static string ConvertTypeOf(Ast.nodeTypes.NodeWithType typedNode)
    {
        return ConvertType(typedNode.getType().toString());
    }

    public static string ConvertType(Type type)
    {
        return ConvertType(type.toString());
    }

    public static string ConvertType(string typeName)
        => TypeNameParser.ParseTypeName(typeName, s => _typeNameConversions.TryGetValue(s, out string? converted) ? converted : s);

    public static TypeSyntax ConvertTypeSyntax(Type type, int arrayRank)
    {
        if (type is ArrayType arrayType)
        {
            if (arrayRank > 0 && arrayType.getArrayLevel() != arrayRank)
            {
                throw new ArgumentException("Given array rank does not match the array level of the type", nameof(arrayRank));
            }

            arrayRank = arrayType.getArrayLevel();
            Type elementType;

            while ((elementType = arrayType.getElementType()) is ArrayType nestedArrayType)
            {
                arrayType = nestedArrayType;
            }

            return ConvertTypeSyntax(elementType, arrayRank);
        }

        return arrayRank == 0
            ? SyntaxFactory.ParseTypeName(ConvertType(type))
            : ConvertArrayTypeSyntax(type, arrayRank);
    }

    public static ArrayTypeSyntax ConvertArrayTypeSyntax(Type type, int arrayRank)
    {
        var rankSpecifiers = SyntaxFactory.ArrayRankSpecifier(
            SyntaxFactory.SeparatedList<ExpressionSyntax>(
                Enumerable.Repeat(SyntaxFactory.OmittedArraySizeExpression(), arrayRank)
            ));

        return SyntaxFactory.ArrayType(ConvertTypeSyntax(type, 0))
            .WithRankSpecifiers(SyntaxFactory.SingletonList(rankSpecifiers));
    }

    public static string Capitalize(string name)
    {
        var parts = name.Split('.');

        var joined = string.Join(".", parts.Select(i =>
        {
            if (i.Length == 1)
                return i.ToUpper();
            else
                return i[0].ToString().ToUpper() + i[1..];
        }));

        return joined;
    }

    public static string EscapeIdentifier(string name)
    {
        // @ (C# Reference): https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/verbatim
        // C# Keywords: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
        return name switch {
            "abstract" or "as" or "base" or "bool" or "break" or
            "byte" or "case" or "catch" or "char" or "checked" or
            "class" or "const" or "continue" or "decimal" or "default" or
            "delegate" or "do" or "double" or "else" or "enum" or
            "event" or "explicit" or "extern" or "false" or "finally" or
            "fixed" or "float" or "for" or "foreach" or "goto" or
            "if" or "implicit" or "in" or "int" or "interface" or
            "internal" or "is" or "lock" or "long" or "namespace" or
            "new" or "null" or "object" or "operator" or "out" or
            "override" or "params" or "private" or "protected" or "public" or
            "readonly" or "ref" or "return" or "sbyte" or "sealed" or
            "short" or "sizeof" or "stackalloc" or "static" or "string" or
            "struct" or "switch" or "this" or "throw" or "true" or
            "try" or "typeof" or "uint" or "ulong" or "unchecked" or
            "unsafe" or "ushort" or "using" or "virtual" or "void" or
            "volatile" or "while" => "@" + name,
            _ => name,
        };
    }

    public static string ReplaceCommonMethodNames(string name)
    {
        return name.ToLower() switch {
            "hashcode" => "GetHashCode",
            "getclass" => "GetType",
            "close" => "Dispose",
            _ => name,
        };
    }

    public static TypeSyntax GetSyntaxFromType(ClassOrInterfaceType type)
    {
        string typeName = ConvertType(type.getNameAsString());
        var typeArgs = type.getTypeArguments().FromOptional<Ast.NodeList>()?.ToList<Type>();

        TypeSyntax typeSyntax;

        if (typeArgs is { Count: > 0 })
        {
            typeSyntax = SyntaxFactory.GenericName(typeName)
                .AddTypeArgumentListArguments(typeArgs.Select(t => SyntaxFactory.ParseTypeName(ConvertType(t))).ToArray());
        }
        else
        {
            typeSyntax = SyntaxFactory.ParseTypeName(typeName);
        }

        // Nested types (e.g. `Outer.Inner`) carry their declaring type as a scope, which
        // getNameAsString() above does not include. Prepend it so the declaring type isn't lost.
        if (type.getScope().FromOptional<ClassOrInterfaceType>() is { } scope
            && typeSyntax is SimpleNameSyntax simpleName
            && GetSyntaxFromType(scope) is NameSyntax scopeName)
        {
            return SyntaxFactory.QualifiedName(scopeName, simpleName);
        }

        return typeSyntax;
    }

    public static ArgumentListSyntax GetSyntaxFromArguments(ConversionContext context, java.util.List args)
    {
        return SyntaxFactory.ArgumentList(GetSeparatedListFromArguments(context, args));
    }

    private static SeparatedSyntaxList<ArgumentSyntax> GetSeparatedListFromArguments(ConversionContext context, java.util.List args)
    {
        return GetSeparatedListFromArguments(context, args.OfType<Expression>());
    }

    private static SeparatedSyntaxList<ArgumentSyntax> GetSeparatedListFromArguments(ConversionContext context, IEnumerable<Expression> args)
    {
        var argSyntaxes = new List<ArgumentSyntax>();

        foreach (var arg in args)
        {
            var argSyntax = ExpressionVisitor.VisitExpression(context, arg);
            if (argSyntax is null)
            {
                continue;
            }

            argSyntaxes.Add(SyntaxFactory.Argument(argSyntax));
        }

        var separators = Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), argSyntaxes.Count - 1);
        return SyntaxFactory.SeparatedList(argSyntaxes, separators);
    }

    /// <summary>
    /// Returns the list of C# type parameter constraints that must be added to a class syntax
    /// to convert the java bounded type parameters of a class declaration.
    /// e.g. to convert <![CDATA[ <T extends Clazz<T>> ]]> into <![CDATA[ <T> where T : Clazz<T> ]]>
    /// </summary>
    public static IEnumerable<TypeParameterConstraintClauseSyntax> GetTypeParameterListConstraints(List<TypeParameter> typeParams)
    {
        var typeParameterConstraints = new List<TypeParameterConstraintClauseSyntax>();

        foreach (TypeParameter typeParam in typeParams)
        {
            if (typeParam.getTypeBound().size() > 0)
            {
                var typeConstraintsSyntax = new SeparatedSyntaxList<TypeParameterConstraintSyntax>();

                foreach (ClassOrInterfaceType bound in typeParam.getTypeBound())
                {
                    typeConstraintsSyntax = typeConstraintsSyntax.Add(SyntaxFactory.TypeConstraint(SyntaxFactory.ParseTypeName(bound.asString())));
                }

                var typeIdentifier = SyntaxFactory.IdentifierName(typeParam.getName().asString());
                var parameterConstraintClauseSyntax = SyntaxFactory.TypeParameterConstraintClause(typeIdentifier, typeConstraintsSyntax);

                typeParameterConstraints.Add(parameterConstraintClauseSyntax);
            }
        }

        return typeParameterConstraints;
    }

    /// <summary>
    /// Transforms method calls into property and indexer accesses where appropriate.
    /// </summary>
    /// <param name="context">The conversion context.</param>
    /// <param name="methodCallExpr">The <c>MethodCallExpr</c> to be transformed.</param>
    /// <param name="transformedSyntax">The resulting transformed syntax.</param>
    /// <returns><c>true</c> if the syntax was transformed, <c>false</c> otherwise</returns>
    public static bool TryTransformMethodCall(ConversionContext context, MethodCallExpr methodCallExpr,
        out ExpressionSyntax? transformedSyntax)
    {
        if (methodCallExpr.getScope().FromOptional<Expression>() is { } scope)
        {
            var methodName = methodCallExpr.getName();
            var args = methodCallExpr.getArguments();

            switch (methodName.getIdentifier())
            {
                case "length" when args.size() == 0:
                {
                    var scopeSyntaxLength = ExpressionVisitor.VisitExpression(context, scope);
                    transformedSyntax = ReplaceMethodByProperty(scopeSyntaxLength, "Length");
                    return true;
                }

                case "size" when args.size() == 0:
                {
                    var scopeSyntaxSize = ExpressionVisitor.VisitExpression(context, scope);
                    transformedSyntax = ReplaceMethodByProperty(scopeSyntaxSize, "Count");
                    return true;
                }

                case "getMessage" when args.size() == 0:
                {
                    var scopeSyntaxMessage = ExpressionVisitor.VisitExpression(context, scope);
                    transformedSyntax = ReplaceMethodByProperty(scopeSyntaxMessage, "Message");
                    return true;
                }

                case "get" when args.size() == 1:
                {
                    var scopeSyntaxGet = ExpressionVisitor.VisitExpression(context, scope);
                    if (scopeSyntaxGet is null)
                    {
                        transformedSyntax = null;
                        return false;
                    }

                    transformedSyntax = ReplaceGetByIndexAccess(context, scopeSyntaxGet, args);
                    return true;
                }

                // Java's put returns the previous value, which an index assignment discards. That
                // matches the existing handling of List.set, whose return value is dropped too.
                case "put" when args.size() == 2:
                case "set" when args.size() == 2:
                {
                    var scopeSyntaxSet = ExpressionVisitor.VisitExpression(context, scope);
                    if (scopeSyntaxSet is null)
                    {
                        transformedSyntax = null;
                        return false;
                    }

                    transformedSyntax = ReplaceSetByIndexAccess(context, scopeSyntaxSet, args);
                    return true;
                }
            }
        }

        transformedSyntax = null;
        return false;

        static MemberAccessExpressionSyntax? ReplaceMethodByProperty(ExpressionSyntax? scopeSyntax, string identifier)
        {
            if (scopeSyntax is null)
            {
                return null;
            }

            // Replace   expr.Size()   by   expr.Count
            return SyntaxFactory.MemberAccessExpression(
                SyntaxKind.SimpleMemberAccessExpression,
                scopeSyntax,
                SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(identifier)));
        }

        static ExpressionSyntax ReplaceGetByIndexAccess(ConversionContext context, ExpressionSyntax scopeSyntax,
            java.util.List args)
        {
            // Replace   expr.Get(i)   by   expr[i]
            return SyntaxFactory.ElementAccessExpression(
                scopeSyntax,
                SyntaxFactory.BracketedArgumentList(GetSeparatedListFromArguments(context, args))
            );
        }

        static ExpressionSyntax? ReplaceSetByIndexAccess(
            ConversionContext context,
            ExpressionSyntax scopeSyntax,
            java.util.List args)
        {
            // Replace   expr.Set(i,v)   by   expr[i] = v
            var argsList = args.ToList<Expression>() ?? [];
            var left = SyntaxFactory.ElementAccessExpression(
                 scopeSyntax,
                 SyntaxFactory.BracketedArgumentList(GetSeparatedListFromArguments(context, argsList.Take(1)))
                ).WithTrailingTrivia(SyntaxFactory.Whitespace(" "));
            var right = ExpressionVisitor.VisitExpression(context, argsList[1])?.WithLeadingTrivia(SyntaxFactory.Whitespace(" "));
            if (right is null)
            {
                return null;
            }

            return SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, left, right);
        }
    }
}