#pragma once
#ifndef _FILE_QUEUE
#define _FILE_QUEUE

#include <stdio.h>
#include <pthread.h>

#include "conn.h"

/* Algoritmo che viene usato per il rimpiazzo dei dati:
   se = 0 -> FIFO
   se = 1 -> LRU
 */
#define ALGORITHM 0

/* struttura dati per gestire i file in memoria principale */
typedef struct {
    char *filepath;     /* path assoluto del file */
    int O_LOCK;         /* 1 se il file e' in modalita' locked */
    int owner;          /* client che possiede la lock sul file */
    int open;           /* 1 se il file e' aperto */
    void *data;         /* contenuto del file */
    size_t size;        /* dimensione del file in bytes */
    size_t valid;       /* posizione fino a cui i dati sono validi */
} fileT;

/* nodo di una linked list */
typedef struct node {
    fileT *data;
    struct node *next;
} nodeT;

/* coda */
typedef struct {
    nodeT *head;        /* puntatore al primo elemento */
    nodeT *tail;        /* puntatore all'ultimo elemento */
    size_t maxLen;      /* numero massimo di elementi */
    size_t len;         /* numero attuale di elementi */
    size_t maxSize;     /* dimensione massima */
    size_t size;        /* dimensione attuale */
    pthread_mutex_t m;  /* lock sulla coda */
} queueT;



/**
 * Creazione di un fileT.
 * @param f string che identifica il fileT tramite il suo path assoluto
 * @param O_LOCK 1 locked, 0 unlocked
 * @param client client associato
 * @param open apertura del file dopo la creazione
 *
 * @return puntatore al fileT, NULL se errore (errno)
 */
fileT* createFileT(char *f, int O_LOCK, int client, int open);

/**
 * Append su un fileT.
 * @param f fileT sul quale scrivere
 * @param data puntatore al buffer da scrivere
 * @param size dimensione in bytes del buffer
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int writeFileT(fileT *f, void *data, size_t size);

/**
 * Rimozione di un fileT.
 * @param f
 */
void destroyFile(fileT *f);



/**
 * Alloca ed inizializza una coda di fileT.
 * @param maxLen lunghezza massima della coda
 * @param maxSize dimensione massima della coda in bytes
 *
 * @return puntatore alla coda allocata, NULL se errore
 */
queueT* createQueue(size_t maxLen, size_t maxSize);

/**
 * Inserisce un fileT nella coda.
 * @param q puntatore alla coda
 * @param data puntatore al fileT da inserire
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int enqueue(queueT *q, fileT* data);

/**
 * Estrae un fileT dalla coda.
 * @param q puntatore alla coda
 *
 * @return puntatore al file estratto, NULL se errore
 */
fileT* dequeue(queueT *q);

/**
 * Estrae fileT dalla coda fino ad ottenere abbastanza spazio in q.
 * @param q puntatore alla coda
 * @param filepath file a cui bisogna aggiungere s di spazio
 * @param s dimensione da aggiungere al file
 *
 * @return puntatore alla lista di file estratti (NULL terminated), NULL se errore
 */
fileT ** dequeueN(queueT *q, char *filepath, size_t s);

/**
 * Estrae un fileT dalla coda come la dequeue, ma invece di restituire il
 * file estratto lo distrugge immediatamente, liberandone la memoria.
 *
 * @param q puntatore alla coda
 */
void voidDequeue(queueT *q);


/**
 * Stampa l'intero contenuto della coda.
 * @param stream file su cui stampare
 * @param q puntatore alla coda da stampare
 *
 * @retval 0 se successo, -1 se errore (errno)
 */
int printQueue(FILE *stream, queueT *q);



/**
 * Cerca di ottenere il lock su un fileT, fallisce se un altro client ha gia'
 * richiesto la lock
 * @param q puntatore alla coda che contiene il fileT
 * @param filepath path assoluto (identificatore) del fileT
 * @param owner client che ha richiesto l'operazione
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int lockFileInQueue(queueT *q, char *filepath, int owner);

/**
 * Rilascia il lock di un file, fallisce se non si e' il possessore del lock
 * @param q puntatore alla coda che contiene il fileT
 * @param filepath path assoluto (identificatore) del fileT
 * @param owner client che ha richiesto l'operazione
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int unlockFileInQueue(queueT *q, char *filepath, int owner);

/**
 * Apre un fileT contenuto nella coda. Fallisce se il lock appartiene a un
 * client diverso.
 * @param q puntatore alla coda che contiene il fileT da aprire
 * @param filepath path assoluto (identificatore) del fileT da aprire
 * @param O_LOCK 1 locked, 0 unlocked
 * @param owner client che ha richiesto l'apertura
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int openFileInQueue(queueT *q, char *filepath, int O_LOCK, int owner);

/**
 * Chiude un file contenuto nella coda. Ha successo se fileT non e' stato aperto.
 * Fallisce se il file e' stato messo in modalita' locked da un client diverso.
 * @param q puntatore alla coda che contiene il fileT da chiudere
 * @param filepath path assoluto (identificatore) del fileT da chiudere
 * @param owner client che ha richiesto la chiusura
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int closeFileInQueue(queueT *q, char *filepath, int owner);

/**
 * Scrive del contenuto su un fileT all'interno della coda. Fallisce se il file
 * non e' stato aperto o se il lock appartiene a un client diverso.
 * @param q puntatore alla coda che contiene il fileT su cui scrivere
 * @param filepath path assoluto (identificatore) del fileT
 * @param data buffer che contiene i dati
 * @param size dimensione in bytes del buffer
 * @param owner client che ha richiesto l'operazione di scrittura
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int writeFileInQueue(queueT *q, char *filepath, void *data, size_t size, int owner);

/**
 * Scrive del contenuto in append su un fileT all'interno della coda. Fallisce
 * se il file non e' stato aperto o se il lock appartiene a un client diverso.
 * @param q puntatore alla coda che contiene il fileT su cui effettuare l'append
 * @param filepath path assoluto (identificatore) del fileT
 * @param data buffer che contiene i dati
 * @param size dimensione in bytes del buffer
 * @param owner client che ha richiesto l'operazione di append
 *
 * @return 0 se successo, -1 se errore (setta errno)
 */
int appendFileInQueue(queueT *q, char *filepath, void *data, size_t size, int owner);

/**
 * Rimuove un fileT dalla coda. Fallisce se non si è in possesso della lock o se
 * la lock e' posseduta da un client diverso.
 * @param q puntatore alla coda che contiene il fileT da rimuovere
 * @param filepath path assoluto (identificatore) del fileT da rimuovere
 * @param owner client che ha richiesto la rimozione
 *
 * @return 0 se successo, -1 se errore (errno)
 */
int removeFileFromQueue(queueT *q, char *filepath, int owner);



/**
 * Cerca un fileT nella coda e ritorna una copia.
 * @param q puntatore alla coda sulla quale cercare il fileT
 * @param filepath path assoluto del fileT da cercare
 *
 * @return puntatore a una copia del fileT se trovato, NULL se non trovato o errore (errno)
 */
fileT* find(queueT *q, char *filepath);

/**
 * Estrae n fileT dalla coda senza eliminarli
 * @param q puntatore alla coda
 * @param n numero di file da estrarre
 *
 * @return puntatore i file estratti (NULL terminated), NULL se errore
 */
fileT ** request(queueT *q, int n);

/**
 * Cerca il fileT nella coda e ritorna il siultato dell'operazione
 * @param q puntatore alla coda sulla quale cercare il fileT
 * @param filepath path assoluto del fileT da cercare
 *
 * @return 0 se non trovato, 1 se trovato
 */
int searchFile(queueT *q, char *filepath);

/**
 * Numero di elementi presenti nella coda.
 * @param q puntatore alla coda
 *
 * @return numero di elementi presenti, -1 se errore (errno)
 */
size_t getLen(queueT *q);

/**
 * Restituisce la dimensione attuale della coda in bytes.
 * @param q puntatore alla coda
 *
 * @return dimensione della coda in bytes, -1 se errore (errno)
 */
size_t getSize(queueT *q);

/**
 * Cancella una coda allocata con createQueue e ne libera la memoria.
 * @param q puntatore alla coda da distruggere
 */
void destroyQueue(queueT *q);

#endif /* _FILE_QUEUE */