json-2-c-sharp-code-generator/Json2CSharpCodeGenerator.Lib/CodeWriters/JavaCodeWriter.cs

using System.Text;

namespace Json2CSharpCodeGenerator.Lib.CodeWriters;

public class JavaCodeWriter : ICodeBuilder
{
    public string FileExtension => ".java";

    public string DisplayName => "Java";

    private static readonly HashSet<string> _ReservedKeywords = new(comparer: StringComparer.Ordinal)
    {
        // https://en.wikipedia.org/wiki/List_of_Java_keywords
        // `Array.from( document.querySelectorAll('dl > dt > code') ).map( e => '"' + e.textContent + '"' ).sort().join( ", " )`

        "abstract",
        "assert",
        "boolean",
        "break",
        "byte",
        "case",
        "catch",
        "char",
        "class",
        "const",
        "const",
        "continue",
        "default",
        "do",
        "double",
        "else",
        "enum",
        "extends",
        "false",
        "final",
        "finally",
        "float",
        "for",
        "goto",
        "goto",
        "if",
        "implements",
        "import",
        "instanceof",
        "int",
        "interface",
        "long",
        "native",
        "new",
        "non-sealed",
        "null",
        "open",
        "opens",
        "package",
        "permits",
        "private",
        "protected",
        "provides",
        "public",
        "record",
        "return",
        "sealed",
        "short",
        "static",
        "strictfp",
        "super",
        "switch",
        "synchronized",
        "this",
        "throw",
        "throws",
        "to",
        "transient",
        "transitive",
        "true",
        "try",
        "uses",
        "var",
        "void",
        "volatile",
        "while",
        "with",
        "yield"
    };

    IReadOnlyCollection<string> ICodeBuilder.ReservedKeywords => _ReservedKeywords;
    public bool IsReservedKeyword(string word) => _ReservedKeywords.Contains(word ?? string.Empty);

    public string GetTypeName(JsonType type, IJsonClassGeneratorConfig config)
    {
        return type.Type switch
        {
            JsonTypeEnum.Anything => "Object",
            JsonTypeEnum.Array => GetCollectionTypeName(elementTypeName: GetTypeName(type.InternalType, config), config.CollectionType),
            JsonTypeEnum.Dictionary => "HashMap<String, " + GetTypeName(type.InternalType, config) + ">",
            JsonTypeEnum.Boolean => "boolean",
            JsonTypeEnum.Float => "double",
            JsonTypeEnum.Integer => "int",
            JsonTypeEnum.NonConstrained => "Object",
            JsonTypeEnum.NullableBoolean => "boolean",
            JsonTypeEnum.NullableFloat => "double",
            JsonTypeEnum.NullableInteger => "int",
            JsonTypeEnum.NullableLong => "long",
            JsonTypeEnum.NullableDate => "Date",
            JsonTypeEnum.Long => "long",
            JsonTypeEnum.Date => "Date",
            JsonTypeEnum.NullableSomething => "Object",
            JsonTypeEnum.Object => type.NewAssignedName,
            JsonTypeEnum.String => "String",
            _ => throw new NotSupportedException("Unsupported json type"),
        };
    }

    private static string GetCollectionTypeName(string elementTypeName, OutputCollectionType type)
    {
        return type switch
        {
            OutputCollectionType.Array => elementTypeName + "[]",
            OutputCollectionType.MutableList => "ArrayList<" + elementTypeName + ">",
            OutputCollectionType.IReadOnlyList or OutputCollectionType.ImmutableArray => throw new NotSupportedException("Java does not have in-box interfaces for read-only and immutable collections."),
            _ => throw new ArgumentOutOfRangeException(paramName: nameof(type), actualValue: type, message: "Invalid " + nameof(OutputCollectionType) + " enum value."),
        };
    }

    public void WriteClass(IJsonClassGeneratorConfig config, StringBuilder sw, JsonType type)
    {
        string visibility = config.InternalVisibility ? "" : "public";

        _ = sw.AppendFormat("{0} class {1}", visibility, type.AssignedName);
        _ = sw.AppendLine("{");

        string prefix = config.UseNestedClasses && !type.IsRoot ? "" : "    ";

        WriteClassMembers(config, sw, type, prefix);

        if (config.UseNestedClasses && !type.IsRoot)
            _ = sw.AppendLine("        }");

        if (!config.UseNestedClasses)
            _ = sw.AppendLine("}");

        _ = sw.AppendLine();
    }

    public void WriteClassMembers(IJsonClassGeneratorConfig config, StringBuilder sw, JsonType type, string prefix)
    {
        foreach (FieldInfo field in type.Fields)
        {
            if (config.UsePascalCase || config.ExamplesInDocumentation)
                _ = sw.AppendLine();

            // Check if property name starts with number
            string memberName = field.MemberName;
            if (!string.IsNullOrEmpty(field.MemberName) && char.IsDigit(field.MemberName[0]))
                memberName = "_" + memberName;

            if (IsReservedKeyword(memberName))
                memberName = "my" + memberName;

            if (config.MutableClasses.Members == OutputMembers.AsProperties)
            {
                _ = sw.AppendFormat(prefix + "@JsonProperty" + "(\"{0}\") {1}", field.JsonMemberName, Environment.NewLine);
                _ = sw.AppendFormat(prefix + "public {0} get{1}() {{ \r\t\t return this.{2}; }} {3}", field.Type.GetTypeName(), ChangeFirstChar(memberName), ChangeFirstChar(memberName, false), Environment.NewLine);
                _ = sw.AppendFormat(prefix + "public void set{1}({0} {2}) {{ \r\t\t this.{2} = {2}; }} {3}", field.Type.GetTypeName(), ChangeFirstChar(memberName), ChangeFirstChar(memberName, false), Environment.NewLine);
                _ = sw.AppendFormat(prefix + "{0} {1};", field.Type.GetTypeName(), ChangeFirstChar(memberName, false));
                _ = sw.AppendLine();
            }
            else if (config.MutableClasses.Members == OutputMembers.AsPublicFields)
            {
                memberName = ChangeFirstChar(memberName, false);
                if (field.JsonMemberName != memberName)
                {
                    _ = sw.AppendFormat(prefix + "@JsonProperty" + "(\"{0}\") {1}", field.JsonMemberName, Environment.NewLine);
                }
                _ = sw.AppendFormat(prefix + "public {0} {1};{2}", field.Type.GetTypeName(), memberName, Environment.NewLine);
            }
            else
            {
                throw new InvalidOperationException("Unsupported " + nameof(OutputMembers) + " value: " + config.MutableClasses.Members);
            }
        }
    }

    private static string ChangeFirstChar(string value, bool toCaptial = true)
    {
        if (value == null)
            throw new ArgumentNullException("value");
        if (value.Length == 0)
            return value;
        StringBuilder sb = new();

        _ = sb.Append(toCaptial ? char.ToUpper(value[0]) : char.ToLower(value[0]));
        _ = sb.Append(value.Substring(1));

        return sb.ToString();
    }

    public void WriteFileStart(IJsonClassGeneratorConfig config, StringBuilder sw)
    {
        // foreach (var line in JsonClassGenerator.FileHeader)
        // {
        //     sw.WriteLine("// " + line);
        // }
    }

    public void WriteFileEnd(IJsonClassGeneratorConfig config, StringBuilder sw)
    {
        if (config.UseNestedClasses)
        {
            _ = sw.AppendLine("    }");
        }
    }

    public void WriteNamespaceStart(IJsonClassGeneratorConfig config, StringBuilder sw, bool root)
    {
        _ = sw.AppendLine();
        _ = sw.AppendFormat("package {0};", root && !config.UseNestedClasses ? config.Namespace : (config.SecondaryNamespace ?? config.Namespace));
        _ = sw.AppendLine();
    }

    public void WriteNamespaceEnd(IJsonClassGeneratorConfig config, StringBuilder sw, bool root) => sw.AppendLine("}");

    public void WriteDeserializationComment(IJsonClassGeneratorConfig config, StringBuilder sw, bool rootIsArray = false)
    {
        _ = sw.AppendLine("// import com.fasterxml.jackson.databind.ObjectMapper; // version 2.11.1");
        _ = sw.AppendLine("// import com.fasterxml.jackson.annotation.JsonProperty; // version 2.11.1");
        _ = sw.AppendLine("/* ObjectMapper om = new ObjectMapper();");

        if (rootIsArray)
        {
            _ = sw.AppendLine("Root[] root = om.readValue(myJsonString, Root[].class); */");
        }
        else
        {
            _ = sw.AppendLine("Root root = om.readValue(myJsonString, Root.class); */");
        }
    }
}