#include "shm.h"

#ifdef __linux

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
#include <semaphore.h>

typedef struct __shm_item__ {

    struct __shm_item__ *next;
    struct __shm_item__ *prev;
    size_t               size;

} ShmItem;


class ShmApi
{
private:
    int     _shm_fd;
    size_t  _size;
    bool    _owner;
    void   *_mem;
    sem_t  *_sem;

    char *_mem_name;
    char *_sem_name;

    size_t  *_used;
    ShmItem **__first;
    ShmItem **__free_list;

    ShmPlace *_slots;

    int    _in_critical;

private:
    void cleanup() {
        // We don't need to do anything here.

    }

public:
    ShmSem *makeSem(const char *name, bool owner) {
        return new ShmSem(name, owner);
    }

public:
    int slot(int s) {
        return _slots[s];
    }

    void setSlot(int s, ShmPlace place) {
        _slots[s] = place;
    }

public:
    const char *name() {
        return _mem_name;
    }

public:
    int alloc(size_t bytes) {
        enterCritical();

        ShmItem *_free_list = *__free_list;
        ShmItem *_first = *__first;

        ShmItem *i = _free_list;

        while (i != nullptr && i->size < bytes) {
            i = i->next;
        }

        int place;
        if (i != nullptr) {
            if (i->prev != nullptr) {
                i->prev->next = i->next;
            }
            if (i->next != nullptr) {
                i->next->prev = i->prev;
            }
            if (i->prev == nullptr) {
                _free_list = i->next;
            }
            i->next = _first;
            if (_first != nullptr) {
                _first->prev = i;
            }
            i->prev = nullptr;

            _first = i;
            *__first = _first;
            *__free_list = _free_list;

            place = (reinterpret_cast<char *>(i) + sizeof(ShmItem)) - reinterpret_cast<char *>(_mem);
        } else {
            i = reinterpret_cast<ShmItem *>(reinterpret_cast<char *>(_mem) + *_used);
            size_t u = *_used + sizeof(ShmItem) + bytes;

            if (u >= _size) {
                place = -1;
            } else {
                *_used = u;
                i->prev = nullptr;
                i->size = bytes;
                i->next = _first;

                _first = i;
                *__first = _first;

                place = (reinterpret_cast<char *>(i) + sizeof(ShmItem)) - reinterpret_cast<char *>(_mem);
            }
        }

        leaveCritical();
        return place;
    }

    void free(int place) {
        enterCritical();
        ShmItem *i = reinterpret_cast<ShmItem *>(reinterpret_cast<char *>(_mem) + place - sizeof(ShmItem));

        ShmItem *_free_list = *__free_list;
        ShmItem *_first = *__first;

        if (i->prev != nullptr) {
            i->prev->next = i->next;
        }
        if (i->next != nullptr) {
            i->next->prev = i->prev;
        }
        if (i->prev == nullptr) {
            _first = i->next;
        }
        i->next = _free_list;
        if (_free_list != nullptr) {
            _free_list->prev = i;
        }
        i->prev = nullptr;
        _free_list = i;

        *__first = _first;
        *__free_list = _free_list;
        leaveCritical();
    }

    inline void *ref(int place)
    {
        return reinterpret_cast<char *>(_mem) + place;
    }

    void enterCritical() {
        if (_in_critical > 0) {
            _in_critical++;
        } else {
            sem_wait(_sem);
            _in_critical = 1;
        }
    }

    void leaveCritical() {
        if (_in_critical > 1) {
            _in_critical--;
        } else {
            _in_critical = 0;
            sem_post(_sem);
        }
    }

public:
    ShmApi(const char *name, size_t size, bool owner) {

        {
            char buf[strlen(name) + 50];
            sprintf(buf, "sem_%s", name);
            _sem_name = strdup(buf);
            _mem_name = strdup(name);
        }

        size_t slots_size = sizeof(ShmPlace) * SHM_MAX_SLOTS;
        size += slots_size;

        _sem = sem_open(_sem_name, O_CREAT);
        _shm_fd = shm_open(name, O_CREAT | O_RDWR, 0600);
        ftruncate(_shm_fd, size);
        _size = size;
        _mem = mmap(nullptr, _size, PROT_READ|PROT_WRITE, MAP_SHARED, _shm_fd, 0);

        _slots = reinterpret_cast <ShmPlace *>(reinterpret_cast<char *>(_mem) + sizeof(size_t) + sizeof(ShmItem *) + sizeof(ShmItem *));

        _used = reinterpret_cast<size_t *>(_mem);

        __first = reinterpret_cast<ShmItem **>(reinterpret_cast<char *>(_mem) + sizeof(size_t));

        __free_list = reinterpret_cast<ShmItem **>(reinterpret_cast<char *>(_mem) + sizeof(size_t) + sizeof(ShmItem *));

        _owner = owner;

        if (_owner) {
            *__first = nullptr;
            *__free_list = nullptr;
            *_used = sizeof(size_t) + sizeof(ShmItem *) + sizeof(ShmItem *) + slots_size;
            sem_post(_sem);
        }

        _in_critical = 0;
    }

    ~ShmApi() {
        cleanup();
        munmap(_mem, _size);
        close(_shm_fd);
        sem_close(_sem);
        if (_owner) {
            shm_unlink(_mem_name);
            sem_unlink(_sem_name);
        }
        ::free(_mem_name);
        ::free(_sem_name);
    }
};
#endif

#ifdef _WIN32
class ShmApi
{
public:
    ShmApi(const char *name, size_t size, bool owner)
    {
    }

    ~ShmApi()
    {
    }

    void enterCritical()
    {

    }

    void leaveCritical()
    {

    }

    void *alloc(size_t bytes)
    {
        return malloc(bytes);
    }

    void free(void *mem)
    {
        free(mem);
    }
}
#endif



ShmPlace Shm::alloc(size_t mem)
{
    return _shm_api->alloc(mem);
}

void Shm::free(ShmPlace place)
{
    _shm_api->free(place);
}

void Shm::unlock()
{
    _shm_api->leaveCritical();
}

ShmPlace Shm::slot(ShmSlot s)
{
    return _shm_api->slot(s);
}

void Shm::setSlot(ShmSlot s, ShmPlace pl)
{
    _shm_api->setSlot(s, pl);
}

ShmSem *Shm::sem(const char *name, bool owner)
{
    return _shm_api->makeSem(name, owner);
}

const char *Shm::name()
{
    return _shm_api->name();
}

void *Shm::ref(int place)
{
    return _shm_api->ref(place);
}

void Shm::lock()
{
    _shm_api->enterCritical();
}

Shm::Shm(const char *name, size_t bytes, bool owner)
{
    _shm_api = new ShmApi(name, bytes, owner);
}

Shm::~Shm()
{
    delete _shm_api;
}

template<class T> void ref(Shm *shm, int place, T **p)
{
    *p = reinterpret_cast<T *>(shm->ref(place));
}

void ShmSem::post() {
    sem_post(reinterpret_cast<sem_t *>(_sem));
}

void ShmSem::wait() {
    sem_wait(reinterpret_cast<sem_t *>(_sem));
}

bool ShmSem::trywait() {
    return sem_trywait(reinterpret_cast<sem_t *>(_sem)) == 0;
}

ShmSem::ShmSem(const char *n, bool owner) {
    _name = strdup(n);
    _sem = reinterpret_cast<void *>(sem_open(n, O_CREAT));
    _owner = owner;
}

ShmSem::~ShmSem() {
    sem_close(reinterpret_cast<sem_t *>(_sem));
    if (_owner) {
        sem_unlink(_name);
    }
    free(_name);
}