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

namespace CodePlay.CLI;

public class Program
{
    public static async Task<int> Main(string[] args)
    {
        // 定义源语言选项
        var sourceLanguageOption = new Option<LanguageType>(
            name: "--source-language",
            description: "源语言 (CSharp, Java, CPlusPlus)",
            parseArgument: result =>
            {
                var value = result.Tokens.Single().Value;
                if (Enum.TryParse<LanguageType>(value, true, out var language))
                {
                    return language;
                }
                result.ErrorMessage = $"Invalid language: {value}. Valid values are: CSharp, Java, CPlusPlus";
                return LanguageType.None;
            }
        );
        sourceLanguageOption.AddAlias("-s");
        sourceLanguageOption.IsRequired = true;
        
        // 定义目标语言选项
        var targetLanguageOption = new Option<LanguageType>(
            name: "--target-language",
            description: "目标语言 (CSharp, Java, CPlusPlus)",
            parseArgument: result =>
            {
                var value = result.Tokens.Single().Value;
                if (Enum.TryParse<LanguageType>(value, true, out var language))
                {
                    return language;
                }
                result.ErrorMessage = $"Invalid language: {value}. Valid values are: CSharp, Java, CPlusPlus";
                return LanguageType.None;
            }
        );
        targetLanguageOption.AddAlias("-t");
        targetLanguageOption.IsRequired = true;
        
        // 定义输入文件选项
        var inputOption = new Option<FileInfo>(
            name: "--input",
            description: "输入文件路径"
        );
        inputOption.AddAlias("-i");
        inputOption.IsRequired = true;
        
        // 定义输出文件选项
        var outputOption = new Option<FileInfo>(
            name: "--output",
            description: "输出文件路径"
        );
        outputOption.AddAlias("-o");
        
        // 定义验证轮次选项
        var validationRoundsOption = new Option<int>(
            name: "--validation-rounds",
            getDefaultValue: () => 2,
            description: "验证轮次 (1-3)"
        );
        validationRoundsOption.AddAlias("-v");
        
        // 定义配置文件选项
        var configOption = new Option<FileInfo>(
            name: "--config",
            description: "配置文件路径"
        );
        configOption.AddAlias("-c");
        
        // 定义转换命令
        var convertCommand = new Command("convert", "转换代码文件")
        {
            sourceLanguageOption,
            targetLanguageOption,
            inputOption,
            outputOption,
            validationRoundsOption,
            configOption
        };
        
        convertCommand.SetHandler(async (context) =>
        {
            var sourceLang = context.ParseResult.GetValueForOption(sourceLanguageOption);
            var targetLang = context.ParseResult.GetValueForOption(targetLanguageOption);
            var inputFile = context.ParseResult.GetValueForOption(inputOption);
            var outputFile = context.ParseResult.GetValueForOption(outputOption);
            var validationRounds = context.ParseResult.GetValueForOption(validationRoundsOption);
            var configFile = context.ParseResult.GetValueForOption(configOption);
            
            try
            {
                // 读取输入文件
                Console.WriteLine($"正在读取文件：{inputFile.FullName}");
                var sourceCode = await File.ReadAllTextAsync(inputFile.FullName);
                
                // 加载配置（如果有）
                ConversionOptions? options = null;
                if (configFile != null && configFile.Exists)
                {
                    options = LoadConfiguration(configFile.FullName);
                }
                
                // 创建转换请求
                var request = new ConversionRequest
                {
                    SourceCode = sourceCode,
                    SourceLanguage = sourceLang,
                    TargetLanguage = targetLang,
                    ValidationRounds = validationRounds,
                    Options = options
                };
                
                // 执行转换
                Console.WriteLine($"正在转换：{sourceLang} → {targetLang}");
                var conversionService = new ConversionService();
                var result = await conversionService.ConvertAsync(request);
                
                if (result.Success)
                {
                    Console.WriteLine($"转换成功!");
                    Console.WriteLine($"转换行数：{result.Report?.LinesConverted}");
                    Console.WriteLine($"转换类数：{result.Report?.ClassesConverted}");
                    Console.WriteLine($"转换方法数：{result.Report?.MethodsConverted}");
                    
                    // 输出结果
                    if (outputFile != null)
                    {
                        await File.WriteAllTextAsync(outputFile.FullName, result.TransformedCode);
                        Console.WriteLine($"已输出到：{outputFile.FullName}");
                    }
                    else
                    {
                        Console.WriteLine("\n==== 转换结果 ====");
                        Console.WriteLine(result.TransformedCode);
                    }
                    
                    // 显示 TODO 和问题
                    if (result.Report?.TodoItems.Count > 0)
                    {
                        Console.WriteLine("\n⚠️  需要注意的 TODO 项:");
                        foreach (var todo in result.Report.TodoItems)
                        {
                            Console.WriteLine($"  - {todo.Description}");
                            Console.WriteLine($"    原因：{todo.WhyNotDirect}");
                            Console.WriteLine($"    建议：{todo.RecommendedAlternative}");
                        }
                    }
                    
                    if (result.Report?.Issues.Count > 0)
                    {
                        Console.WriteLine("\n⚠️  需要注意的问题:");
                        foreach (var issue in result.Report.Issues)
                        {
                            Console.WriteLine($"  - {issue.Description}");
                            Console.WriteLine($"    建议：{issue.Suggestion}");
                        }
                    }
                    
                    context.ExitCode = 0;
                }
                else
                {
                    Console.WriteLine($"❌ 转换失败：{result.ErrorMessage}");
                    context.ExitCode = 1;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"❌ 错误：{ex.Message}");
                context.ExitCode = 1;
            }
        });
        
        // 定义 list 命令
        var listCommand = new Command("list", "列出支持的转换");
        listCommand.SetHandler((context) =>
        {
            var conversionService = new ConversionService();
            var supported = conversionService.GetSupportedConversions();
            
            Console.WriteLine("支持的转换:");
            foreach (var (source, target) in supported)
            {
                Console.WriteLine($"  {source} → {target}");
            }
            
            context.ExitCode = 0;
        });
        
        // 定义 check 命令
        var checkCommand = new Command("check", "检查是否支持指定的转换")
        {
            sourceLanguageOption,
            targetLanguageOption
        };
        checkCommand.SetHandler((context) =>
        {
            var sourceLang = context.ParseResult.GetValueForOption(sourceLanguageOption);
            var targetLang = context.ParseResult.GetValueForOption(targetLanguageOption);
            
            var conversionService = new ConversionService();
            var isSupported = conversionService.IsConversionSupported(sourceLang, targetLang);
            
            if (isSupported)
            {
                Console.WriteLine($"✅ 支持 {sourceLang} → {targetLang} 转换");
                context.ExitCode = 0;
            }
            else
            {
                Console.WriteLine($"❌ 不支持 {sourceLang} → {targetLang} 转换");
                context.ExitCode = 1;
            }
        });
        
        // 创建根命令
        var rootCommand = new RootCommand("CodePlay 代码转换工具 - 支持 C#、Java、C++ 之间的代码转换")
        {
            convertCommand,
            listCommand,
            checkCommand
        };
        
        // 配置并运行解析器
        var parser = new CommandLineBuilder(rootCommand)
            .UseDefaults()
            .Build();
        
        return await parser.InvokeAsync(args);
    }
    
    private static ConversionOptions? LoadConfiguration(string configFile)
    {
        try
        {
            if (configFile.EndsWith(".json"))
            {
                // 这里可以添加 JSON 配置加载逻辑
                // MVP 版本简化处理
                return new ConversionOptions
                {
                    KeepComments = true,
                    KeepDocStrings = true
                };
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"⚠️  加载配置文件失败：{ex.Message}，使用默认配置");
        }
        return null;
    }
}