#ifndef my_handle_h

#define my_handle_h

#include <stdint.h>

#include "mydef.h"

#include "mem.h"

typedef struct tag_my_handle {

    int ref;

    int stack;

    intptr_t detached;

    void* ptr;

    free_t free;

} my_handle;

static inline my_handle* debug_handle_attach(void* ptr, free_t fp_free, const char* func, int line)

{

    my_handle* handle = (my_handle *) debug_malloc(sizeof(my_handle), func, line);

    if (handle != NULL) {

        handle->ref = 1;

        handle->stack = 1;

        handle->ptr = ptr;

        handle->free = fp_free;

        handle->detached = 0;

    }

    return handle;

}

#define handle_attach(ptr, fptr) debug_handle_attach(ptr, fptr, __FUNCTION__, __LINE__)

#define handle_put(handle) \

do { \

    int n = __sync_sub_and_fetch(&(handle)->stack, 1); \

    my_assert(n >= 0); \

    if (n == 0) { \

        void* handle_ptr = (void *) __sync_lock_test_and_set(&(handle)->ptr, NULL); \

        if ((handle)->free && handle_ptr) { \

            (handle)->free(handle_ptr); \

        } \

    } \

} while (0)

static inline void* handle_get_with(my_handle* handle, int detach, const char* func, int line)

{

    int n = __sync_add_and_fetch(&handle->stack, 1);

    int b = __sync_bool_compare_and_swap((void **) &handle->detached, (void *) 0, (void *) (intptr_t) detach);

    if (!b) {

        handle_put(handle);

        return NULL;

    }

    void* ptr = handle->ptr;

    my_assert2(n > 1 && ptr != NULL, "%d, %p, caller %d@%s", n, ptr, line, func);

    return ptr;

}

#define handle_get(handle) handle_get_with((handle), 0, __FUNCTION__, __LINE__)

static inline int handle_clone(my_handle* handle)

{

    int n = __sync_add_and_fetch(&handle->ref, 1);

    my_assert(n > 0);

    return n;

}

static inline int handle_release(my_handle* handle)

{

    int n = __sync_sub_and_fetch(&handle->ref, 1);

    my_assert2(n >= 0, "%p %d:%d", handle, handle->ref, handle->stack);

    if (n > 0) {

        return n;

    }

    // it should be safe to simplely check whether detached equals 0.

    // we know __sync_xxx functions have mb() semantics, and

    // if some one set handle->detached = 1, it only can be called in

    // handle_dettach while still holds a reference of handle.

    // ok, now we have seen handle->ref = 0 above, meaning

    // we have observed the latter handle_release in handle_dettach.

    // then, the mb() assure that

    // we have observed the earlier handle_get_with(handle, 1).

    if (handle->detached == 0) {

        handle_put(handle);

    }

    my_assert(handle->stack == 0);

    my_free(handle);

    return n;

}

static inline int debug_handle_dettach(my_handle* handle, const char* func, int line)

{

    void* ptr = handle_get_with(handle, 1, func, line);

    if (ptr != NULL) {

        __sync_sub_and_fetch(&handle->stack, 1);

        handle_put(handle);

    }

    return handle_release(handle);

}

#define handle_dettach(handle) debug_handle_dettach((handle), __FUNCTION__, __LINE__)

#endif