using System.CommandLine;
using System.CommandLine.Builder;
using System.CommandLine.Parsing;
using CodePlay.Core.Common;
using CodePlay.Core.Models;
using CodePlay.Core.Services;
using CodePlay.Core.Converters;
using CodePlay.Core.Parsers;

namespace CodePlay.CLI;

public class Program
{
    public static async Task<int> Main(string[] args)
    {
        Console.WriteLine("CodePlay CLI - Code Conversion Tool");
        Console.WriteLine("Version 1.0.0");
        Console.WriteLine();
        
        var sourceOption = new Option<string>(["-s", "--source"], "Source language (CSharp, Java)");
        var targetOption = new Option<string>(["-t", "--target"], "Target language (CSharp, Java)");
        var inputOption = new Option<string>(["-i", "--input"], "Input file path");
        var outputOption = new Option<string>(["-o", "--output"], "Output file path");
        var verboseOption = new Option<bool>(["-v", "--verbose"], "Verbose output");
        
        var rootCommand = new RootCommand("CodePlay - Convert code between languages");
        rootCommand.AddOption(sourceOption);
        rootCommand.AddOption(targetOption);
        rootCommand.AddOption(inputOption);
        rootCommand.AddOption(outputOption);
        rootCommand.AddOption(verboseOption);
        
        rootCommand.SetHandler(async (context) =>
        {
            var source = context.ParseResult.GetValueForOption(sourceOption);
            var target = context.ParseResult.GetValueForOption(targetOption);
            var input = context.ParseResult.GetValueForOption(inputOption);
            var output = context.ParseResult.GetValueForOption(outputOption);
            var verbose = context.ParseResult.GetValueForOption(verboseOption);
            
            if (string.IsNullOrEmpty(input))
            {
                Console.WriteLine("Error: Input file is required");
                context.ExitCode = 1;
                return;
            }
            
            try
            {
                Console.WriteLine($"Converting: {input}");
                Console.WriteLine($"From: {source} To: {target}");
                
                var sourceCode = await File.ReadAllTextAsync(input);
                var converter = new CSharpToJavaConverter();
                var parser = new CSharpParser();
                
                var tree = await parser.ParseAsync(sourceCode);
                
                LanguageType targetLang = LanguageType.Java;
                if (!Enum.TryParse(target, true, out targetLang))
                {
                    targetLang = LanguageType.Java;
                }
                
                var result = await converter.ConvertAsync(tree, targetLang);
                
                if (result.Success)
                {
                    Console.WriteLine("Conversion successful!");
                    var lines = result.TransformedCode?.Split('\n') ?? Array.Empty<string>();
                    Console.WriteLine($"Lines: {lines.Length}");
                    
                    if (!string.IsNullOrEmpty(output))
                    {
                        await File.WriteAllTextAsync(output, result.TransformedCode);
                        Console.WriteLine($"Output: {output}");
                    }
                    else if (verbose)
                    {
                        Console.WriteLine("\n==== Result ====");
                        Console.WriteLine(result.TransformedCode);
                    }
                    
                    context.ExitCode = 0;
                }
                else
                {
                    Console.WriteLine($"Conversion failed: {result.ErrorMessage}");
                    context.ExitCode = 1;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
                if (verbose)
                {
                    Console.WriteLine($"Details: {ex}");
                }
                context.ExitCode = 1;
            }
        });
        
        var parser2 = new CommandLineBuilder(rootCommand)
            .UseDefaults()
            .Build();
        
        return await parser2.InvokeAsync(args);
    }
}