/**
 * @file    myTask.c
 * @brief   任务框架实现 — 定时器 + 事件 + 消息队列（纯 C）
 * @details 基于 SPEC §8 原工程分析，从零自主编写。
 *          定时器基于 timerfd + epoll 精确到毫秒。
 *          事件基于位图 + pthread 条件变量。
 *          消息队列基于环形缓冲区，消息带长度前缀。
 */

#include "myTask.h"
#include "myBase.h"
#include "myLog.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <sys/timerfd.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>

/* ================================================================
 * 内部数据结构
 * ================================================================ */

/**
 * @brief  事件对象（位图 + 条件变量 + 引用计数）
 */
typedef struct
{
	char             name[64];      /* 事件名称（调试用） */
	uint32_t         bits;          /* 当前事件位掩码 */
	pthread_mutex_t  lock;          /* 互斥锁 */
	pthread_cond_t   cond;          /* 条件变量 */
	int              ref_count;     /* 引用计数（安全析构） */
} stru_task_event;

/**
 * @brief  消息队列对象（环形缓冲区）
 */
typedef struct
{
	char             name[64];      /* 队列名称（调试用） */
	uint8_t         *buf;           /* 环形缓冲区基址 */
	uint32_t         msg_size;      /* 单条消息最大字节数 */
	uint32_t         max_msgs;      /* 最大消息条数 */
	uint32_t         msg_count;     /* 当前消息数 */
	uint32_t         head;          /* 读位置 */
	uint32_t         tail;          /* 写位置 */
	pthread_mutex_t  lock;          /* 互斥锁 */
	pthread_cond_t   cond;          /* 条件变量 */
	int              ref_count;     /* 引用计数（安全析构） */
} stru_task_msg_queue;

/**
 * @brief  定时器对象（基于 timerfd + epoll）
 */
typedef struct
{
	char             name[64];      /* 定时器名称（调试用） */
	int              timerfd;       /* timerfd 文件描述符 */
	timer_func_cb    cb;            /* 到期回调函数 */
	void            *arg;           /* 回调参数 */
	uint32_t         timeout_ms;    /* 定时周期（毫秒） */
	int              flags;         /* ONCE / PERIODIC */
	int              active;        /* 是否已启动 */
	int              running;       /* 是否在 epoll 监听中 */
	pthread_mutex_t  lock;          /* 互斥锁 */
	int              ref_count;     /* 引用计数（安全析构） */
} stru_task_timer;

/* ================================================================
 * 全局定时器管理器（epoll + 独立线程）
 * ================================================================ */

LOCAL int              g_timer_epfd    = -1;  /* epoll 实例 fd */
LOCAL int              g_timer_evtfd   = -1;  /* eventfd（用于唤醒 epoll） */
LOCAL pthread_t        g_timer_thread;         /* 定时器管理线程 */
LOCAL pthread_mutex_t  g_timer_lock    = PTHREAD_MUTEX_INITIALIZER;
LOCAL int              g_timer_inited  = 0;

/*******************************************************************************
 * 定时器管理线程
 * @details 使用 epoll 统一监听所有定时器的 timerfd。
 *          通过 eventfd 实现安全唤醒，支持动态增删定时器。
 ******************************************************************************/

LOCAL void *timer_manager_thread(void *arg)
{
	(void)arg;

	struct epoll_event ev;
	struct epoll_event events[64];

	/* 创建 epoll 实例 */
	g_timer_epfd = epoll_create1(0);

	if (g_timer_epfd < 0)
	{
		LOG_E("epoll_create1 failed");

		return NULL;
	}

	/* 创建 eventfd 用于唤醒 */
	g_timer_evtfd = eventfd(0, EFD_NONBLOCK);

	if (g_timer_evtfd < 0)
	{
		LOG_E("eventfd failed");
		close(g_timer_epfd);

		return NULL;
	}

	/* 将 eventfd 加入 epoll */
	memset(&ev, 0, sizeof(ev));
	ev.events   = EPOLLIN;
	ev.data.ptr = NULL;

	if (epoll_ctl(g_timer_epfd, EPOLL_CTL_ADD, g_timer_evtfd, &ev) != 0)
	{
		LOG_E("epoll_ctl ADD eventfd failed");
		close(g_timer_evtfd);
		close(g_timer_epfd);

		return NULL;
	}

	/* 事件循环 */
	while (1)
	{
		int n = epoll_wait(g_timer_epfd, events, 64, -1);

		if (n < 0)
		{
			if (errno == EINTR)
			{
				continue;
			}

			break;
		}

		/* 遍历就绪事件 */
		for (int i = 0; i < n; i++)
		{
			if (events[i].data.ptr == NULL)
			{
				/* eventfd 唤醒：读取并丢弃 */
				uint64_t dummy;

				read(g_timer_evtfd, &dummy, sizeof(dummy));

				continue;
			}

			/* 定时器到期 */
			stru_task_timer *p = (stru_task_timer *)events[i].data.ptr;
			uint64_t         exp;

			read(p->timerfd, &exp, sizeof(exp));

			/* 加锁后回调（避免竞态） */
			pthread_mutex_lock(&p->lock);

			if (p->active && p->cb)
			{
				p->cb(p->arg);

				/* 单次触发则自动停止 */
				if (p->flags & TASK_TIMER_FLAG_ONCE)
				{
					p->active  = 0;
					p->running = 0;
				}
			}

			pthread_mutex_unlock(&p->lock);
		}
	}

	/* 清理 epoll 资源 */
	close(g_timer_evtfd);
	close(g_timer_epfd);

	return NULL;
}

/**
 * @brief  线程安全初始化定时器管理器
 * @details 首次调用时启动 epoll 线程
 */
LOCAL void timer_manager_ensure(void)
{
	pthread_mutex_lock(&g_timer_lock);

	if (!g_timer_inited)
	{
		g_timer_inited = 1;
		pthread_create(&g_timer_thread, NULL, timer_manager_thread, NULL);
	}

	pthread_mutex_unlock(&g_timer_lock);
}

/*******************************************************************************
 * 通用延时函数
 ******************************************************************************/

/**
 * @brief  毫秒级精度延时（使用 nanosleep）
 */
void task_sleep_ms(uint32_t ms)
{
	struct timespec req;

	req.tv_sec  = ms / 1000;
	req.tv_nsec = (ms % 1000) * 1000000;

	nanosleep(&req, NULL);
}

/*******************************************************************************
 * 事件子系统的公开 API 实现
 ******************************************************************************/

/**
 * @brief  创建事件对象
 */
stru_task_event_t task_event_create(const char *name)
{
	if (!name)
	{
		LOG_E("task_event_create: name is NULL");

		return NULL;
	}

	stru_task_event *p = (stru_task_event *)calloc(1, sizeof(stru_task_event));

	if (!p)
	{
		LOG_E("task_event_create: malloc failed");

		return NULL;
	}

	strncpy(p->name, name, sizeof(p->name) - 1);
	p->bits      = 0;
	p->ref_count = 1;

	pthread_mutex_init(&p->lock, NULL);
	pthread_cond_init(&p->cond, NULL);

	return (stru_task_event_t)p;
}

/**
 * @brief  销毁事件对象（带引用计数保护）
 */
int task_event_destroy(stru_task_event_t p_event)
{
	if (!p_event)
	{
		LOG_E("task_event_destroy: p_event is NULL");

		return -1;
	}

	stru_task_event *p = (stru_task_event *)p_event;

	pthread_mutex_lock(&p->lock);

	p->ref_count--;

	if (p->ref_count > 0)
	{
		pthread_mutex_unlock(&p->lock);

		return 0;
	}

	pthread_mutex_unlock(&p->lock);
	pthread_mutex_destroy(&p->lock);
	pthread_cond_destroy(&p->cond);

	free(p);

	return 0;
}

/**
 * @brief  发送事件（置位 + 广播唤醒）
 */
int task_event_send(stru_task_event_t p_event, uint32_t event)
{
	if (!p_event)
	{
		LOG_E("task_event_send: p_event is NULL");

		return -1;
	}

	stru_task_event *p = (stru_task_event *)p_event;

	pthread_mutex_lock(&p->lock);
	p->bits |= event;
	pthread_cond_broadcast(&p->cond);
	pthread_mutex_unlock(&p->lock);

	return 0;
}

/**
 * @brief  等待事件（支持 AND/OR/CLEAR 三种模式）
 */
int task_event_recv(stru_task_event_t p_event, uint32_t set, uint32_t opt,
                    uint32_t timeout_ms, uint32_t *recved)
{
	if (!p_event)
	{
		LOG_E("task_event_recv: p_event is NULL");

		return -1;
	}

	stru_task_event *p   = (stru_task_event *)p_event;
	uint32_t         matched;
	int              ret = 0;
	struct timespec  ts;

	pthread_mutex_lock(&p->lock);

	/* 计算超时绝对时间 */
	if (timeout_ms != TASK_EVENT_WAIT_FOREVER && timeout_ms != 0)
	{
		clock_gettime(CLOCK_REALTIME, &ts);
		ts.tv_sec  += timeout_ms / 1000;
		ts.tv_nsec += (timeout_ms % 1000) * 1000000;

		if (ts.tv_nsec >= 1000000000)
		{
			ts.tv_sec++;
			ts.tv_nsec -= 1000000000;
		}
	}

	/* 轮询等待直到条件满足或超时 */
	while (1)
	{
		/* 判断是否满足等待条件 */
		if (opt & TASK_EVENT_FLAG_AND)
		{
			matched = (set == (p->bits & set));
		}
		else
		{
			matched = (p->bits & set) != 0;
		}

		if (matched)
		{
			/* 回传实际接收到的事件位 */
			if (recved)
			{
				*recved = p->bits & set;
			}

			/* 如果设置了 CLEAR 标志，自动清除已匹配的位 */
			if (opt & TASK_EVENT_FLAG_CLEAR)
			{
				p->bits &= ~set;
			}

			break;
		}

		/* 非阻塞模式：立即返回失败 */
		if (timeout_ms == 0)
		{
			ret = -1;

			break;
		}

		/* 等待条件变量 */
		if (timeout_ms == TASK_EVENT_WAIT_FOREVER)
		{
			ret = pthread_cond_wait(&p->cond, &p->lock);
		}
		else
		{
			ret = pthread_cond_timedwait(&p->cond, &p->lock, &ts);

			if (ret == ETIMEDOUT)
			{
				ret = -1;

				break;
			}
		}

		if (ret != 0)
		{
			break;
		}
	}

	pthread_mutex_unlock(&p->lock);

	return ret;
}

/**
 * @brief  清除指定事件位
 */
int task_event_clear(stru_task_event_t p_event, uint32_t event)
{
	if (!p_event)
	{
		LOG_E("task_event_clear: p_event is NULL");

		return -1;
	}

	stru_task_event *p = (stru_task_event *)p_event;

	pthread_mutex_lock(&p->lock);
	p->bits &= ~event;
	pthread_mutex_unlock(&p->lock);

	return 0;
}

/**
 * @brief  查询当前事件位（非阻塞）
 */
uint32_t task_event_query(stru_task_event_t p_event)
{
	if (!p_event)
	{
		return 0;
	}

	stru_task_event *p = (stru_task_event *)p_event;

	pthread_mutex_lock(&p->lock);
	uint32_t bits = p->bits;
	pthread_mutex_unlock(&p->lock);

	return bits;
}

/*******************************************************************************
 * 消息队列子系统的公开 API 实现
 ******************************************************************************/

/**
 * @brief  创建定长消息队列
 */
stru_task_msg_queue_t task_msg_queue_create(const char *name,
                                            uint32_t msg_size, uint32_t msg_num)
{
	if (!name || msg_size == 0 || msg_num == 0)
	{
		LOG_E("task_msg_queue_create: invalid params");

		return NULL;
	}

	uint32_t total = msg_size * msg_num;

	stru_task_msg_queue *p = (stru_task_msg_queue *)calloc(1, sizeof(*p));

	if (!p)
	{
		return NULL;
	}

	p->buf = (uint8_t *)malloc(total);

	if (!p->buf)
	{
		free(p);

		return NULL;
	}

	strncpy(p->name, name, sizeof(p->name) - 1);
	p->msg_size  = msg_size;
	p->max_msgs  = msg_num;
	p->msg_count = 0;
	p->head      = 0;
	p->tail      = 0;
	p->ref_count = 1;

	pthread_mutex_init(&p->lock, NULL);
	pthread_cond_init(&p->cond, NULL);

	return (stru_task_msg_queue_t)p;
}

/**
 * @brief  销毁消息队列（带引用计数保护）
 */
int task_msg_queue_destroy(stru_task_msg_queue_t p_queue)
{
	if (!p_queue)
	{
		return -1;
	}

	stru_task_msg_queue *p = (stru_task_msg_queue *)p_queue;

	pthread_mutex_lock(&p->lock);

	p->ref_count--;

	if (p->ref_count > 0)
	{
		pthread_mutex_unlock(&p->lock);

		return 0;
	}

	pthread_mutex_unlock(&p->lock);
	pthread_mutex_destroy(&p->lock);
	pthread_cond_destroy(&p->cond);
	free(p->buf);
	free(p);

	return 0;
}

/**
 * @brief  发送消息（队列满时阻塞等待，无超时版本）
 */
int task_msg_queue_send(stru_task_msg_queue_t p_queue, const void *msg,
                        uint32_t size)
{
	if (!p_queue || !msg || size == 0)
	{
		return -1;
	}

	stru_task_msg_queue *p = (stru_task_msg_queue *)p_queue;

	pthread_mutex_lock(&p->lock);

	/* 队列满则阻塞等待 */
	while (p->msg_count >= p->max_msgs)
	{
		pthread_cond_wait(&p->cond, &p->lock);
	}

	/* 写入消息：先写长度前缀，再写消息体 */
	uint8_t *dst = p->buf + (p->tail * p->msg_size);

	memcpy(dst, &size, sizeof(size));
	dst += sizeof(size);
	memcpy(dst, msg, size);

	p->tail = (p->tail + 1) % p->max_msgs;
	p->msg_count++;

	pthread_cond_signal(&p->cond);
	pthread_mutex_unlock(&p->lock);

	return 0;
}

/**
 * @brief  发送消息（带超时）
 */
int task_msg_queue_send_timeout(stru_task_msg_queue_t p_queue, const void *msg,
                                uint32_t size, uint32_t timeout_ms)
{
	if (!p_queue || !msg || size == 0)
	{
		return -1;
	}

	stru_task_msg_queue *p = (stru_task_msg_queue *)p_queue;
	struct timespec      ts;
	int                  ret = 0;

	pthread_mutex_lock(&p->lock);

	/* 非阻塞：队列满直接返回 */
	if (p->msg_count >= p->max_msgs)
	{
		if (timeout_ms == 0)
		{
			pthread_mutex_unlock(&p->lock);

			return -1;
		}

		/* 计算绝对超时时间 */
		if (timeout_ms != TASK_EVENT_WAIT_FOREVER)
		{
			clock_gettime(CLOCK_REALTIME, &ts);
			ts.tv_sec  += timeout_ms / 1000;
			ts.tv_nsec += (timeout_ms % 1000) * 1000000;

			if (ts.tv_nsec >= 1000000000)
			{
				ts.tv_sec++;
				ts.tv_nsec -= 1000000000;
			}
		}

		/* 阻塞等待空间或超时 */
		while (p->msg_count >= p->max_msgs)
		{
			if (timeout_ms == TASK_EVENT_WAIT_FOREVER)
			{
				ret = pthread_cond_wait(&p->cond, &p->lock);
			}
			else
			{
				ret = pthread_cond_timedwait(&p->cond, &p->lock, &ts);

				if (ret == ETIMEDOUT)
				{
					pthread_mutex_unlock(&p->lock);

					return -1;
				}
			}

			if (ret != 0)
			{
				pthread_mutex_unlock(&p->lock);

				return -1;
			}
		}
	}

	/* 写入消息 */
	uint8_t *dst = p->buf + (p->tail * p->msg_size);

	memcpy(dst, &size, sizeof(size));
	dst += sizeof(size);
	memcpy(dst, msg, size);

	p->tail = (p->tail + 1) % p->max_msgs;
	p->msg_count++;

	pthread_cond_signal(&p->cond);
	pthread_mutex_unlock(&p->lock);

	return 0;
}

/**
 * @brief  接收消息（带超时）
 */
int task_msg_queue_recv(stru_task_msg_queue_t p_queue, void *msg,
                        uint32_t size, uint32_t timeout_ms)
{
	if (!p_queue || !msg || size == 0)
	{
		return -1;
	}

	stru_task_msg_queue *p = (stru_task_msg_queue *)p_queue;
	struct timespec      ts;
	int                  ret      = 0;
	uint32_t             msg_len  = 0;
	uint8_t             *src;

	pthread_mutex_lock(&p->lock);

	/* 计算绝对超时时间 */
	if (timeout_ms != TASK_EVENT_WAIT_FOREVER && timeout_ms != 0)
	{
		clock_gettime(CLOCK_REALTIME, &ts);
		ts.tv_sec  += timeout_ms / 1000;
		ts.tv_nsec += (timeout_ms % 1000) * 1000000;

		if (ts.tv_nsec >= 1000000000)
		{
			ts.tv_sec++;
			ts.tv_nsec -= 1000000000;
		}
	}

	/* 等待直到有消息或超时 */
	while (p->msg_count == 0)
	{
		if (timeout_ms == 0)
		{
			pthread_mutex_unlock(&p->lock);

			return -1;
		}

		if (timeout_ms == TASK_EVENT_WAIT_FOREVER)
		{
			ret = pthread_cond_wait(&p->cond, &p->lock);
		}
		else
		{
			ret = pthread_cond_timedwait(&p->cond, &p->lock, &ts);

			if (ret == ETIMEDOUT)
			{
				pthread_mutex_unlock(&p->lock);

				return -1;
			}
		}

		if (ret != 0)
		{
			pthread_mutex_unlock(&p->lock);

			return -1;
		}
	}

	/* 读取消息：先读长度前缀，再读消息体 */
	src = p->buf + (p->head * p->msg_size);

	memcpy(&msg_len, src, sizeof(msg_len));
	src += sizeof(msg_len);

	/* 如果接收缓冲区不够大，截断 */
	if (msg_len > size)
	{
		msg_len = size;
	}

	memcpy(msg, src, msg_len);

	p->head = (p->head + 1) % p->max_msgs;
	p->msg_count--;

	pthread_cond_signal(&p->cond);
	pthread_mutex_unlock(&p->lock);

	return (int)msg_len;
}

/**
 * @brief  尝试接收消息（非阻塞，队列空返回 -1）
 */
int task_msg_queue_try_recv(stru_task_msg_queue_t p_queue, void *msg,
                            uint32_t size)
{
	return task_msg_queue_recv(p_queue, msg, size, 0);
}

/**
 * @brief  获取当前队列消息数
 */
uint32_t task_msg_queue_get_count(stru_task_msg_queue_t p_queue)
{
	if (!p_queue)
	{
		return 0;
	}

	stru_task_msg_queue *p = (stru_task_msg_queue *)p_queue;

	pthread_mutex_lock(&p->lock);
	uint32_t cnt = p->msg_count;
	pthread_mutex_unlock(&p->lock);

	return cnt;
}

/**
 * @brief  获取队列剩余空间
 */
uint32_t task_msg_queue_space(stru_task_msg_queue_t p_queue)
{
	if (!p_queue)
	{
		return 0;
	}

	stru_task_msg_queue *p = (stru_task_msg_queue *)p_queue;

	pthread_mutex_lock(&p->lock);
	uint32_t sp = p->max_msgs - p->msg_count;
	pthread_mutex_unlock(&p->lock);

	return sp;
}

/*******************************************************************************
 * 定时器子系统的公开 API 实现
 ******************************************************************************/

/**
 * @brief  创建定时器
 */
stru_task_timer_t task_timer_create(const char *name, timer_func_cb fun_cb,
                                    void *arg, uint32_t timeout_ms, int flags)
{
	if (!name || !fun_cb || timeout_ms == 0)
	{
		LOG_E("task_timer_create: invalid params");

		return NULL;
	}

	timer_manager_ensure();

	stru_task_timer *p = (stru_task_timer *)calloc(1, sizeof(*p));

	if (!p)
	{
		return NULL;
	}

	strncpy(p->name, name, sizeof(p->name) - 1);
	p->cb         = fun_cb;
	p->arg        = arg;
	p->timeout_ms = timeout_ms;
	p->flags      = flags;
	p->active     = 0;
	p->ref_count  = 1;

	p->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);

	if (p->timerfd < 0)
	{
		LOG_E("timerfd_create failed");
		free(p);

		return NULL;
	}

	pthread_mutex_init(&p->lock, NULL);

	return (stru_task_timer_t)p;
}

/**
 * @brief  启动定时器
 */
int task_timer_start(stru_task_timer_t p_timer)
{
	if (!p_timer)
	{
		return -1;
	}

	stru_task_timer *p = (stru_task_timer *)p_timer;

	while (g_timer_epfd < 0) { usleep(1000); }

	while (g_timer_epfd < 0)
	{
		usleep(1000);
	}

	pthread_mutex_lock(&p->lock);

	/* 设置 timerfd 定时参数 */
	struct itimerspec its;

	memset(&its, 0, sizeof(its));
	its.it_value.tv_sec  = p->timeout_ms / 1000;
	its.it_value.tv_nsec = (p->timeout_ms % 1000) * 1000000;

	/* 周期模式下设置间隔 */
	if (p->flags & TASK_TIMER_FLAG_PERIODIC)
	{
		its.it_interval.tv_sec  = p->timeout_ms / 1000;
		its.it_interval.tv_nsec = (p->timeout_ms % 1000) * 1000000;
	}

	timerfd_settime(p->timerfd, 0, &its, NULL);

	/* 加入 epoll 监听 */
	if (!p->running)
	{
		struct epoll_event ev;

		memset(&ev, 0, sizeof(ev));
		ev.events   = EPOLLIN;
		ev.data.ptr = p;

		epoll_ctl(g_timer_epfd, EPOLL_CTL_ADD, p->timerfd, &ev);
		p->running = 1;
	}

	p->active = 1;

	/* 通过 eventfd 唤醒 epoll 线程 */
	uint64_t one = 1;

	write(g_timer_evtfd, &one, sizeof(one));

	pthread_mutex_unlock(&p->lock);

	return 0;
}

/**
 * @brief  停止定时器
 */
int task_timer_stop(stru_task_timer_t p_timer)
{
	if (!p_timer)
	{
		return -1;
	}

	stru_task_timer *p = (stru_task_timer *)p_timer;

	pthread_mutex_lock(&p->lock);

	/* 从 epoll 移除 */
	if (p->running)
	{
		epoll_ctl(g_timer_epfd, EPOLL_CTL_DEL, p->timerfd, NULL);
		p->running = 0;
	}

	/* 停止 timerfd */
	struct itimerspec its;

	memset(&its, 0, sizeof(its));
	timerfd_settime(p->timerfd, 0, &its, NULL);
	p->active = 0;

	pthread_mutex_unlock(&p->lock);

	return 0;
}

/**
 * @brief  重启定时器（可修改周期）
 */
int task_timer_restart(stru_task_timer_t p_timer, uint32_t timeout_ms)
{
	if (!p_timer || timeout_ms == 0)
	{
		return -1;
	}

	stru_task_timer *p = (stru_task_timer *)p_timer;

	pthread_mutex_lock(&p->lock);

	p->timeout_ms = timeout_ms;

	/* 重新设置 timerfd */
	struct itimerspec its;

	memset(&its, 0, sizeof(its));
	its.it_value.tv_sec  = timeout_ms / 1000;
	its.it_value.tv_nsec = (timeout_ms % 1000) * 1000000;

	if (p->flags & TASK_TIMER_FLAG_PERIODIC)
	{
		its.it_interval.tv_sec  = timeout_ms / 1000;
		its.it_interval.tv_nsec = (timeout_ms % 1000) * 1000000;
	}

	timerfd_settime(p->timerfd, 0, &its, NULL);

	/* 如果不在 epoll 中则加入 */
	if (!p->running)
	{
		struct epoll_event ev;

		memset(&ev, 0, sizeof(ev));
		ev.events   = EPOLLIN;
		ev.data.ptr = p;

		epoll_ctl(g_timer_epfd, EPOLL_CTL_ADD, p->timerfd, &ev);
		p->running = 1;
	}

	p->active = 1;

	pthread_mutex_unlock(&p->lock);

	return 0;
}

/**
 * @brief  销毁定时器（带引用计数保护）
 */
int task_timer_destroy(stru_task_timer_t p_timer)
{
	if (!p_timer)
	{
		return -1;
	}

	stru_task_timer *p = (stru_task_timer *)p_timer;

	pthread_mutex_lock(&p->lock);

	if (p->running)
	{
		epoll_ctl(g_timer_epfd, EPOLL_CTL_DEL, p->timerfd, NULL);
		p->running = 0;
	}

	close(p->timerfd);
	p->active = 0;

	pthread_mutex_unlock(&p->lock);
	pthread_mutex_destroy(&p->lock);
	free(p);

	return 0;
}

/**
 * @brief  查询定时器是否在运行
 */
int task_timer_is_active(stru_task_timer_t p_timer)
{
	if (!p_timer)
	{
		return 0;
	}

	stru_task_timer *p = (stru_task_timer *)p_timer;

	pthread_mutex_lock(&p->lock);
	int a = p->active;
	pthread_mutex_unlock(&p->lock);

	return a;
}
