// Advanced C concepts showcased:
- Variadic functions (va_list, va_start, va_arg, va_end)
- Function pointers and callback patterns
- Recursive algorithms for number conversion
- Bit manipulation for hexadecimal output
- String parsing and state machines
- Memory-efficient buffer management

int ft_printf(const char *format, ...)
{
    va_list args;           // Variable argument list
    int chars_printed = 0;  // Return value tracking
    
    va_start(args, format); // Initialize argument traversal
    
    while (*format) {
        if (*format == '%') {
            // Parse format specifier and dispatch to handler
            chars_printed += ft_formats(args, *(++format));
        } else {
            // Regular character output
            chars_printed += ft_putchar(*format);
        }
        format++;
    }
    
    va_end(args); // Cleanup
    return chars_printed;
}

int ft_formats(va_list args, const char format)
{
    // Function pointer approach for extensibility
    switch (format) {
        case 'c': return ft_putchar(va_arg(args, int));
        case 's': return ft_print_str(va_arg(args, char *));
        case 'p': return ft_print_ptr(va_arg(args, unsigned long long));
        case 'd':
        case 'i': return ft_print_nbr(va_arg(args, int));
        case 'u': return ft_print_unsigned(va_arg(args, unsigned int));
        case 'x':
        case 'X': return ft_print_hex(va_arg(args, unsigned int), format);
        case '%': return ft_print_percent();
    }
    return 0;
}

#include "ft_printf.h"

int main(void)
{
    int count;
    
    // Character and string output
    ft_printf("Character: %c\n", 'A');
    ft_printf("String: %s\n", "Hello, World!");
    
    // Numeric output
    ft_printf("Integer: %d\n", -42);
    ft_printf("Unsigned: %u\n", 42U);
    
    // Hexadecimal output
    ft_printf("Hex (lower): %x\n", 255);
    ft_printf("Hex (upper): %X\n", 255);
    
    // Pointer output
    int value = 42;
    ft_printf("Pointer: %p\n", &value);
    
    // Return value usage
    count = ft_printf("Printed characters: ");
    ft_printf("%d\n", count);
    
    return 0;
}

void debug_log(const char *function, int line, const char *message)
{
    ft_printf("[DEBUG] %s:%d - %s\n", function, line, message);
}

void error_log(int error_code, const char *details)
{
    ft_printf("[ERROR %d] %s\n", error_code, details);
}

void print_user_data(int id, char *name, unsigned int age)
{
    ft_printf("User{id:%d, name:'%s', age:%u}\n", id, name, age);
}

void print_memory_dump(void *ptr, unsigned int size)
{
    ft_printf("Memory at %p (%u bytes):\n", ptr, size);
    // Additional hex dump logic...
}

void print_config(void)
{
    ft_printf("Configuration:\n");
    ft_printf("  Debug mode: %s\n", DEBUG ? "enabled" : "disabled");
    ft_printf("  Buffer size: %u bytes\n", BUFFER_SIZE);
    ft_printf("  Log level: %d\n", LOG_LEVEL);
}

// test_ft_printf.c - Professional testing approach
#include "ft_printf.h"
#include <stdio.h>
#include <string.h>

void test_basic_formats(void)
{
    printf("=== Basic Format Testing ===\n");
    
    // Character tests
    printf("System: "); printf("'%c'\n", 'A');
    printf("Custom: "); ft_printf("'%c'\n", 'A');
    
    // String tests
    printf("System: "); printf("'%s'\n", "Hello");
    printf("Custom: "); ft_printf("'%s'\n", "Hello");
    
    // Integer tests
    printf("System: "); printf("%d, %d\n", 42, -42);
    printf("Custom: "); ft_printf("%d, %d\n", 42, -42);
}

void test_edge_cases(void)
{
    printf("=== Edge Case Testing ===\n");
    
    // Null pointer handling
    char *null_str = NULL;
    printf("System: "); printf("'%s'\n", null_str);
    printf("Custom: "); ft_printf("'%s'\n", null_str);
    
    // Integer limits
    printf("System: "); printf("%d\n", INT_MAX);
    printf("Custom: "); ft_printf("%d\n", INT_MAX);
}

int main(void)
{
    test_basic_formats();
    test_edge_cases();
    return 0;
}

#include <time.h>

void performance_test(void)
{
    clock_t start, end;
    int iterations = 100000;
    
    // Test ft_printf performance
    start = clock();
    for (int i = 0; i < iterations; i++)
        ft_printf("Test %d: %s %x\n", i, "performance", i);
    end = clock();
    
    double ft_time = ((double)(end - start)) / CLOCKS_PER_SEC;
    ft_printf("ft_printf: %.4f seconds\n", ft_time);
}

// Microcontroller debugging
void mcu_debug(uint32_t register_val, uint16_t status)
{
    ft_printf("MCU: REG=0x%X, STATUS=0x%x\n", register_val, status);
}

// Network packet logging
void log_packet(uint32_t src_ip, uint16_t port, size_t size)
{
    ft_printf("PKT: %u.%u.%u.%u:%u (%u bytes)\n", 
              (src_ip >> 24) & 0xFF, (src_ip >> 16) & 0xFF,
              (src_ip >> 8) & 0xFF, src_ip & 0xFF, port, size);
}

// Process monitoring
void log_process(int pid, const char *name, unsigned long memory)
{
    ft_printf("PROC: PID=%d NAME='%s' MEM=%u KB\n", pid, name, memory);
}

// Game state debugging
void debug_player(int x, int y, unsigned int health, unsigned int score)
{
    ft_printf("PLAYER: pos=(%d,%d) hp=%u score=%u\n", x, y, health, score);
}