// SPDX-License-Identifier: GPL-2.0

/******************************************************************************
 *
 * Copyright (C) 2020 SeekWave Technology Co.,Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 ******************************************************************************/

#include <linux/skbuff.h>
#include <net/cfg80211.h>

#include "skw_core.h"
#include "skw_timer.h"
#include "skw_msg.h"
#include "skw_mlme.h"

static int skw_timer_show(struct seq_file *seq, void *data)
{
	struct skw_timer *timer;
	struct skw_core *skw = seq->private;

	seq_printf(seq, "count: %d\n", skw->timer_data.count);

	if (!skw->timer_data.count)
		return 0;

	spin_lock_bh(&skw->timer_data.lock);
	list_for_each_entry(timer, &skw->timer_data.list, list) {
		seq_puts(seq, "\n");

		seq_printf(seq, "name: %s\n"
				"id: 0x%p\n"
				"time left: %u ms\n",
				timer->name,
				timer->id,
				jiffies_to_msecs(timer->timeout - jiffies));
	}

	spin_unlock_bh(&skw->timer_data.lock);

	return 0;
}

static int skw_timer_open(struct inode *inode, struct file *file)
{
	return single_open(file, skw_timer_show, inode->i_private);
}

static const struct file_operations skw_timer_fops = {
	.owner = THIS_MODULE,
	.open = skw_timer_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 15, 0)
static void skw_timer_work(struct timer_list *data)
#else
static void skw_timer_work(unsigned long data)
#endif
{
	struct skw_core *skw;
	struct skw_timer *timer, *next;
	LIST_HEAD(timeout_list);

	skw = container_of((void *)data, struct skw_core, timer_data.timer);

	spin_lock_bh(&skw->timer_data.lock);
	list_for_each_entry_safe(timer, next, &skw->timer_data.list, list) {
		if (time_before(jiffies, timer->timeout))
			break;

		list_move(&timer->list, &timeout_list);
	}

	spin_unlock_bh(&skw->timer_data.lock);

	while (!list_empty(&timeout_list)) {
		timer = list_first_entry(&timeout_list, struct skw_timer, list);
		skw_log(SKW_TIMER, "[%s] %s: %s(id: 0x%p)\n",
			SKW_TAG_TIMER, __func__, timer->name, timer->id);
		list_del(&timer->list);

		timer->cb(timer->data);
		skw->timer_data.count--;

		SKW_KFREE(timer);
	}

	spin_lock_bh(&skw->timer_data.lock);
	timer = list_first_entry_or_null(&skw->timer_data.list, struct skw_timer, list);
	if (timer)
		mod_timer(&skw->timer_data.timer, timer->timeout);

	spin_unlock_bh(&skw->timer_data.lock);
}

static bool skw_timer_id_exist(struct skw_core *skw, void *id)
{
	bool result = false;
	struct skw_timer *timer;

	spin_lock_bh(&skw->timer_data.lock);

	list_for_each_entry(timer, &skw->timer_data.list, list) {
		if (id == timer->id) {
			result = true;
			break;
		}
	}

	spin_unlock_bh(&skw->timer_data.lock);

	return result;
}

int skw_add_timer_work(struct skw_core *skw, const char *name,
		       void (*cb)(void *dat), void *data,
		       unsigned long timeout, void *timer_id, gfp_t flags)
{
	struct skw_timer *timer, *node;
	struct list_head *head;

	if (!timer_id || !cb || !name)
		return -EINVAL;

	skw_log(SKW_TIMER, "[%s] %s: %s(id: 0x%p), time out = %ld\n",
		SKW_TAG_TIMER, __func__, name, timer_id, timeout);

	if (skw_timer_id_exist(skw, timer_id)) {
		skw_warn("id: 0x%p exist\n", timer_id);
		SKW_BUG_ON(1);

		return -EINVAL;
	}

	timer = SKW_ZALLOC(sizeof(*timer), flags);
	if (!timer)
		return -ENOMEM;

	INIT_LIST_HEAD(&timer->list);

	timer->name = name;
	timer->cb = cb;
	timer->data = data;
	timer->id = timer_id;
	timer->timeout = msecs_to_jiffies(timeout) + jiffies + 1;

	spin_lock_bh(&skw->timer_data.lock);
	head = &skw->timer_data.list;

	list_for_each_entry(node, &skw->timer_data.list, list) {
		if (time_before_eq(timer->timeout, node->timeout)) {
			head = &node->list;
			break;
		}
	}

	list_add(&timer->list, head);

	skw->timer_data.count++;
	node = list_first_entry(&skw->timer_data.list, struct skw_timer, list);

	mod_timer(&skw->timer_data.timer, node->timeout);
	spin_unlock_bh(&skw->timer_data.lock);

	return 0;
}

void skw_del_timer_work(struct skw_core *skw, void *timer_id)
{
	struct skw_timer *timer;

	skw_log(SKW_TIMER, "[%s] %s: id: 0x%p\n",
		SKW_TAG_TIMER, __func__, timer_id);

	spin_lock_bh(&skw->timer_data.lock);
	list_for_each_entry(timer, &skw->timer_data.list, list) {
		if (timer->id == timer_id) {
			list_del(&timer->list);
			skw->timer_data.count--;
			SKW_KFREE(timer);
			break;
		}
	}

	timer = list_first_entry_or_null(&skw->timer_data.list, struct skw_timer, list);
	if (timer)
		mod_timer(&skw->timer_data.timer, timer->timeout);

	spin_unlock_bh(&skw->timer_data.lock);
}

void skw_timer_init(struct skw_core *skw)
{
	// skw->timer_work.timeout = LONG_MAX;
	skw->timer_data.count = 0;

	INIT_LIST_HEAD(&skw->timer_data.list);
	spin_lock_init(&skw->timer_data.lock);

	// fixme:
	// timer_setup(&skw->timer_data.timer, skw->timer_data.timer_work, 0);
	skw_compat_setup_timer(&skw->timer_data.timer, skw_timer_work);

	skw_debugfs_file(skw->dentry, "timer", 04444, &skw_timer_fops, skw);
}

void skw_timer_deinit(struct skw_core *skw)
{
	LIST_HEAD(flush_list);

	del_timer(&skw->timer_data.timer);

	spin_lock_bh(&skw->timer_data.lock);
	list_replace_init(&skw->timer_data.list, &flush_list);
	spin_unlock_bh(&skw->timer_data.lock);

	while (!list_empty(&flush_list)) {
		struct skw_timer *timer = list_first_entry(&flush_list,
			struct skw_timer, list);

		list_del(&timer->list);

		skw_log(SKW_TIMER, "[%s] %s: name: %s\n",
			SKW_TAG_TIMER, __func__, timer->name);

		SKW_KFREE(timer);
	}
}