using System.CommandLine;

using System.CommandLine.Invocation;

using JavaToCSharp;

using Microsoft.Extensions.Logging;

namespace JavaToCSharpCli;

/// <summary>

/// The main JavaToCSharpCli program class.

/// </summary>

public class Program

{

private static readonly ILoggerFactory _loggerFactory;

private static readonly ILogger _logger;

private static readonly Option<bool> _includeUsingsOption = new(

name: "--include-usings",

description: "Include using directives in output",

getDefaultValue: () => true);

private static readonly Option<bool> _includeNamespaceOption = new(

name: "--include-namespace",

description: "Include namespace in output",

getDefaultValue: () => true);

private static readonly Option<bool> _includeCommentsOption = new(

name: "--include-comments",

description: "Include comments in output",

getDefaultValue: () => true);

private static readonly Option<bool> _useDebugAssertOption = new(

name: "--use-debug-assert",

description: "Use Debug.Assert for asserts",

getDefaultValue: () => false);

private static readonly Option<bool> _startInterfaceNamesWithIOption = new(

name: "--start-interface-names-with-i",

description: "Prefix interface names with the letter I",

getDefaultValue: () => true);

private static readonly Option<bool> _commentUnrecognizedCodeOption = new(

name: "--comment-unrecognized-code",

description: "Include unrecognized code in output as commented-out code",

getDefaultValue: () => true);

private static readonly Option<bool> _systemOutToConsoleOption = new(

name: "--system-out-to-console",

description: "Convert System.out calls to Console",

getDefaultValue: () => false);

private static readonly Option<bool> _clearDefaultUsingsOption = new(

name: "--clear-usings",

description: "Remove all default usings provided by this app",

getDefaultValue: () => false);

private static readonly Option<List<string>> _addUsingsOption = new(

name: "--add-using",

description: "Adds a using directive to the collection of usings")

{

ArgumentHelpName = "namespace"

};

static Program()

{

_loggerFactory = LoggerFactory.Create(builder =>

builder.AddSimpleConsole().SetMinimumLevel(LogLevel.Information));

_logger = _loggerFactory.CreateLogger<Program>();

}

public static async Task Main(string[] args)

{

var rootCommand = new RootCommand("Java to C# Converter")

{

Description = "A syntactic transformer of source code from Java to C#."

};

rootCommand.AddCommand(CreateFileCommand());

rootCommand.AddCommand(CreateDirectoryCommand());

rootCommand.AddGlobalOption(_includeUsingsOption);

rootCommand.AddGlobalOption(_includeNamespaceOption);

rootCommand.AddGlobalOption(_includeCommentsOption);

rootCommand.AddGlobalOption(_useDebugAssertOption);

rootCommand.AddGlobalOption(_startInterfaceNamesWithIOption);

rootCommand.AddGlobalOption(_commentUnrecognizedCodeOption);

rootCommand.AddGlobalOption(_systemOutToConsoleOption);

rootCommand.AddGlobalOption(_clearDefaultUsingsOption);

rootCommand.AddGlobalOption(_addUsingsOption);

await rootCommand.InvokeAsync(args);

// flush logs

_loggerFactory.Dispose();

}

private static Command CreateFileCommand()

{

var inputArgument = new Argument<FileInfo>(

name: "input",

description: "A Java source code file to convert");

var outputArgument = new Argument<FileInfo?>(

name: "output",

description: "Path to place the C# output file, or stdout if omitted",

getDefaultValue: () => null);

var fileCommand = new Command("file", "Convert a Java file to C#");

fileCommand.AddArgument(inputArgument);

fileCommand.AddArgument(outputArgument);

fileCommand.SetHandler(context =>

{

var input = context.ParseResult.GetValueForArgument(inputArgument);

var output = context.ParseResult.GetValueForArgument(outputArgument);

var options = GetJavaConversionOptions(context);

ConvertToCSharpFile(input, output, options);

});

return fileCommand;

}

private static JavaConversionOptions GetJavaConversionOptions(InvocationContext context)

{

var options = new JavaConversionOptions

{

IncludeUsings = context.ParseResult.GetValueForOption(_includeUsingsOption),

IncludeComments = context.ParseResult.GetValueForOption(_includeCommentsOption),

IncludeNamespace = context.ParseResult.GetValueForOption(_includeNamespaceOption),

ConvertSystemOutToConsole = context.ParseResult.GetValueForOption(_systemOutToConsoleOption),

StartInterfaceNamesWithI = context.ParseResult.GetValueForOption(_startInterfaceNamesWithIOption),

UseDebugAssertForAsserts = context.ParseResult.GetValueForOption(_useDebugAssertOption),

UseUnrecognizedCodeToComment = context.ParseResult.GetValueForOption(_commentUnrecognizedCodeOption)

};

if (context.ParseResult.GetValueForOption(_clearDefaultUsingsOption))

{

options.ClearUsings();

}

foreach (string ns in context.ParseResult.GetValueForOption(_addUsingsOption) ?? new List<string>())

{

options.AddUsing(ns);

}

return options;

}

private static Command CreateDirectoryCommand()

{

var inputArgument = new Argument<DirectoryInfo>(

name: "input",

description: "A directory containing Java source code files to convert");

var outputArgument = new Argument<DirectoryInfo>(

name: "output",

description: "Path to place the C# output files");

var dirCommand = new Command("dir", "Convert a directory containing Java files to C#");

dirCommand.AddArgument(inputArgument);

dirCommand.AddArgument(outputArgument);

dirCommand.SetHandler(context =>

{

var input = context.ParseResult.GetValueForArgument(inputArgument);

var output = context.ParseResult.GetValueForArgument(outputArgument);

var options = GetJavaConversionOptions(context);

ConvertToCSharpDir(input, output, options);

});

return dirCommand;

}

private static void ConvertToCSharpDir(DirectoryInfo inputDirectory, DirectoryInfo outputDirectory, JavaConversionOptions options)

{

if (inputDirectory.Exists)

{

foreach (var f in inputDirectory.GetFiles("*.java", SearchOption.AllDirectories))

{

string? directoryName = f.DirectoryName;

if (string.IsNullOrWhiteSpace(directoryName))

{

continue;

}

if (!outputDirectory.Exists)

{

outputDirectory.Create();

}

ConvertToCSharpFile(f,

new FileInfo(Path.Combine(outputDirectory.FullName, Path.ChangeExtension(f.Name, ".cs"))),

options,

false);

}

}

else

_logger.LogError("Java input folder {path} doesn't exist!", inputDirectory);

}

private static void ConvertToCSharpFile(FileSystemInfo inputFile, FileSystemInfo? outputFile, JavaConversionOptions options, bool overwrite = true)

{

if (!overwrite && outputFile is { Exists: true })

_logger.LogInformation("{outputFilePath} exists, skip to next.", outputFile);

else if (inputFile.Exists)

{

try

{

string javaText = File.ReadAllText(inputFile.FullName);

options.WarningEncountered += (_, eventArgs) =>

{

if (outputFile != null)

{

_logger.LogWarning("Line {JavaLineNumber}: {Message}", eventArgs.JavaLineNumber,

eventArgs.Message);

}

OutputFileOrPrint(outputFile != null ? Path.ChangeExtension(outputFile.FullName, ".warning") : null,

eventArgs.Message + Environment.NewLine);

};

string? parsed = JavaToCSharpConverter.ConvertText(javaText, options);

OutputFileOrPrint(outputFile?.FullName, parsed ?? string.Empty);

if (outputFile != null)

{

_logger.LogInformation("{filePath} converted!", inputFile.Name);

}

}

catch (Exception ex)

{

_logger.LogError("{filePath} failed! {type}: {message}", inputFile.Name, ex.GetType().Name, ex);

if (outputFile != null)

{

File.WriteAllText(Path.ChangeExtension(outputFile.FullName, ".error"), ex.ToString());

}

}

}

else

_logger.LogError("Java input file {filePath} doesn't exist!", inputFile.FullName);

}

private static void OutputFileOrPrint(string? fileName, string contents)

{

if (fileName == null)

{

Console.Out.WriteLine(contents);

}

else

{

File.WriteAllText(fileName, contents);

}

}

}