const std = @import("std");
const parser = @import("../../src/parser.zig");
const types = @import("../../src/types.zig");

test "parseArgs - basic keyword" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "sleep"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("sleep", config.keyword);
    try std.testing.expect(config.target_sections == null);
    try std.testing.expect(!config.show_paths);
    try std.testing.expect(!config.verbose);
}

test "parseArgs - with verbose flag" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-v", "ls"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("ls", config.keyword);
    try std.testing.expect(config.verbose);
}

test "parseArgs - with long verbose flag" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "--verbose", "ls"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("ls", config.keyword);
    try std.testing.expect(config.verbose);
}

test "parseArgs - with paths flag" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "--paths", "printf"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("printf", config.keyword);
    try std.testing.expect(config.show_paths);
}

test "parseArgs - with section flag short" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-s", "1", "ls"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("ls", config.keyword);
    try std.testing.expect(config.target_sections != null);
    try std.testing.expectEqual(@as(usize, 1), config.target_sections.?.len);
    try std.testing.expectEqualStrings("1", config.target_sections.?[0]);
}

test "parseArgs - with section flag long" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "--section", "3", "printf"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("printf", config.keyword);
    try std.testing.expect(config.target_sections != null);
    try std.testing.expectEqualStrings("3", config.target_sections.?[0]);
}

test "parseArgs - with multiple sections" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-s", "1", "-s", "3", "test"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("test", config.keyword);
    try std.testing.expect(config.target_sections != null);
    try std.testing.expectEqual(@as(usize, 2), config.target_sections.?.len);
    try std.testing.expectEqualStrings("1", config.target_sections.?[0]);
    try std.testing.expectEqualStrings("3", config.target_sections.?[1]);
}

test "parseArgs - with section and verbose" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-v", "-s", "3ssl", "ssl"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("ssl", config.keyword);
    try std.testing.expect(config.verbose);
    try std.testing.expectEqualStrings("3ssl", config.target_sections.?[0]);
}

test "parseArgs - error no keyword" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere"};
    const result = parser.parseArgs(allocator, args);
    
    try std.testing.expectError(error.NoKeyword, result);
}

test "parseArgs - error invalid option" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "--invalid", "ls"};
    const result = parser.parseArgs(allocator, args);
    
    try std.testing.expectError(error.InvalidOption, result);
}

test "parseArgs - error section without value" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-s"};
    const result = parser.parseArgs(allocator, args);
    
    try std.testing.expectError(error.InvalidOption, result);
}

test "parseArgs - error invalid section letter" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-s", "abc", "ls"};
    const result = parser.parseArgs(allocator, args);
    
    try std.testing.expectError(error.InvalidSection, result);
}

test "parseArgs - error section zero" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-s", "0", "ls"};
    const result = parser.parseArgs(allocator, args);
    
    try std.testing.expectError(error.InvalidSection, result);
}

test "parseArgs - error multiple keywords" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "ls", "cat"};
    const result = parser.parseArgs(allocator, args);
    
    try std.testing.expectError(error.MultipleKeywords, result);
}

test "parseArgs - complex combination" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const args = &[_][:0]u8{"manwhere", "-v", "--paths", "-s", "1", "-s", "8", "admin"};
    const config = try parser.parseArgs(allocator, args);
    
    try std.testing.expectEqualStrings("admin", config.keyword);
    try std.testing.expect(config.verbose);
    try std.testing.expect(config.show_paths);
    try std.testing.expectEqual(@as(usize, 2), config.target_sections.?.len);
}

test "HELP_TEXT - contains usage info" {
    try std.testing.expect(std.mem.indexOf(u8, parser.HELP_TEXT, "Usage:") != null);
    try std.testing.expect(std.mem.indexOf(u8, parser.HELP_TEXT, "OPTIONS:") != null);
    try std.testing.expect(std.mem.indexOf(u8, parser.HELP_TEXT, "EXAMPLES:") != null);
    try std.testing.expect(std.mem.indexOf(u8, parser.HELP_TEXT, "--verbose") != null);
    try std.testing.expect(std.mem.indexOf(u8, parser.HELP_TEXT, "--section") != null);
}