#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"
#include "../memory/pageframealloc.h"
void *operator new(size_t, void *);

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

uint8_t mapNumber = 0;

namespace Syscall {
namespace Skeleton {


void invlpg(uintptr_t virt_addr) {                                                                                                                                                           
  asm volatile("invlpg (%0)" : : "r" (virt_addr) : "memory");                                                                                                                                           
}   

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;
    return me->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_sem.p(vault);
        vault.keys.consume(key);
        if(key.valid())
            ((char*)buf)[read_cnt++] = key.ascii();
        else
            break;
    }
    return read_cnt;
}

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]);
}


void* map(Vault &vault, size_t size) { 
  int NumberOfPages = (1 + (size/4096));
  subtable  = (pagetable_t*)  PageFrameAllocator::alloc(false);

  for (int i=0; i < NumberOfPages-1; i++) {
      PageFrameAllocator::alloc(false);
  }

  for(uint8_t i=0; i<NumberOfPages; i++){
    subtable->entries[i] = {
      .present = 1,
      .user = 1,
      .address = ((uintptr_t)(0x6000+ mapNumber*0x10)) + i
    }
    memset((void*)((0x6000+(mapNumber*0x10)) >> 12) , 0, 4096);
    mapNumber++;
  }
  return subtable; 
}   


int unmap(Vault &vault, void* start, size_t size) {  
  int NumberOfPages = (1 + (size/4096));

//  for int i=0; i < NumberOfPages-1; i++ {
//      PageFrameAllocator::alloc(false);
//  }

  	for(uint8_t i=0; i<NumberOfPages; i++){
		subtable->entries[i] = {
			.present = 0,
			.user = 0,
			.address =(uintptr_t) start
		};
    memset(start, 0, 4096);
    invlpg(start);
    mapNumber++;

	}
  return 0; 



}



}  // namespace Skeleton
}  // namespace Syscall