#pragma once

// Objects for Inter-Process-Communication
//
// created on 2022-03-01
//

#ifdef WIN32
#include <Windows.h>

#define sem_t                   HANDLE
#define USB_TIMEOUT_INFINITE    -1
#else
#include <semaphore.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define USB_TIMEOUT_INFINITE    0
#endif

#include <string>
#include <mutex>


class platform_event
{
    sem_t   sem_;
    volatile bool waiting_;
    std::string     dbg_info_;

public:
    platform_event();
    ~platform_event();

public:
    bool try_wait(void);
    bool wait(unsigned timeout = USB_TIMEOUT_INFINITE/*ms*/);       // USB_TIMEOUT_INFINITE is waiting unfinite, true when watied and false for wait timeout
    void notify(void);
    bool is_waiting(void);

    void set_debug_info(const char* info);
};

class refer
{
    volatile int ref_;
    std::mutex   mutex_;

protected:
    refer() : ref_(1)
    {}
    virtual ~refer()
    {}

public:
    int add_ref(void)
    {
        std::lock_guard<std::mutex> lock(mutex_);

        return ++ref_;
    }
    int release(void)
    {
        int ref = 0;

        {
            std::lock_guard<std::mutex> lock(mutex_);
            ref = --ref_;
        }

        if (ref == 0)
            delete this;

        return ref;
    }
};

template<class T>
class do_when_born_and_dead : public refer
{
    T*          obj_;
    void(T::* dead_)(void*);
    void*       param_;

public:
    do_when_born_and_dead(T* obj, void(T::* born)(void*), void(T::* dead)(void*), void* param)
        : obj_(obj), dead_(dead), param_(param)
    {
        if(born)
            (obj_->*born)(param_);
    }

protected:
    ~do_when_born_and_dead()
    {
        (obj_->*dead_)(param_);
    }
};

// mutex object
class shared_memory : public refer
{
    unsigned long long key_;
    void*   obj_;
    bool    first_;
    size_t  bytes_;
    size_t  len_;

    void init(void);
    void clear(void);
    char* get_buf(void);
    void release_buf(void* buf);

public:
    shared_memory(unsigned long long key, size_t size = 1024);

protected:
    ~shared_memory();

public:
    bool is_ok(void);
    bool is_first(void);
    std::string read(void);
    int write(const char* data, size_t len);
};