#include <u.h>
#include <base.h>

// -----------------------------------------------------------------------
// interface implementations

/* casting functions */
static 
int
·read(void *rdr, int size, int n, void *buf)
{
    return io·read((io·Stream *)rdr, size, n, buf);
}

static 
byte
·get(void *rdr)
{
    return io·getbyte((io·Stream *)rdr);
}

static 
error
·unget(void *rdr, byte c)
{
    return io·ungetbyte((io·Stream *)rdr, c);
}

static 
int
·write(void *wtr, int sz, int n, void *buf)
{
    return io·write((io·Stream *)wtr, sz, n, buf);
}

static 
error
·put(void *wtr, byte c)
{
    return io·putbyte((io·Stream *)wtr, c);
}

static
int
·puts(void *wtr, string s)
{
    return io·putstring((io·Stream *)wtr, s);
}

static
int
·seek(void *skr, long off, enum SeekPos whence)
{
    return io·seek((io·Stream *)skr, off, whence);
}

static
long
·tell(void *skr)
{
    return io·tell((io·Stream *)skr);
}

/* actual interfaces */
io·Reader     sys·Reader     = (io·Reader){ ·read };
io·Seeker     sys·Seeker     = (io·Seeker){ ·seek, ·tell };
io·Peeker     sys·Peeker     = (io·Peeker){ ·get, ·unget };
io·SeekReader sys·SeekReader = (io·SeekReader){ ·seek, ·tell, ·read };
io·PeekReader sys·PeekReader = (io·PeekReader){ ·read, ·get, ·unget };

io·Writer     sys·Writer     = (io·Writer){ ·write };
io·Putter     sys·Putter     = (io·Putter){ ·put, ·puts };
io·PutWriter  sys·PutWriter  = (io·PutWriter){ ·write, ·put, ·puts };

io·ReadWriter sys·ReadWriter = (io·ReadWriter){ ·read, ·write };

// -----------------------------------------------------------------------
// open/close

io·Stream*
io·open(byte *name, byte *mode)
{
    return fopen(name, mode);
}

int
io·fd(io·Stream *s)
{
    return fileno(s);
}

error
io·stat(io·Stream *s, io·Stat *buf)
{
    return fstat(fileno(s), buf);
}

error
io·close(io·Stream *s)
{
    return fclose(s);
}

// -----------------------------------------------------------------------
// reading

byte
io·getbyte(io·Stream *s)
{
    return fgetc(s);
}

error
io·ungetbyte(io·Stream *s, byte c)
{
    return ungetc(c, s);
}

int
io·read(io·Stream *s, int sz, int n, void *buf)
{
    return fread(buf, sz, n, s);
}

int
io·readln(io·Stream *s, int n, byte* buf)
{
    byte* b;
    b = fgets(buf, n+1, s);
    if(b == nil)
        return -1;

    return strlen(buf);
}

// -----------------------------------------------------------------------
// writing

error
io·putbyte(io·Stream *s, byte c)
{
    return fputc(c, s);
}

int
io·putstring(io·Stream *s, string str)
{
    return fputs(str, s);
}

int
io·write(io·Stream *s, int sz, int n, void *buf)
{
    return fwrite(buf, sz, n, s);
}

int
io·flush(io·Stream *s)
{
    return fflush(s);
}

// -----------------------------------------------------------------------
// seek

int
io·seek(io·Stream *s, long off, enum SeekPos origin)
{
    return fseek(s, off, origin);
}

long
io·tell(io·Stream *s)
{
    return ftell(s);
}