#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <assert.h>
#include <stdint.h>
#include <sys/file.h>

#include "locking.h"
#include "error.h"
#include "pci.h"
#include "kmem.h"

/*
 * this function allocates the kernel memory for the locks for software registers
 */
int pcilib_init_locking(pcilib_t* ctx) {
    int i;
    int err;
    pcilib_kmem_reuse_state_t reused;

    assert(PCILIB_LOCK_PAGES * PCILIB_KMEM_PAGE_SIZE >= PCILIB_MAX_LOCKS * PCILIB_LOCK_SIZE);
	
	/*protection against multiple creations of kernel space*/
    err = pcilib_lock_global(ctx);
    if (err) return err;

	/* by default, this kernel space is persistent and will be reused, in order to avoid the big initialization times for robust mutexes each time we run pcitool*/
    ctx->locks.kmem = pcilib_alloc_kernel_memory(ctx, PCILIB_KMEM_TYPE_PAGE, PCILIB_LOCK_PAGES, PCILIB_KMEM_PAGE_SIZE, 0, PCILIB_KMEM_USE(PCILIB_KMEM_USE_LOCKS,0), PCILIB_KMEM_FLAG_REUSE|PCILIB_KMEM_FLAG_PERSISTENT);
    if (!ctx->locks.kmem) {
	pcilib_unlock_global(ctx);
	pcilib_error("Allocation of kernel memory for locking subsystem has failed");
	return PCILIB_ERROR_FAILED;
    }

    reused = pcilib_kmem_is_reused(ctx, ctx->locks.kmem);
    if (reused & PCILIB_KMEM_REUSE_PARTIAL) {
	pcilib_unlock_global(ctx);
        pcilib_error("Inconsistent kernel memory for locking subsystem is found (only part of the required buffers is available)");
        return PCILIB_ERROR_INVALID_STATE;
    }

    if ((reused & PCILIB_KMEM_REUSE_REUSED) == 0) {
        for (i = 0; i < PCILIB_LOCK_PAGES; i++) {
	    void *addr = (void*)pcilib_kmem_get_block_ua(ctx, ctx->locks.kmem, i);
	    memset(addr, 0, PCILIB_KMEM_PAGE_SIZE);
        }
    }

	/* the lock that has been used for the creation of kernel space is declared unlocked, has we shouldnot use it anymore*/
    ctx->locks.locking = pcilib_get_lock(ctx, PCILIB_LOCK_FLAG_UNLOCKED, "locking");

    pcilib_unlock_global(ctx);

    if ((!ctx->locks.locking)) {
	pcilib_error("Locking subsystem has failed to initialized mandatory global locks");
	return PCILIB_ERROR_FAILED;
    }

    return 0;
}

/*
 * this function free the kernel memory allocated for them and destroys locks by setting memory to 0
 */
void pcilib_free_locking(pcilib_t *ctx) {
    if (ctx->locks.locking)
	pcilib_return_lock(ctx, PCILIB_LOCK_FLAGS_DEFAULT, ctx->locks.locking);

    if (ctx->locks.kmem) {
	pcilib_free_kernel_memory(ctx, ctx->locks.kmem, PCILIB_KMEM_FLAG_REUSE);
    }

    memset(&ctx->locks, 0, sizeof(pcilib_locking_t));
}

int pcilib_lock_global(pcilib_t *ctx) {
    int err;
    
    /* we flock() on the board's device file to make sure to not have two initialization in the same time (possible long time to init) */
    if ((err = flock(ctx->handle, LOCK_EX))==-1) {
	pcilib_error("Can't get flock on device file");
	return PCILIB_ERROR_FAILED;
    }

    return 0;
}

void pcilib_unlock_global(pcilib_t *ctx) {
    if (flock(ctx->handle, LOCK_UN) == -1)
	pcilib_warning("Could not correctly remove lock from the device file");
}

pcilib_lock_t *pcilib_get_lock_by_id(pcilib_t *ctx, pcilib_lock_id_t id) {
    int page = id / PCILIB_LOCKS_PER_PAGE;
    int offset = id - page * PCILIB_LOCKS_PER_PAGE;
    volatile void *addr = pcilib_kmem_get_block_ua(ctx, ctx->locks.kmem, page);
    pcilib_lock_t *lock = (pcilib_lock_t*)(addr + offset * PCILIB_LOCK_SIZE);

    return lock;
}

pcilib_lock_t *pcilib_get_lock(pcilib_t *ctx, pcilib_lock_flags_t flags, const char  *lock_id, ...) {
    pcilib_lock_id_t i;
    int err, ret;

    pcilib_lock_t *lock;
    char buffer[PCILIB_LOCK_SIZE];

	/* we construct the complete lock_id given the parameters of the function*/
    va_list pa;
    va_start(pa, lock_id);
    ret = vsnprintf(buffer, PCILIB_LOCK_SIZE, lock_id, pa);
    va_end(pa);

    if (ret < 0) {
	pcilib_error("Failed to construct the lock id, probably arguments does not match the format string (%s)...", lock_id);
	return NULL;
    }
	
	
	/* we iterate through locks to see if there is one already with the same name*/	
	// Would be nice to have hash here
    for (i = 0; i < PCILIB_MAX_LOCKS; i++) {
	lock = pcilib_get_lock_by_id(ctx, i);

        const char *name = pcilib_lock_get_name(lock);
	if (!name) break;
	
	if (!strcmp(buffer, name)) {
	    if ((pcilib_lock_get_flags(lock)&PCILIB_LOCK_FLAG_PERSISTENT) != (flags&PCILIB_LOCK_FLAG_PERSISTENT)) {
		if (flags&PCILIB_LOCK_FLAG_PERSISTENT)
		    pcilib_error("Requesting persistent lock (%s), but requested lock is already existing and is robust", name);
		else
		    pcilib_error("Requesting robust lock (%s), but requested lock is already existing and is persistent", name);
		return NULL;
	    }

#ifndef HAVE_STDATOMIC_H
	    if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) {
		err = pcilib_lock(ctx->locks.locking);
		if (err) {
		    pcilib_error("Error (%i) obtaining global lock", err);
		    return NULL;
		}
	    }
#endif /* ! HAVE_STDATOMIC_H */
	/* if yes, we increment its ref variable*/
	    pcilib_lock_ref(lock);
#ifndef HAVE_STDATOMIC_H
	    if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0)
		pcilib_unlock(ctx->locks.locking);
#endif /* ! HAVE_STDATOMIC_H */

	    return lock;
	}
    }

    if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) {
	err = pcilib_lock(ctx->locks.locking);
	if (err) {
	    pcilib_error("Error (%i) obtaining global lock", err);
	    return NULL;
	}
    }

	// Make sure it was not allocated meanwhile
    for (; i < PCILIB_MAX_LOCKS; i++) {
	lock = pcilib_get_lock_by_id(ctx, i);

        const char *name = pcilib_lock_get_name(lock);
	if (!name) break;

	if (!strcmp(buffer, name)) {
	    if ((pcilib_lock_get_flags(lock)&PCILIB_LOCK_FLAG_PERSISTENT) != (flags&PCILIB_LOCK_FLAG_PERSISTENT)) {
		if (flags&PCILIB_LOCK_FLAG_PERSISTENT)
		    pcilib_error("Requesting persistent lock (%s), but requested lock is already existing and is robust", name);
		else
		    pcilib_error("Requesting robust lock (%s), but requested lock is already existing and is persistent", name);
		
		if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0)
		    pcilib_unlock(ctx->locks.locking);
		return NULL;
	    }

	    pcilib_lock_ref(lock);
	    if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0)
		pcilib_unlock(ctx->locks.locking);
	    return lock;
	}
    }

    if (i == PCILIB_MAX_LOCKS) {
	if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0)
	    pcilib_unlock(ctx->locks.locking);
	pcilib_error("Failed to create lock (%s), only %u locks is supported", buffer, PCILIB_MAX_LOCKS);
	return NULL;
    }

	/* if the lock did not exist before, then we create it*/
    err = pcilib_init_lock(lock, flags, buffer);
    
    if (err) {
	pcilib_error("Lock initialization failed with error %i", err);

	if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0)
	    pcilib_unlock(ctx->locks.locking);
	
	return NULL;
    }
    
    if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0)
	pcilib_unlock(ctx->locks.locking);

    return lock;
}

void pcilib_return_lock(pcilib_t *ctx, pcilib_lock_flags_t flags, pcilib_lock_t *lock) {
#ifndef HAVE_STDATOMIC_H
	int err;
	
	if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) {
	    err = pcilib_lock(ctx->locks.locking);
	    if (err) {
		pcilib_error("Error (%i) obtaining global lock", err);
		return;
	    }
	}
#endif /* ! HAVE_STDATOMIC_H */
	pcilib_lock_unref(lock);
#ifndef HAVE_STDATOMIC_H
	if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0)
	    pcilib_unlock(ctx->locks.locking);
#endif /* ! HAVE_STDATOMIC_H */
}


/*
 * Destroy all existing locks. This is unsafe call as this and other running applications
 * will still have all initialized lock pointers. It is user responsibility to issue this
 * command when no other application is running.
 */
int pcilib_destroy_all_locks(pcilib_t *ctx, int force) {
    int err;
    pcilib_lock_id_t i;
    pcilib_kmem_reuse_state_t reused;

    if (strcasecmp(ctx->model, "maintenance")) {
	pcilib_error("Can't destroy locks while locking subsystem is initialized, use maintenance model");
	return PCILIB_ERROR_INVALID_STATE;
    }

    err = pcilib_lock_global(ctx);
    if (err) return err;

	// ToDo: We should check here that no other instances of pcitool are running, the driver can provide this information

    ctx->locks.kmem = pcilib_alloc_kernel_memory(ctx, PCILIB_KMEM_TYPE_PAGE, PCILIB_LOCK_PAGES, PCILIB_KMEM_PAGE_SIZE, 0, PCILIB_KMEM_USE(PCILIB_KMEM_USE_LOCKS,0), PCILIB_KMEM_FLAG_REUSE|PCILIB_KMEM_FLAG_PERSISTENT);
    if (!ctx->locks.kmem) {
	pcilib_unlock_global(ctx);
	pcilib_error("Failed to allocate kernel memory of locking subsystem");
	return PCILIB_ERROR_FAILED;
    }

    reused = pcilib_kmem_is_reused(ctx, ctx->locks.kmem);
    if (reused & PCILIB_KMEM_REUSE_PARTIAL) {
	pcilib_unlock_global(ctx);
        pcilib_error("Inconsistent kernel memory for locking subsystem is found (only part of the required buffers is available)");
        return PCILIB_ERROR_INVALID_STATE;
    }

    if ((reused & PCILIB_KMEM_REUSE_REUSED) == 0) {
	pcilib_free_kernel_memory(ctx, ctx->locks.kmem, PCILIB_KMEM_FLAG_REUSE|PCILIB_KMEM_FLAG_PERSISTENT);
	pcilib_unlock_global(ctx);
	return 0;
    }

	/* if we run in non-forced case, then if it may be still processes that can have access to the locks, they are not destroyed*/
    if (!force) {
	for (i = 0; i < PCILIB_MAX_LOCKS; i++) {
	    pcilib_lock_t *lock = pcilib_get_lock_by_id(ctx, i);

	    const char *name = pcilib_lock_get_name(lock);
	    if (!name) break;
	
	    size_t refs = pcilib_lock_get_refs(lock);

	    if (refs > 0) {
		char *stmp = strdup(name);
		pcilib_free_locking(ctx);
		pcilib_unlock_global(ctx);
		pcilib_error("Lock (%s) has %zu references, destroying references may result in crashes and data corruption", stmp, refs);
		free(stmp);
		return PCILIB_ERROR_BUSY;
	    }
	}
    }

	// Do we really need this? I guess zeroing should be enough
    for (i = 0; i < PCILIB_MAX_LOCKS; i++) {
	pcilib_lock_t *lock = pcilib_get_lock_by_id(ctx, i);

	const char *name = pcilib_lock_get_name(lock);
	if (!name) break;

	pcilib_free_lock(lock);
    }

    for (i = 0; i < PCILIB_LOCK_PAGES; i++) {
	void *addr = (void*)pcilib_kmem_get_block_ua(ctx, ctx->locks.kmem, i);
	memset(addr, 0, PCILIB_KMEM_PAGE_SIZE);
    }

    pcilib_free_locking(ctx);
    pcilib_unlock_global(ctx);

    return 0;
}