use tui_generator_cli::parser::{HelpParser, Argument, CommandInfo};

#[test]
fn test_extract_description_basic() {
    let help = "A test command description\n\nUsage:\n  test [OPTIONS]";
    let desc = HelpParser::extract_description(help);
    assert_eq!(desc, "A test command description");
}

#[test]
fn test_extract_description_empty() {
    let help = "";
    let desc = HelpParser::extract_description(help);
    assert_eq!(desc, "");
}

#[test]
fn test_extract_version() {
    let help = "Some tool\nVersion: 1.2.3\n\nOptions:";
    let version = HelpParser::extract_version(help);
    assert_eq!(version, Some("1.2.3".to_string()));
}

#[test]
fn test_extract_version_case_insensitive() {
    let help = "Tool\nversion 2.0.0\n";
    let version = HelpParser::extract_version(help);
    assert_eq!(version, Some("2.0.0".to_string()));
}

#[test]
fn test_extract_version_not_found() {
    let help = "Tool without version\n";
    let version = HelpParser::extract_version(help);
    assert_eq!(version, None);
}

#[test]
fn test_extract_arguments_basic() {
    let help = r#"Usage: test [OPTIONS]

Options:
  -v, --verbose    Enable verbose output
  -o, --output FILE  Write to file"#;
    let args = HelpParser::extract_arguments(help);
    assert!(args.len() >= 1);
}

#[test]
fn test_extract_arguments_with_required() {
    let help = r#"Options:
  --required ARG    A required argument (required)
  --optional ARG    An optional argument"#;
    let args = HelpParser::extract_arguments(help);
    if !args.is_empty() {
        assert!(args.iter().any(|a| a.required));
    }
}

#[test]
fn test_extract_subcommands() {
    let help = r#"Commands:
  init    Initialize a new project
  build   Build the project
  deploy  Deploy to production"#;
    let subcommands = HelpParser::extract_subcommands(help);
    assert!(!subcommands.is_empty());
    assert!(subcommands.iter().any(|s| s.name == "init"));
    assert!(subcommands.iter().any(|s| s.name == "build"));
}

#[test]
fn test_extract_examples() {
    let help = r#"Examples:
  $ test -v
  $ test --output file.txt"#;
    let examples = HelpParser::extract_examples(help);
    assert_eq!(examples.len(), 2);
    assert!(examples[0].contains("-v"));
    assert!(examples[1].contains("--output"));
}

#[test]
fn test_argument_default_value() {
    let help = r#"Options:
  --port PORT    Port to listen on (default: 8080)"#;
    let args = HelpParser::extract_arguments(help);
    if !args.is_empty() {
        let arg = &args[0];
        assert_eq!(arg.default_value, Some("8080".to_string()));
    }
}

#[test]
fn test_argument_possible_values() {
    let help = r#"Options:
  --format FORMAT    Output format (choices: json, yaml, xml)"#;
    let args = HelpParser::extract_arguments(help);
    if !args.is_empty() {
        let arg = &args[0];
        assert!(!arg.possible_values.is_empty());
    }
}

#[test]
fn test_command_info_structure() {
    let info = CommandInfo {
        name: "test".to_string(),
        description: "Test command".to_string(),
        version: Some("1.0.0".to_string()),
        arguments: vec![Argument {
            name: "verbose".to_string(),
            short: Some('v'),
            long: Some("verbose".to_string()),
            description: "Verbose output".to_string(),
            required: false,
            takes_value: false,
            default_value: None,
            possible_values: Vec::new(),
        }],
        subcommands: Vec::new(),
        examples: vec!["test -v".to_string()],
        environment_variables: Vec::new(),
    };

    assert_eq!(info.name, "test");
    assert_eq!(info.arguments.len(), 1);
    assert_eq!(info.examples.len(), 1);
}