/* Initializes the minisocket layer. */
void minisocket_initialize()
{
  int i;
  sock_array = (minisocket_t*)malloc(sizeof(struct minisocket)*NUM_SOCKETS);
  if (!sock_array) {
    return;
  }
  for (i = 0; i < NUM_SOCKETS; i++) {
    sock_array[i] = NULL;
  }
  client_lock = semaphore_create();
  if (!client_lock) {
    free(sock_array);
    return;
  }
  server_lock = semaphore_create();
  if (!server_lock) {
    free(sock_array);
    semaphore_destroy(client_lock);
    return;
  }
  semaphore_initialize(client_lock, 1);
  semaphore_initialize(server_lock, 1);
  network_get_my_address(my_addr);
  curr_client_idx = CLIENT_START;
  //printf("minisocket_initialize complete\n");
}

void vfs_init(void)
{
    int i;

    vfs_table.sem = semaphore_create(1);
    openfile_table.sem = semaphore_create(1);

    KERNEL_ASSERT(vfs_table.sem != NULL && openfile_table.sem != NULL);

    /* Clear table of mounted filesystems. */
    for(i=0; i<CONFIG_MAX_FILESYSTEMS; i++) {
        vfs_table.filesystems[i].filesystem = NULL;
    }

    /* Clear table of open files. */
    for (i = 0; i < CONFIG_MAX_OPEN_FILES; i++) {
        openfile_table.files[i].filesystem = NULL;
    }

    vfs_op_sem = semaphore_create(1);
    vfs_unmount_sem = semaphore_create(0);

    vfs_ops = 0;
    vfs_usable = 1;

    kprintf("VFS: Max filesystems: %d, Max open files: %d\n",
            CONFIG_MAX_FILESYSTEMS, CONFIG_MAX_OPEN_FILES);
}

BLOCKDEVICEP 
blockdevice_create(char *name, int blocksize, int numblocks)
{
	BLOCKDEVICEP devp ;
	int rc ;

	if (blocksize != REAL_BLOCK_LENGTH) {
		/*
		** For now we simplify things and just force
		** all blockdevices to have 1k block sizes.
		** We can fix this assumption up later.
		*/
		return NULL ;
	}

	if (strlen(name) >= BLOCK_DEV_MAX_NAME_LEN) {
		return NULL ;
	}

	devp = malloc(sizeof(BLOCKDEVICE)) ;

	if (NULL == devp) {
		return NULL ;
	}

	devp->name = malloc(strlen(name)+1) ;

	if (NULL == devp->name) {
		free(devp) ;
		return NULL ;
	}

	devp->sem = semaphore_create(1234, 0) ;
	devp->dirtysem = semaphore_create(1235, 0) ;

	/*if (! devp->sem) {
		free(devp) ;
		return NULL ;
	}*/

	strcpy(devp->name, name) ;
	devp->blocksize = blocksize ;
	devp->numblocks = numblocks ;
	devp->lastblockchecked = 0 ;

	rc = shmem_open() ;

	if (0 == rc) {
		semaphore_destroy(devp->sem, 1) ;
		free(devp->name) ;
		free(devp) ;
		return NULL ;
	}

	devp->bd = (struct SHMEM_BLOCK_OVERLAY *) shmem_get_memptr() ;

	initialize_block_dev_shmem(devp->bd, blocksize, numblocks, name) ;

	return devp ;
}

/* Performs any initialization of the miniroute layer, if required. */
void
miniroute_initialize()
{
    network_get_my_address(hostaddr);
    discovery_alarm = -1;

    intrpt_buffer = queue_new();
    intrpt_sig = semaphore_create();
    discovery_mutex = semaphore_create();
    discovery_sig = semaphore_create();

    route_cache = miniroute_cache_new(65536, SIZE_OF_ROUTE_CACHE, MINIROUTE_CACHED_ROUTE_EXPIRE);
    disc_cache = miniroute_cache_new(65536, SIZE_OF_ROUTE_CACHE, MINIROUTE_CACHED_ROUTE_EXPIRE * 10);

    if (NULL == intrpt_buffer || NULL == intrpt_sig || NULL == route_cache
            || NULL == discovery_mutex || NULL == discovery_sig) {
        queue_free(intrpt_buffer);
        semaphore_destroy(intrpt_sig);
        semaphore_destroy(discovery_mutex);
        semaphore_destroy(discovery_sig);
        miniroute_cache_destroy(route_cache);
        return;
    }

    semaphore_initialize(intrpt_sig, 0);
    semaphore_initialize(discovery_mutex, 1);
    semaphore_initialize(discovery_sig, 0);

    network_get_my_address(hostaddr);

    minithread_fork(miniroute_control, NULL);
}

/*
 * Initialization.
 *
 *      minithread_system_initialize:
 *       This procedure should be called from your C main procedure
 *       to turn a single threaded UNIX process into a multithreaded
 *       program.
 *
 *       Initialize any private data structures.
 *       Create the idle thread.
 *       Fork the thread which should call mainproc(mainarg)
 *       Start scheduling.
 *
 */
void
minithread_system_initialize(proc_t mainproc, arg_t mainarg) {
  minithread_t clean_up_thread = NULL;
  int a = 0;
  void* dummy_ptr = NULL;
  minithread_t tmp = NULL;
  tmp = NULL;
  dummy_ptr = (void*)&a;
  current_id = 0; // the next thread id to be assigned
  id_lock = semaphore_create();
  semaphore_initialize(id_lock,1); 
  runnable_q = multilevel_queue_new(4);
  blocked_q = queue_new();
  blocked_q_lock = semaphore_create();
  semaphore_initialize(blocked_q_lock,1);
  dead_q = queue_new();
  dead_q_lock = semaphore_create();
  semaphore_initialize(dead_q_lock,1);
  dead_sem = semaphore_create();
  semaphore_initialize(dead_sem,0);    
  runnable_q_lock = semaphore_create();
  semaphore_initialize(runnable_q_lock,1);
  clean_up_thread = minithread_create(clean_up, NULL);
  multilevel_queue_enqueue(runnable_q,
    clean_up_thread->priority,clean_up_thread);
  runnable_count++;
  minithread_clock_init(TIME_QUANTA, (interrupt_handler_t)clock_handler);
  init_alarm();
  current_thread = minithread_create(mainproc, mainarg);
  minithread_switch(&dummy_ptr, &(current_thread->stacktop));
  return;
}

/* performs any required initialization of the minimsg layer. */
void minimsg_initialize() {
	int i;

	msgmutex = semaphore_create();
    semaphore_initialize(msgmutex, 1);

    bound_ports_free = semaphore_create();
    semaphore_initialize(bound_ports_free, BOUND_MAX_PORT_NUM - BOUND_MIN_PORT_NUM + 1);

    // Initialize ports array
	ports = (miniport_t*) malloc((BOUND_MAX_PORT_NUM + 1) * sizeof(miniport_t));

	if (ports == NULL) { // Fail if malloc() fails
      fprintf(stderr, "ERROR: minimsg_initialize() failed to malloc miniport_t array\n");
      return;
    }

    // Initialize each unbound port's data elements
    for (i = UNBOUND_MIN_PORT_NUM; i <= UNBOUND_MAX_PORT_NUM; i++) {
    	miniport_create_unbound(i);
    	ports[i]->u.unbound.incoming_data = queue_new();
    	ports[i]->u.unbound.datagrams_ready = semaphore_create();
    	semaphore_initialize(ports[i]->u.unbound.datagrams_ready, 0);
    }
}

/*
 * Creates a socket 
 * The argument "port" is the port number of the created socket
 */
minisocket_t minisocket_create_socket(int port)
{
	minisocket_t newMinisocket;

	newMinisocket = (minisocket_t) malloc(sizeof(struct minisocket));

	if (newMinisocket == NULL)
		return NULL;

	//Initialize fields
	newMinisocket->port_number = port;
	newMinisocket->status = TCP_PORT_LISTENING;
	newMinisocket->seq_number = 0;
	newMinisocket->ack_number = 0;
	newMinisocket->data_buffer = NULL;
	newMinisocket->data_length = 0;
	newMinisocket->num_waiting_on_mutex = 0;
	newMinisocket->timeout = 100;

	newMinisocket->wait_for_ack_semaphore = semaphore_create();
	if (newMinisocket->wait_for_ack_semaphore == NULL)
	{
		free(newMinisocket);
		return NULL;
	}
	semaphore_initialize(newMinisocket->wait_for_ack_semaphore, 0);

	newMinisocket->mutex = semaphore_create();
	if (newMinisocket->mutex == NULL)
	{
		free(newMinisocket->wait_for_ack_semaphore);
		free(newMinisocket);
		return NULL;
	}
	semaphore_initialize(newMinisocket->mutex, 1);

	newMinisocket->packet_ready = semaphore_create();
	if (newMinisocket->packet_ready == NULL)
	{
		free(newMinisocket->mutex);
		free(newMinisocket->wait_for_ack_semaphore);
		free(newMinisocket);
		return NULL;
	}
	semaphore_initialize(newMinisocket->packet_ready, 0);

	newMinisocket->waiting_packets = queue_new();
	if (newMinisocket->waiting_packets == NULL)
	{
		free(newMinisocket->packet_ready);
		free(newMinisocket->mutex);
		free(newMinisocket->wait_for_ack_semaphore);
		free(newMinisocket);
		return NULL;
	}

	return newMinisocket;
}

int
main(int argc, char *argv[]) {
  sem1 = semaphore_create();
  semaphore_initialize(sem1, 0);
  sem2 = semaphore_create();
  semaphore_initialize(sem2, 0);
  minithread_system_initialize(thread1, NULL);
  return -1;
}

/* This needs to:
 * -get a block from the in-memory blocks if possible
 * -otherwise pull block from disk
 * -increment blocks' num_open counter
 * -we do NOT need to save the num_open update to disk, as it is reset after a 
 *  crash anyway.
 * 
 * Clients must ALWAYS check the return ID, in case a file was deleted.
 */
block_t _retrieve_block(int block_id)
{
	block_t block;
	minifile_t inode;
	int ret;
// todo - handle semaphores for inodes, destroy the in inode delete
	// First check if it's already in memory

	if (block_id < 0)
		return NULL;

	block = hashmap_get(retrieved_blocks, block_id);

	if (block != NULL && block->is_deleted == 0)
	{
		if ( block->block_type == BLOCK_TYPE_FILE
			|| block->block_type == BLOCK_TYPE_DIRECTORY)
		{
			block->num_open++;
			inode = (minifile_t) block;
			inode->u.data.mutex = semaphore_create();
			semaphore_initialize(inode->u.data.mutex, 1);
		}

		return block;
	}

	// Otherwise, get it from disk
	block = (block_t) malloc(sizeof(struct block));

	ret = _perform_full_disk_read(disk, block_id, (char*) block);

	// Setup the semaphore if it's an inode type

	// ONly check deleted for file/dir, as data blocks can have anything
	if (ret == 0 && !((block->block_type == BLOCK_TYPE_FILE || block->block_type == BLOCK_TYPE_DIRECTORY) && block->is_deleted == 1))
	{
		// Ensure num_open is set to just one, as we got it from disk (may have crashed with old data)
		hashmap_insert(retrieved_blocks, block_id, (void*) block);
		if ( block->block_type == BLOCK_TYPE_FILE
			|| block->block_type == BLOCK_TYPE_DIRECTORY)
		{
			inode = (minifile_t) block;
			inode->u.data.mutex = semaphore_create();
			semaphore_initialize(inode->u.data.mutex, 1);
			block->num_open = 1;
		}
		return block;
	}
	 else
	{
		return NULL;
	}
}

void
main(void) {
  int maxcount = MAXCOUNT;
  
  size = head = tail = 0;
  empty = semaphore_create();
  semaphore_initialize(empty, 0);
  full = semaphore_create();
  semaphore_initialize(full, BUFFER_SIZE);

  minithread_system_initialize(producer, &maxcount);
}

void command_move(struct cmdStruct* commandsList, int socket)  {

  char fifoBuffer[__BUFFER_SIZE];
  int descr[2];
  int stdoutDescr = dup(STDOUT_FILENO);
  int stdinDescr = dup(STDIN_FILENO);
  int stderrDescr = dup(STDERR_FILENO);
  int size = 0;
  int status;
  int cStream = pipe(descr);
  int childPid;
  int semIdIn = semaphore_create(commandsList->words[1], 1);           /* Utworzenie semaforow do zabezpieczenia przed wielokrotną edycją */
  int semIdOut = semaphore_create(commandsList->words[2], 1);

  P(semIdIn, 0);
  P(semIdOut, 0);

  childPid = fork();

  if (childPid == 0)  {
    dup2(descr[1], 2);                                               /* przekierowanie stderr do FIFO_OUT */
    dup2(descr[1], 1);                                               /* przekierowanie stdout do FIFO_OUT */
    close(descr[0]);
    execvp("/bin/mv", commandsList->words);
                                                                     /* jezeli nie uda sie wykonac komendy, zglasza komunikat o bledzie i przywraca wejscia */
    dup2(stdinDescr, 0);                                              /* przywrocenie poprzednich wejsc */
    dup2(stdoutDescr, 1);
    dup2(stderrDescr, 2);
    info_remote_handler(socket, __COMMAND_EXEC_ERROR);
  } else  {
      dup2(descr[0], 0);                                             /* przekierowanie stdin na FIFO_IN */
      close(descr[1]);
      while (1)  {
        memset(fifoBuffer, 0, __BUFFER_SIZE);
        size = read(descr[0], fifoBuffer, sizeof(fifoBuffer));
        status = write(socket, fifoBuffer, size);
        if (size == 0)  {
          close(descr[0]);
          dup2(stdinDescr, 0);                                        /* przywrocenie poprzednich wejsc */
          dup2(stdoutDescr, 1);
          dup2(stderrDescr, 2);
          break;
        }
      }
      wait(0);
      V(semIdOut, 0);
      V(semIdIn, 0);
      if (semaphore_value_lookup(semIdIn, 0)) semaphore_remove(semIdIn);
      if (semaphore_value_lookup(semIdOut, 0)) semaphore_remove(semIdOut);
  }

}

int
main(int argc, char * argv[]) {
  int maxcount = MAXCOUNT;
  
  size = head = tail = 0;
  empty = semaphore_create();
  semaphore_initialize(empty, 0);
  full = semaphore_create();
  semaphore_initialize(full, BUFFER_SIZE);

  minithread_system_initialize(producer, &maxcount);
  return -1;
}

int
main(void)
{
    pthread_t     pthread1, pthread2, pthread3;
    semaphore_t*   sem = g_sem;
    kern_return_t kr;

    setbuf(stdout, NULL);

    kr = semaphore_create(mach_task_self(), &sem[0], SYNC_POLICY_FIFO, 0);
    OUT_ON_MACH_ERROR("semaphore_create", kr);

    kr = semaphore_create(mach_task_self(), &sem[1], SYNC_POLICY_FIFO, 0);
    OUT_ON_MACH_ERROR("semaphore_create", kr);

    (void)pthread_create(&pthread1, (const pthread_attr_t *)0,
                         start_routine, (void *) 0);
    printf("created thread1=%lx\n", 0);

    (void)pthread_create(&pthread2, (const pthread_attr_t *)0,
                         start_routine, (void *) 1);
    printf("created thread2=%lx\n", 1);

    (void)pthread_create(&pthread3, (const pthread_attr_t *)0,
                         start_routine, (void *) 2);
    printf("created thread3=%lx\n", 2);

    // wait until all three threads are ready
    SEMAPHORE_WAIT(sem[1], 3);

//    printf("main: about to signal thread3\n");
//    semaphore_signal_thread(sem[0], pthread_mach_thread_np(pthread3));

    // wait for thread3 to sem_signal()
//    semaphore_wait(sem[1]);

    sleep(1);
    printf("main: about to signal all threads\n");
    semaphore_signal_all(sem[0]);

    // wait for thread1 and thread2 to sem_signal()
    SEMAPHORE_WAIT(sem[1], 3);

out:
    if (sem[0])
        semaphore_destroy(mach_task_self(), sem[0]);
    if (sem[1])
        semaphore_destroy(mach_task_self(), sem[1]);

    exit(kr);
}

status_t block_device_init_driver (void)
{
  int32_t i ;
  char alpha_num[8], semaphore_name_buffer[64], * semaphore_prefix = "block_device_" ;
  char isr_semaphore_name[64] ;
  
  watch (status_t)
  {
    block_device_controls = kernel_malloc (sizeof (block_device_control_t) * 
        SOCLIB_BLOCK_DEVICES_NDEV, true) ;
    ensure (block_device_controls != NULL, DNA_OUT_OF_MEM) ;
    

    for (i = 0 ; i < SOCLIB_BLOCK_DEVICES_NDEV ; i++)
    {
      dna_itoa (i, alpha_num) ;
      dna_strcpy (semaphore_name_buffer, semaphore_prefix) ;
      dna_strcat (semaphore_name_buffer, alpha_num) ;
      dna_strcat (semaphore_name_buffer, "_sem") ;

      semaphore_create (semaphore_name_buffer, 1, 
          &block_device_controls[i] . semaphore_id) ;

      block_device_controls[i] . should_enable_irq = 
        (bool) SOCLIB_BLOCK_DEVICES[i] . should_enable_irq ;
      block_device_controls[i] . port = 
        (block_device_register_map_t) SOCLIB_BLOCK_DEVICES[i] . base_address ;

      cpu_read (UINT32, 
          & (block_device_controls[i] . port -> BLOCK_DEVICE_SIZE), 
          block_device_controls[i] . block_count) ;
      cpu_read (UINT32, 
          & (block_device_controls[i] . port -> BLOCK_DEVICE_BLOCK_SIZE), 
          block_device_controls[i] . block_size) ;

      if (block_device_controls[i] . should_enable_irq) {
        block_device_controls[i] . irq = SOCLIB_BLOCK_DEVICES[i] . irq ;
        interrupt_attach (0, SOCLIB_BLOCK_DEVICES[i] . irq, 0x0, 
            block_device_isr, false) ;
        dna_strcpy (isr_semaphore_name, semaphore_name_buffer) ;
        dna_strcat (isr_semaphore_name, "_isr") ;
        semaphore_create (isr_semaphore_name, 0, 
            &block_device_controls[i] . isr_semaphore_id) ;
      }

    }

    return DNA_OK ;
  }
}

/* Create a route request struct - this stores information regarding the current
 * route discovery attempt.
 */
route_request_t create_route_request()
{
	route_request_t route_request = (route_request_t) malloc(sizeof(struct route_request));
	if (route_request == NULL)
		return NULL;

	route_request->threads_waiting = 0;
	route_request->initiator_sem = semaphore_create();
	route_request->waiting_sem = semaphore_create();
	semaphore_initialize(route_request->initiator_sem, 0);
	semaphore_initialize(route_request->waiting_sem, 0);
	route_request->interrupt_arg = NULL;

	return route_request;
}

s32 sys_semaphore_create(vm::ptr<u32> sem, vm::ptr<sys_semaphore_attribute_t> attr, s32 initial_val, s32 max_val)
{
	sys_semaphore.Warning("sys_semaphore_create(sem=*0x%x, attr=*0x%x, initial_val=%d, max_val=%d)", sem, attr, initial_val, max_val);

	if (!sem || !attr)
	{
		return CELL_EFAULT;
	}

	if (max_val <= 0 || initial_val > max_val || initial_val < 0)
	{
		sys_semaphore.Error("sys_semaphore_create(): invalid parameters (initial_val=%d, max_val=%d)", initial_val, max_val);
		return CELL_EINVAL;
	}

	const u32 protocol = attr->protocol;

	switch (protocol)
	{
	case SYS_SYNC_FIFO: break;
	case SYS_SYNC_PRIORITY: break;
	case SYS_SYNC_PRIORITY_INHERIT: break;
	default: sys_semaphore.Error("sys_semaphore_create(): unknown protocol (0x%x)", protocol); return CELL_EINVAL;
	}

	if (attr->pshared.data() != se32(0x200) || attr->ipc_key.data() || attr->flags.data())
	{
		sys_semaphore.Error("sys_semaphore_create(): unknown attributes (pshared=0x%x, ipc_key=0x%x, flags=0x%x)", attr->pshared, attr->ipc_key, attr->flags);
		return CELL_EINVAL;
	}

	*sem = semaphore_create(initial_val, max_val, protocol, attr->name_u64);

	return CELL_OK;
}

void
_dispatch_sema4_create_slow(_dispatch_sema4_t *s4, int policy)
{
	semaphore_t tmp = MACH_PORT_NULL;

	_dispatch_fork_becomes_unsafe();

	// lazily allocate the semaphore port

	// Someday:
	// 1) Switch to a doubly-linked FIFO in user-space.
	// 2) User-space timers for the timeout.

#if DISPATCH_USE_OS_SEMAPHORE_CACHE
	if (policy == _DSEMA4_POLICY_FIFO) {
		tmp = (_dispatch_sema4_t)os_get_cached_semaphore();
		if (!os_atomic_cmpxchg(s4, MACH_PORT_NULL, tmp, relaxed)) {
			os_put_cached_semaphore((os_semaphore_t)tmp);
		}
		return;
	}
#endif

	kern_return_t kr = semaphore_create(mach_task_self(), &tmp, policy, 0);
	DISPATCH_SEMAPHORE_VERIFY_KR(kr);

	if (!os_atomic_cmpxchg(s4, MACH_PORT_NULL, tmp, relaxed)) {
		kr = semaphore_destroy(mach_task_self(), tmp);
		DISPATCH_SEMAPHORE_VERIFY_KR(kr);
	}
}

void create_data(){
	struct semaphore* s=semaphore_create(M);
	set_bouncer(s);
	
	struct BB* bb=BB_create(A);
	set_ABB(bb);
	
	bb=BB_create(A);
	set_DrinkBB(bb);
	
	bb=BB_create(C);
	set_CBB(bb);
	// buy new cups
	int i;
	for(i=0; i<C; i++){
		struct Cup* c=malloc(sizeof(struct Cup));
		c->id=next_cupID;
		next_cupID++;
		printf(1, "buy new cup\n");
		BB_put(cbb, c);
	}
	
	bb=BB_create(C);
	set_DBB(bb);
}

int test4(void)
{
    thread_id tid;
    sem_id sid;
    status_t err;
    int res = 1;

    /* create new semaphore */
    sid = semaphore_create(NULL, 1, 0);
    if(sid == INVALID_SEMID)
        return 0;

    /* create thread */
    tid = sys_create_thread(thread_func, &sid, false, 0);
    if(tid == INVALID_THREADID)
        return 0;

    /* wait for created thread count up semaphore */
    err = semaphore_down_timeout(sid, 1, 1000);
    if(err != NO_ERROR)
        res = 0;

    /* delete semaphore */
    err = semaphore_delete(sid);
    if(err != NO_ERROR)
        res = 0;

    return res;
}

Threading::Semaphore::Semaphore()
{
	// other platforms explicitly make a thread-private (unshared) semaphore
	// here. But it seems Mach doesn't support that.
	MACH_CHECK(semaphore_create(mach_task_self(), (semaphore_t *)&m_sema, SYNC_POLICY_FIFO, 0));
	__atomic_store_n(&m_counter, 0, __ATOMIC_SEQ_CST);
}