/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <time.h>

#include <errno.h>

#include <new>

#include <AutoDeleter.h>
#include <syscall_utils.h>

#include <errno_private.h>
#include <syscalls.h>
#include <thread_defs.h>
#include <user_timer_defs.h>

#include <libroot_private.h>
#include <pthread_private.h>
#include <time_private.h>
#include <user_thread.h>


static void
info_to_itimerspec(const user_timer_info& info, itimerspec& spec)
{
        bigtime_to_timespec(info.interval, spec.it_interval);

        // A remaining_time of B_INFINITE_TIMEOUT means the timer isn't scheduled.
        if (info.remaining_time != B_INFINITE_TIMEOUT) {
                bigtime_to_timespec(info.remaining_time, spec.it_value);
        } else {
                spec.it_value.tv_sec = 0;
                spec.it_value.tv_nsec = 0;
        }
}


static bool
itimerspec_to_bigtimes(const itimerspec& spec, bigtime_t& _nextTime,
        bigtime_t& _interval)
{
        if (!timespec_to_bigtime(spec.it_interval, _interval)
                || !timespec_to_bigtime(spec.it_value, _nextTime)) {
                return false;
        }

        if (_nextTime == 0)
                _nextTime = B_INFINITE_TIMEOUT;

        return true;
}


static status_t
timer_thread_entry(void* _entry, void* _value)
{
        // init a pthread
        pthread_thread thread;
        __init_pthread(&thread, NULL, NULL);
        thread.flags |= THREAD_DETACHED;

        get_user_thread()->pthread = &thread;

        // we have been started with deferred signals -- undefer them
        undefer_signals();

        // prepare the arguments
        union sigval value;
        value.sival_ptr = _value;
        void (*entry)(union sigval) = (void (*)(union sigval))_entry;

        // call the entry function
        entry(value);

        return B_OK;
}


// #pragma mark -


int
timer_create(clockid_t clockID, struct sigevent* event, timer_t* _timer)
{
        // create a timer object
        __timer_t* timer = new(std::nothrow) __timer_t;
        if (timer == NULL)
                RETURN_AND_SET_ERRNO(ENOMEM);
        ObjectDeleter<__timer_t> timerDeleter(timer);

        // If the notification method is SIGEV_THREAD, initialize thread creation
        // attributes.
        bool isThreadEvent = event != NULL && event->sigev_notify == SIGEV_THREAD;
        thread_creation_attributes threadAttributes;
        if (isThreadEvent) {
                status_t error = __pthread_init_creation_attributes(
                        event->sigev_notify_attributes, NULL, &timer_thread_entry,
                        (void*)event->sigev_notify_function, event->sigev_value.sival_ptr,
                        "timer notify", &threadAttributes);
                if (error != B_OK)
                        RETURN_AND_SET_ERRNO(error);

                threadAttributes.flags |= THREAD_CREATION_FLAG_DEFER_SIGNALS;
        }

        // create the timer
        int32 timerID = _kern_create_timer(clockID, -1, 0, event,
                isThreadEvent ? &threadAttributes : NULL);
        if (timerID < 0)
                RETURN_AND_SET_ERRNO(timerID);

        // init the object members
        timer->SetTo(timerID, -1);

        *_timer = timerDeleter.Detach();
        return 0;
}


int
timer_delete(timer_t timer)
{
        status_t error = _kern_delete_timer(timer->id, timer->thread);
        if (error != B_OK)
                RETURN_AND_SET_ERRNO(error);

        delete timer;
        return 0;
}


int
timer_gettime(timer_t timer, struct itimerspec* value)
{
        user_timer_info info;
        status_t error = _kern_get_timer(timer->id, timer->thread, &info);
        if (error != B_OK)
                RETURN_AND_SET_ERRNO(error);

        info_to_itimerspec(info, *value);

        return 0;
}


int
timer_settime(timer_t timer, int flags, const struct itimerspec* value,
        struct itimerspec* oldValue)
{
        // translate new value
        bigtime_t nextTime;
        bigtime_t interval;
        if (!itimerspec_to_bigtimes(*value, nextTime, interval))
                RETURN_AND_SET_ERRNO(EINVAL);

        uint32 timeoutFlags = (flags & TIMER_ABSTIME) != 0
                ? B_ABSOLUTE_TIMEOUT : B_RELATIVE_TIMEOUT;

        // set the timer
        user_timer_info oldInfo;
        status_t error = _kern_set_timer(timer->id, timer->thread, nextTime,
                interval, timeoutFlags, oldValue != NULL ? &oldInfo : NULL);
        if (error != B_OK)
                RETURN_AND_SET_ERRNO(error);

        // translate old info back
        if (oldValue != NULL)
                info_to_itimerspec(oldInfo, *oldValue);

        return 0;
}


int
timer_getoverrun(timer_t timer)
{
        user_timer_info info;
        status_t error = _kern_get_timer(timer->id, timer->thread, &info);
        if (error != B_OK)
                RETURN_AND_SET_ERRNO(error);

        return info.overrun_count;
}