#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/times.h>
#include <streamdevices.h>
#include <string.h>
#include <stdio.h>
#include <gpio.h>
#include <uart.h>
#include <stdint.h>

#undef errno



#ifdef __cplusplus
extern "C" {
#endif
extern int errno;
extern int32_t __max_opened_files__;
extern streamdevice* __opnfiles__[];
extern int32_t* __fs_root__;
extern int32_t __fs_root_size__;

char *__env[1] = { 0 };
char **environ = __env;

int _exit() 
{
    while(1);
}

int _close(int file) 
{
    if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
    {
        return __opnfiles__[file]->ops->close( __opnfiles__[file]);
    }
    return 0;
}


int _write(int file, char *ptr, int len) 
{	
    if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
    {
        if(__opnfiles__[file]->ops->write(__opnfiles__[file],ptr,1,len)) return len;
    }
    return 0;
}

int _execve(char *name, char **argv, char **env) {
    errno = ENOMEM;
    return -1;
}


int _fork(void) {
    errno = EAGAIN;
    return -1;
}

int _fstat(int file, struct stat *st) {
    st->st_mode = S_IFCHR;
    return 0;
}


int _getpid(void) {
    return 1;
}


int _isatty(int file) {
    return 1;
}


int _kill(int pid, int sig) {
    errno = EINVAL;
    return -1;
}


int _link(char *old, char *_new) {
    errno = EMLINK;
    return -1;
}


int _lseek(int file, int ptr, int dir) {
    return 0;
}

#include <gpio.h>

int _open(const char *name, int flags, int mode) 
{
    if(!strncmp("UART", name, 4) && ((name[4] & 0x30)==0x30))
    {
        //uart_t* uart1 = malloc(sizeof(uart_t));
        streamdevice* fd1 = malloc(sizeof(streamdevice));
        uart_t uart=uartopen((name[4] & 0xF)-1);
        if(uart!=-1);
        {
            uartmkstreamdev(uart,fd1);
            int i=2;
            while((i<__max_opened_files__) && (__opnfiles__[i]!=NULL))i++;
            if(i!=__max_opened_files__)
            {
                __opnfiles__[i] = fd1;
                return i;
            }
            else printf("Too much files opened\n\r");
        }
    }
    return -1;
}

int _read(int file, char *ptr, int len) {
    if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
    {
        if(__opnfiles__[file]->ops->read(__opnfiles__[file],ptr,1,len)) return len;
    }
    return 0;
}



caddr_t _sbrk(int incr) {
    register char * stack_ptr __asm__ ("sp");
    extern char _end; /* Defined by the linker */
    static char *heap_end;
    char *prev_heap_end;
    if (heap_end == 0) {
        heap_end = &_end;
    }
    prev_heap_end = heap_end;
    if (heap_end + incr > stack_ptr) {
        _write (1, "Heap and stack collision\n", 25);
        abort ();
    }
    heap_end += incr;
    return (caddr_t) prev_heap_end;
}



int _stat(char *file, struct stat *st) {
    st->st_mode = S_IFCHR;
    return 0;
}


int _times(struct tms *buf) {
    return -1;
}


int _unlink(char *name) {
    errno = ENOENT;
    return -1;
}

int _wait(int *status) {
    errno = ECHILD;
    return -1;
}


int _read_r (struct _reent *r, int file, char * ptr, int len)
{
    r = r;
    file = file;
    ptr = ptr;
    len = len;
    _read(file,ptr,len);
    errno = EINVAL;
    return -1;
}

/***************************************************************************/

int _lseek_r (struct _reent *r, int file, int ptr, int dir)
{
    r = r;
    file = file;
    ptr = ptr;
    dir = dir;

    return 0;
}

/***************************************************************************/

int _write_r (struct _reent *r, int file, char * ptr, int len)
{  
    return _write(file, ptr, len);
}

/***************************************************************************/

int _close_r (struct _reent *r, int file)
{
    return 0;
}

/***************************************************************************/

caddr_t _sbrk_r (struct _reent *r, int incr)
{
    register char * stack_ptr __asm__ ("sp");
    extern char _end; /* Defined by the linker */
    static char *heap_end;
    char *prev_heap_end;
    if (heap_end == 0) {
        heap_end = &_end;
    }
    prev_heap_end = heap_end;
    if (heap_end + incr > stack_ptr) {
        _write (1, "Heap and stack collision\n", 25);
        abort ();
    }
    heap_end += incr;
    return (caddr_t) prev_heap_end;
}

/***************************************************************************/

int _fstat_r (struct _reent *r, int file, struct stat * st)
{
    r = r;
    file = file;

    memset (st, 0, sizeof (* st));
    st->st_mode = S_IFCHR;
    return 0;
}

/***************************************************************************/
int _open_r(struct _reent *r,const char *name, int flags, int mode) 
{
    return _open(name, flags, mode);
}

int _isatty_r(struct _reent *r, int fd)
{
    r = r;
    fd = fd;

    return 1;
}


#ifdef __cplusplus
}
#endif