#include <unistd.h>
#include <stdarg.h>
#include <stdlib.h>

int printchar(char c){
    write(1, &c, 1);
    return 1;
}

int str_len(char * str){
    int counter = 0;
    while(str[counter] != '\0'){
        counter++;
    }
    
    return counter;
}

int printstring(char *str){
    int len  = 0;
    
	if (!str) {
		write(1, "(null)", 6);
		len = 6;
	}
    else {
        len = str_len(str);
        write(1, str, len);
    }
    return len;
}

int int_len(int a){

	int result = 0;
	int n = a;

	if (n == 0)
		return 1;

	if (n < 0)
		result++;

	while (n != 0){
		result++;
		n /= 10;
	}

	return result;
}

char* int_toa(int a){

	int num;
	int sign;
	int i_len;
	char* result;

	i_len = int_len(a);
	result = malloc((i_len + 1) * sizeof(char));
	sign = 1;
	num = a;

	if (!result)
		return NULL;

	if (num < 0)
		sign = -1;

	result[i_len] = '\0';

	while (--i_len >= 0){
		result[i_len] = (num % 10) * sign + '0';
		num /= 10;
	}

	if (sign == -1)
		result[0] = '-';

	return result;
}

int printdecimal(int n)
{
	char *number;
	int result;

	result = 0;
	number = int_toa(n);
	result = printstring(number);
	free(number);

	return (result);
}

int	uint_len(unsigned int n){

	int	count = 1;

	while (n > 9) {
		count++;
		n /= 10;
	}

	return count;
}

char    *uint_toa(unsigned int n)
{
	int n_len;
	char *result;

	n_len = uint_len(n);
	result = malloc((n_len + 1) * sizeof(char));
	if (!result)
		return (NULL);
	result[n_len] = '\0';
	while (--n_len >= 0)
	{
		result[n_len] = (n % 10) + '0';
		n /= 10;
	}
	return (result);
}

int printu(unsigned int n)
{
	char *number;
	int result = 0;
	
	number = uint_toa(n);
	printstring(number);
	result = str_len(number);
	free(number);
	return (result);
}

int uhex_len(unsigned long n)
{
	int count = 1;
	
	while (n > 15) {
		count++;
		n /= 16;
	}
	return count;
}

char *uhex_toa(unsigned long n, char base)
{
	int tmp;
	int n_len;
	char *result;

	n_len = uhex_len(n);
	result = (char *)malloc((n_len + 1) * sizeof(char));
	result[n_len] = '\0';
	while (--n_len >= 0)
	{
		tmp = (n % 16);
		if (tmp > 9)
			result[n_len] = base + tmp - 10;
		else
			result[n_len] = tmp + '0';
		n /= 16;
	}
	return (result);
}

int printhex(unsigned long n, char base)
{
	char *number;
	int	 result;

	result = 0;
	number = uhex_toa(n, base);
	printstring(number);
	result = str_len(number);
	free(number);
	return (result);
}

int printpointer(unsigned long n)
{
	char *number;
	int result;

	result = 0;
	if (!n)
	{
		write(1, "(nil)", 5);
		result = 5;
	}
	else
	{
		number = uhex_toa(n, 'a');
		printstring("0x");
		printstring(number);
		result = str_len(number) + 2;
		free(number);
	}
	return (result);
}


int	handle_flag(va_list args, char flag)
{
    if (flag == 'p')
		return (printpointer(va_arg(args, unsigned long)));
    if (flag == 'x')
		return (printhex(va_arg(args, unsigned long), 'a'));
	if (flag == 'X')
		return (printhex(va_arg(args, unsigned long), 'A'));
    if (flag == 'u')
		return (printu(va_arg(args, unsigned int)));
    if (flag == 'd' || flag == 'i')
        return (printdecimal(va_arg(args, int)));
	if (flag == 'c')
		return (printchar((char)va_arg(args, int)));
	if (flag == 's')
		return (printstring(va_arg(args, char *)));
	if (flag == '%')
		return (printchar('%'));
	return (0);
}

int myprintf(const char * str, ...){
    va_list args;
    int counter;
    
    va_start(args, str);
    counter = 0;
    while(*str != '\0'){
        if (*str == '%'){
            str++;
            counter += handle_flag(args, *str);
        }
        else {
            counter += printchar(*str);
        }
        str++;
    }
    va_end(args);
    
    return counter;
}

int main() {
  unsigned long a = 0;
  unsigned long b = 2147483647;
  unsigned long c = 2147483648;
  unsigned long d = 4294967295;


		
  myprintf("%p\n", a);
  myprintf("%p\n", b);
  myprintf("%p\n", c);
  myprintf("%p\n", d);
  
  myprintf("%p\n", &a);
  myprintf("%p\n", &b);
  myprintf("%p\n", &c);
  myprintf("%p\n", &d);
  return 0;
}