#include <u.h>
#include <libn.h>

#include <zlib.h>

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

/* actual interfaces */
io·Reader     gz·FileReader     = (io·Reader){ gz·read };
io·Peeker     gz·FilePeeker     = (io·Peeker){ gz·getbyte, gz·ungetbyte };
io·FullReader gz·FullFileReader = (io·FullReader){ gz·read, gz·getbyte, gz·ungetbyte };

io·Writer     gz·FileWriter     = (io·Writer){ gz·write };
io·Putter     gz·FilePutter     = (io·Putter){ gz·putbyte, gz·putstring };
io·FullWriter gz·FullFileWriter = (io·FullWriter){ gz·write, gz·putbyte, gz·putstring };

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

// -----------------------------------------------------------------------
// functions implementations

gz·Stream*
gz·open(byte *path, byte *mode)
{
    return gzopen(path, mode);
}

error
gz·close(gz·Stream* s)
{
    return gzclose(s);
}

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

int
gz·readln(gz·Stream *s, int n, byte *buf)
{
    byte* b;
    b = gzgets(s, buf, n);

    return strlen(b);
}

byte
gz·getbyte(gz·Stream *s)
{
    // NOTE: Can't call macro
    byte b[2];
    gzread(s, b, 1);

    return b[0];
}

error
gz·ungetbyte(gz·Stream *s, byte c)
{
    return gzungetc(c, s);
}

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

error   
gz·putbyte(gz·Stream *s, byte c)
{
    return gzputc(s, c);
}

error   
gz·putstring(gz·Stream *s, byte *str)
{
    return gzputs(s, str);
}

int
gz·printf(gz·Stream *s, byte *fmt, ...)
{
    error err;

    va_list args;
    va_start(args, fmt);
    err = gzprintf(s, fmt, args);
    va_end(args);

    return err;
}

error
gz·flush(gz·Stream *s)
{
    return gzflush(s, Z_FINISH);
}

vlong
gz·seek(gz·Stream *s, long off, enum SeekPos whence)
{
    return gzseek(s, off, whence);
}