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

#include <time.h>
#include "kseq.h"

static
int
my_read(Stream *s, void *buf, int n)
{
    return io·read(s, 1, n, buf);
}

KSEQ_INIT(Stream*, my_read)

// -----------------------------------------------------------------------
// Point of entry for testing

error
test·newick()
{
    error err;
    bio·Tree t;
    mem·Arena *mem;
    Stream    *fd[2];

    io·Peeker     rdr;
    io·Putter     wtr;
    mem·Allocator al;

    mem = mem·newarena(mem·sys, nil);
    rdr = (io·Peeker){.get = &io·getbyte, .unget  = &io·ungetbyte};
    wtr = (io·Putter){.put = &io·putbyte, .putstr = &io·putstring};
    al  = (mem·Allocator) { .alloc = &mem·arenaalloc, .free = nil, };

    fd[0] = io·open("/home/nolln/root/data/test/example.nwk", "r");
    fd[1] = io·open("/home/nolln/root/data/test/example.proc.nwk", "w");

    t   = bio·readnewick(rdr, fd[0], al, mem);
    err = bio·writenewick(t, wtr, fd[1]);

    io·flush(fd[1]);

    io·close(fd[0]); 
    io·close(fd[1]);

    mem·freearena(mem);
    return 0;
}

error
test·fasta()
{
    error err;
    Stream           *fd;

    bio·Seq          seq;
    bio·FastaReader *rdr;

    clock_t t;

    fd  = io·open("/home/nolln/root/data/test/zika.fa", "r");

    /* Benchmark against Heng */
#if 0
    int  n, slen;
    kseq_t *kseq;

    t    = clock();
	kseq = kseq_init(fd);
	while (kseq_read(kseq) >= 0) {
		++n, slen += kseq->seq.l;
    }
    t = clock() - t;
    printf("heng's code took %f ms to execute\n", 1000.*t/CLOCKS_PER_SEC);

	kseq_destroy(kseq);

    io·seek(fd, 0, seek·set);
#endif

    rdr = bio·openfasta((io·Reader){.read = &io·read}, fd, mem·sys, nil);

    t = clock();
    err = 0;
    while (!err) {
        err = bio·readfasta(rdr, &seq);
    }
    t = clock() - t;
    printf("nick's code took %f ms to execute\n", 1000.*t/CLOCKS_PER_SEC);
    bio·closefasta(rdr);


    io·close(fd); 
    return err <= 0 ? 0 : 1;
}

error
test·fastq()
{
    error err;
    Stream           *fd;

    bio·Seq          seq;
    bio·FastqReader *rdr;

    clock_t t;

    int  n, slen;
    kseq_t *kseq;

    fd  = io·open("/home/nolln/root/data/test/eg.fq", "r");

    t    = clock();
	kseq = kseq_init(fd);
	while (kseq_read(kseq) >= 0) {
		++n, slen += kseq->seq.l;
    }
    t = clock() - t;
    printf("heng's fastq code took %f ms to execute\n", 1000.*t/CLOCKS_PER_SEC);

	kseq_destroy(kseq);

    io·seek(fd, 0, seek·set);

    rdr = bio·openfastq((io·Reader){.read = &io·read}, fd, mem·sys, nil);

    t = clock();
    err = 0;
    while (!err) {
        err = bio·readfastq(rdr, &seq);
    }
    t = clock() - t;
    printf("nick's fastq code took %f ms to execute\n", 1000.*t/CLOCKS_PER_SEC);
    bio·closefastq(rdr);


    io·close(fd); 
    return err <= 0 ? 0 : 1;
}

error
main()
{
    error err;
    if (err = test·newick(), err) {
        errorf("test fail: newick");
    }

    if (err = test·fasta(), err) {
        errorf("test fail: fasta");
    }

    if (err = test·fastq(), err) {
        errorf("test fail: fastq");
    }
}