#include "../syscall/skeleton.h"

#include "../debug/kernelpanic.h"
#include "../debug/output.h"
#include "../device/textstream.h"
#include "../interrupt/guard.h"
#include "../sync/semaphore.h"
#include "../thread/scheduler.h"

void *operator new(size_t, void *);

#include "../user/app1/appl.h"
extern Application apps[];

namespace Syscall {
namespace Skeleton {
size_t test(Vault &vault, size_t p1, size_t p2, size_t p3, size_t p4,
			size_t p5) {
	(void)vault;
	vault.kout << "test(" << p1 << ", " << p2 << ", " << p3 << ", " << p4
			   << ", " << p5 << ");" << endl;
	return 0xdeadbeef;
}

int getpid(Vault &vault) {
	Thread *me = vault.scheduler.active();
	unsigned id = 0;
	while (&apps[id++] != me); // TODO find better pid source
    return id;
}

size_t write(Vault &vault, uint32_t id, const void *buffer, size_t size, int x, int y) {
    (void)id;

    TextStream* out;

    switch (id) {
        case 1:
            out = &vault.kout;
            break;
        case 2:
            out = &dout;
            break;
        default:
            out = &vault.kout;
    }

    int dummy;
    if(x == -1 && y != -1)
        out->getPos(x, dummy);
    if(x != -1 && y == -1)
        out->getPos(dummy, y);
    if(x == -1 && y == -1)
        out->getPos(x, y);

    out->setPos(x, y);

    for(size_t i = 0; i<size; i++)
        *out << ((char*)buffer)[i];
    out->flush();

    return 0;
}

size_t read(Vault &vault, uint32_t id, void *buf, size_t len) {
    (void)id;

    size_t read_cnt = 0;
    while(read_cnt <= len){
        Key key;
        vault.keys.consume(key);
        if(key.valid())
            ((char*)buf)[read_cnt++] = key.ascii();
        else
            return read_cnt;
    }
    return len;
}

void sleep(Vault &vault, size_t ms) {
	vault.bellringer.sleep(vault, ms);
}

bool sem_init(Vault &vault, size_t id, uint32_t value) {
  if (id >= vault.MAX_SEMS) {
    return false;             // out‐of‐range id
  }
  if (vault.sems[id].used==1){
    return false;  //already in use
  }

  vault.sems[id].counter=value;
	return true;
}

bool sem_destroy(Vault &vault, size_t id) {
  if (id >= vault.MAX_SEMS) {
    return false;             // out‐of‐range id
  }
  if (vault.sems[id].used==0){
    return false;  //already in free
  }

  vault.sems[id].used=0;
  vault.sems[id].counter=0;
	return true;
}

bool sem_signal(Vault &vault, size_t id) {
  vault.sems[id].v(vault);

  return true;
}

bool sem_wait(Vault &vault, size_t id) {
  vault.sems[id].p(vault);
  return true;
}

void exit(Vault &vault) {
    vault.scheduler.exit();
}

void kill(Vault &vault, size_t pid){
    vault.scheduler.kill(&apps[pid]);
}
}  // namespace Skeleton
}  // namespace Syscall