#include "stdafx.h"
#include "Emu/IdManager.h"

#include "Emu/Cell/lv2/sys_event.h"
#include "Emu/Cell/ErrorCodes.h"

#include "sys_config.h"

LOG_CHANNEL(sys_config);


// Enums
template<>
void fmt_class_string<sys_config_service_id>::format(std::string& out, u64 id)
{
	const s64 s_id = static_cast<s64>(id);

	switch (s_id)
	{
	case SYS_CONFIG_SERVICE_PADMANAGER   : out += "SYS_CONFIG_SERVICE_PADMANAGER"; return;
	case SYS_CONFIG_SERVICE_PADMANAGER2  : out += "SYS_CONFIG_SERVICE_PADMANAGER2"; return;
	case SYS_CONFIG_SERVICE_USER_LIBPAD  : out += "SYS_CONFIG_SERVICE_USER_LIBPAD"; return;
	case SYS_CONFIG_SERVICE_USER_LIBKB   : out += "SYS_CONFIG_SERVICE_USER_LIBKB"; return;
	case SYS_CONFIG_SERVICE_USER_LIBMOUSE: out += "SYS_CONFIG_SERVICE_USER_LIBMOUSE"; return;
	}

	if (s_id < 0)
	{
		fmt::append(out, "SYS_CONFIG_SERVICE_USER_%llx", id & ~(1ull << 63));
	}
	else
	{
		fmt::append(out, "SYS_CONFIG_SERVICE_%llx", id);
	}
}

template<>
void fmt_class_string<sys_config_service_listener_type>::format(std::string& out, u64 arg)
{
	format_enum(out, arg, [](auto value)
	{
		switch (value)
		{
			STR_CASE(SYS_CONFIG_SERVICE_LISTENER_ONCE);
			STR_CASE(SYS_CONFIG_SERVICE_LISTENER_REPEATING);
		}

		return unknown;
	});
}

// Utilities
void dump_buffer(std::string& out, const std::vector<u8>& buffer)
{
	if (!buffer.empty())
	{
		out.reserve(out.size() + buffer.size() * 2 + 1);
		fmt::append(out, "0x");

		for (u8 x : buffer)
		{
			fmt::append(out, "%02x", x);
		}
	}
	else
	{
		fmt::append(out, "EMPTY");
	}
}


// LV2 Config
void lv2_config::initialize()
{
	if (m_state || !m_state.compare_and_swap_test(0, 1))
	{
		return;
	}

	// Register padmanager service, notifying vsh that a controller is connected
	static const u8 hid_info[0x1a] = {
		0x01, 0x01, //  2 unk
		0x02, 0x02, //  4
		0x00, 0x00, //  6
		0x00, 0x00, //  8
		0x00, 0x00, // 10
		0x05, 0x4c, // 12 vid
		0x02, 0x68, // 14 pid
		0x00, 0x10, // 16 unk2
		0x91, 0x88, // 18
		0x04, 0x00, // 20
		0x00, 0x07, // 22
		0x00, 0x00, // 24
		0x00, 0x00  // 26
	};

	// user_id for the padmanager seems to signify the controller port number, and the buffer contains some sort of HID descriptor
	lv2_config_service::create(SYS_CONFIG_SERVICE_PADMANAGER , 0, 1, 0, hid_info, 0x1a)->notify();
	lv2_config_service::create(SYS_CONFIG_SERVICE_PADMANAGER2, 0, 1, 0, hid_info, 0x1a)->notify();
}

void lv2_config::add_service_event(shared_ptr<lv2_config_service_event> event)
{
	std::lock_guard lock(m_mutex);
	events.emplace(event->id, std::move(event));
}

void lv2_config::remove_service_event(u32 id)
{
	shared_ptr<lv2_config_service_event> ptr;

	std::lock_guard lock(m_mutex);

	if (auto it = events.find(id); it != events.end())
	{
		ptr = std::move(it->second);
		events.erase(it);
	}
}

lv2_config_service_event& lv2_config_service_event::operator=(thread_state s) noexcept
{
	if (s == thread_state::destroying_context && !m_destroyed.exchange(true))
	{
		if (auto global = g_fxo->try_get<lv2_config>())
		{
			global->remove_service_event(id);
		}
	}

	return *this;
}

lv2_config_service_event::~lv2_config_service_event() noexcept
{
	operator=(thread_state::destroying_context);
}

lv2_config::~lv2_config() noexcept
{
	for (auto& [key, event] : events)
	{
		if (event)
		{
			// Avoid collision with lv2_config_service_event destructor
			event->m_destroyed = true;
		}
	}
}

// LV2 Config Service Listener
bool lv2_config_service_listener::check_service(const lv2_config_service& service) const
{
	// Filter by type
	if (type == SYS_CONFIG_SERVICE_LISTENER_ONCE && !service_events.empty())
	{
		return false;
	}

	// Filter by service ID or verbosity
	if (service_id != service.id || min_verbosity > service.verbosity)
	{
		return false;
	}

	// realhw only seems to send the pad connected events to the listeners that provided 0x01 as the first byte of their data buffer
	// TODO: Figure out how this filter works more properly
	if (service_id == SYS_CONFIG_SERVICE_PADMANAGER && (data.empty() || data[0] != 0x01))
	{
		return false;
	}

	// Event applies to this listener!
	return true;
}

bool lv2_config_service_listener::notify(const shared_ptr<lv2_config_service>& service)
{
	{
		std::lock_guard lock(mutex_service_events);

		if (!check_service(*service))
			return false;

		// Create service event and notify queue!
		const auto event = lv2_config_service_event::create(handle, service, *this);
		service_events.emplace_back(event);

		if (!event->notify())
		{
			// If we fail to deliver the event to the queue just clean the event up or it'll hold the listener alive forever
			g_fxo->get<lv2_config>().remove_service_event(event->id);
			service_events.pop_back();
			return false;
		}
	}
	
	return true;
}

void lv2_config_service_listener::notify_all()
{
	std::vector<shared_ptr<lv2_config_service>> services;

	// Grab all events
	idm::select<lv2_config_service>([&](u32 /*id*/, lv2_config_service& service)
	{
		if (check_service(service))
		{
			services.push_back(service.get_shared_ptr());
		}
	});

	// Sort services by timestamp
	sort(services.begin(), services.end(), [](const shared_ptr<lv2_config_service>& s1, const shared_ptr<lv2_config_service>& s2)
	{
		return s1->timestamp < s2->timestamp;
	});

	// Notify listener (now with services in sorted order)
	for (auto& service : services)
	{
		this->notify(service);
	}
}


// LV2 Config Service
void lv2_config_service::unregister()
{
	registered = false;

	// Notify listeners
	notify();

	// Allow this object to be destroyed by withdrawing it from the IDM
	// Note that it won't be destroyed while there are service events that hold a reference to it
	idm::remove<lv2_config_service>(idm_id);
}

void lv2_config_service::notify() const
{
	std::vector<shared_ptr<lv2_config_service_listener>> listeners;

	const shared_ptr<lv2_config_service> sptr = get_shared_ptr();

	idm::select<lv2_config_service_listener>([&](u32 /*id*/, lv2_config_service_listener& listener)
	{
		if (listener.check_service(*sptr))
			listeners.push_back(listener.get_shared_ptr());
	});

	for (auto& listener : listeners)
	{
		listener->notify(sptr);
	}
}

bool lv2_config_service_event::notify() const
{
	const auto _handle = handle;

	if (!_handle)
	{
		return false;
	}

	// Send event
	return _handle->notify(SYS_CONFIG_EVENT_SOURCE_SERVICE, (static_cast<u64>(service->is_registered()) << 32) | id, service->get_size());
}


// LV2 Config Service Event
void lv2_config_service_event::write(sys_config_service_event_t *dst) const
{
	const auto registered = service->is_registered();

	dst->service_listener_handle = listener_id;
	dst->registered = registered;
	dst->service_id = service->id;
	dst->user_id = service->user_id;

	if (registered)
	{
		dst->verbosity = service->verbosity;
		dst->padding = service->padding;

		const auto size = service->data.size();
		dst->data_size = static_cast<u32>(size);
		memcpy(dst->data, service->data.data(), size);
	}
}




/*
 * Syscalls
 */
error_code sys_config_open(u32 equeue_hdl, vm::ptr<u32> out_config_hdl)
{
	sys_config.trace("sys_config_open(equeue_hdl=0x%x, out_config_hdl=*0x%x)", equeue_hdl, out_config_hdl);

	// Find queue with the given ID
	const auto queue = idm::get_unlocked<lv2_obj, lv2_event_queue>(equeue_hdl);
	if (!queue)
	{
		return CELL_ESRCH;
	}

	// Initialize lv2_config global state
	auto& global = g_fxo->get<lv2_config>();
	if (true)
	{
		global.initialize();
	}

	// Create a lv2_config_handle object
	const auto config = lv2_config_handle::create(std::move(queue));
	if (config)
	{
		*out_config_hdl = idm::last_id();
		return CELL_OK;
	}

	// Failed to allocate sys_config object
	return CELL_EAGAIN;
}

error_code sys_config_close(u32 config_hdl)
{
	sys_config.trace("sys_config_close(config_hdl=0x%x)", config_hdl);

	if (!idm::remove<lv2_config_handle>(config_hdl))
	{
		return CELL_ESRCH;
	}

	return CELL_OK;
}



error_code sys_config_get_service_event(u32 config_hdl, u32 event_id, vm::ptr<sys_config_service_event_t> dst, u64 size)
{
	sys_config.trace("sys_config_get_service_event(config_hdl=0x%x, event_id=0x%llx, dst=*0x%llx, size=0x%llx)", config_hdl, event_id, dst, size);

	// Find sys_config handle object with the given ID
	const auto cfg = idm::get_unlocked<lv2_config_handle>(config_hdl);
	if (!cfg)
	{
		return CELL_ESRCH;
	}

	// Find service_event object
	const auto event = g_fxo->get<lv2_config>().find_event(event_id);
	if (!event || event->handle != cfg)
	{
		return CELL_ESRCH;
	}

	// Check buffer fits
	if (!event->check_buffer_size(size))
	{
		return CELL_EAGAIN;
	}

	// Write event to buffer
	event->write(dst.get_ptr());

	return CELL_OK;
}



error_code sys_config_add_service_listener(u32 config_hdl, sys_config_service_id service_id, u64 min_verbosity, vm::ptr<void> in, u64 size, sys_config_service_listener_type type, vm::ptr<u32> out_listener_hdl)
{
	sys_config.trace("sys_config_add_service_listener(config_hdl=0x%x, service_id=0x%llx, min_verbosity=0x%llx, in=*0x%x, size=%lld, type=0x%llx, out_listener_hdl=*0x%x)", config_hdl, service_id, min_verbosity, in, size, type, out_listener_hdl);

	// Find sys_config handle object with the given ID
	auto cfg = idm::get_unlocked<lv2_config_handle>(config_hdl);
	if (!cfg)
	{
		return CELL_ESRCH;
	}

	// Create service listener
	const auto listener = lv2_config_service_listener::create(cfg, service_id, min_verbosity, type, static_cast<u8*>(in.get_ptr()), size);
	if (!listener)
	{
		return CELL_EAGAIN;
	}

	if (size > 0)
	{
		std::string buf_str;
		dump_buffer(buf_str, listener->data);
		sys_config.todo("Registered service listener for service %llx with non-zero buffer: %s", service_id, buf_str.c_str());
	}

	// Notify listener with all past events
	listener->notify_all();

	// Done!
	*out_listener_hdl = listener->get_id();
	return CELL_OK;
}

error_code sys_config_remove_service_listener(u32 config_hdl, u32 listener_hdl)
{
	sys_config.trace("sys_config_remove_service_listener(config_hdl=0x%x, listener_hdl=0x%x)", config_hdl, listener_hdl);

	// Remove listener from IDM
	if (!idm::remove<lv2_config_service_listener>(listener_hdl))
	{
		return CELL_ESRCH;
	}

	return CELL_OK;
}



error_code sys_config_register_service(u32 config_hdl, sys_config_service_id service_id, u64 user_id, u64 verbosity, vm::ptr<u8> data_buf, u64 size, vm::ptr<u32> out_service_hdl)
{
	sys_config.trace("sys_config_register_service(config_hdl=0x%x, service_id=0x%llx, user_id=0x%llx, verbosity=0x%llx, data_but=*0x%llx, size=%lld, out_service_hdl=*0x%llx)", config_hdl, service_id, user_id, verbosity, data_buf, size, out_service_hdl);

	// Find sys_config handle object with the given ID
	const auto cfg = idm::get_unlocked<lv2_config_handle>(config_hdl);
	if (!cfg)
	{
		return CELL_ESRCH;
	}

	// Create service
	const auto service = lv2_config_service::create(service_id, user_id, verbosity, 0, data_buf.get_ptr(), size);
	if (!service)
	{
		return CELL_EAGAIN;
	}

	// Notify all listeners
	service->notify();

	// Done!
	*out_service_hdl = service->get_id();
	return CELL_OK;
}

error_code sys_config_unregister_service(u32 config_hdl, u32 service_hdl)
{
	sys_config.trace("sys_config_unregister_service(config_hdl=0x%x, service_hdl=0x%x)", config_hdl, service_hdl);

	// Remove listener from IDM
	auto service = idm::withdraw<lv2_config_service>(service_hdl);
	if (!service)
	{
		return CELL_ESRCH;
	}

	// Unregister service
	service->unregister();

	// Done!
	return CELL_OK;
}



/*
 * IO Events - TODO
 */
error_code sys_config_get_io_event(u32 config_hdl, u32 event_id /*?*/, vm::ptr<void> out_buf /*?*/, u64 size /*?*/)
{
	sys_config.todo("sys_config_get_io_event(config_hdl=0x%x, event_id=0x%x, out_buf=*0x%x, size=%lld)", config_hdl, event_id, out_buf, size);
	return CELL_OK;
}

error_code sys_config_register_io_error_listener(u32 config_hdl)
{
	sys_config.todo("sys_config_register_io_error_listener(config_hdl=0x%x)", config_hdl);
	return CELL_OK;
}

error_code sys_config_unregister_io_error_listener(u32 config_hdl)
{
	sys_config.todo("sys_config_unregister_io_error_listener(config_hdl=0x%x)", config_hdl);
	return CELL_OK;
}
