/*
 * Copyright 2014, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Lin Longzhou, linlongzhou@163.com
 */


#include <errno.h>
#include <stdlib.h>
#include <net/if_dl.h>
#include <net/if_media.h>
#include <net/if_types.h>
#include <new>

#include <ethernet.h>
#include <ether_driver.h>
#include <net_buffer.h>
#include <net_datalink_protocol.h>

#include <NetBufferUtilities.h>
#include <net_stack.h>

#include <KernelExport.h>

#include <KPPPManager.h>
#include <ppp_device.h>

#define PPP_HEADER_LENGTH (8 + ETHER_HEADER_LENGTH)


net_buffer* create_buffer_for_frame(uint8 *frame, uint16 frame_size);

static const bigtime_t kLinkCheckInterval = 1000000;
	// 1 second

net_buffer_module_info *gBufferModule;
ppp_interface_module_info* gPPPInterfaceModule;
static net_stack_module_info *sStackModule;

static mutex sListLock;
static DoublyLinkedList<ppp_device> sCheckList;
static sem_id sLinkChangeSemaphore;
static thread_id sLinkCheckerThread;


//	#pragma mark -
//

status_t
ppp_init(const char *name, net_device **_device)
{
	// ppp device
	dprintf("%s: entering!\n", __func__);

	if (strncmp(name, "ppp", 3)) {
		dprintf("[%s] not ppp device\n", name);
		return B_BAD_VALUE;
	}

	dprintf("[%s] is ppp device\n", name);

	status_t status = get_module(NET_BUFFER_MODULE_NAME, (module_info **)&gBufferModule);
	if (status < B_OK)
		return status;

	// ppp_device *device = new (std::nothrow) ppp_device;
	ppp_interface_id idInterface = gPPPInterfaceModule->CreateInterfaceWithName(name, 0);
	KPPPInterface * pppInterface = gPPPInterfaceModule->GetInterface(idInterface);

	if (idInterface <= 0 || pppInterface == NULL) {
		if (idInterface <= 0)
			dprintf("%s: idInterface: %" B_PRIu32 "\n", __func__, idInterface);
		else
			dprintf("%s: pppInterface == NULL %" B_PRIu32 "\n", __func__, idInterface);
		put_module(NET_BUFFER_MODULE_NAME);
		return B_NO_MEMORY;
	}

	// Ifnet available until interface up phase
	ppp_device *device = (ppp_device *)pppInterface->Ifnet();
	if (device == NULL) {
		dprintf("%s: can not get ppp_device\n", __func__);
		put_module(NET_BUFFER_MODULE_NAME);
		return B_NO_MEMORY;
	}

	strcpy(device->name, name);
	device->flags = (IFF_BROADCAST | IFF_LINK) & (~IFF_UP);
	device->type = IFT_PPP;
	device->mtu = 1492;
	device->frame_size = 1500;
	device->media = IFM_ACTIVE | IFM_ETHER;
	device->header_length = PPP_HEADER_LENGTH;

	status =sStackModule->init_fifo(&(device->ppp_fifo), "ppp_fifo", 10 * 1500);
		// 10 ppp packet at most
	if (status < B_OK)
		return(status);

	TRACE("[%s] finish\n", "allocate ppp_device");
	*_device = device;

	return B_OK;
}


status_t
ppp_uninit(net_device *device)
{
	dprintf("%s:  uninit ppp\n", __func__);
	ppp_device *ppp_dev=(ppp_device *)device;

	sStackModule->uninit_fifo(&(ppp_dev->ppp_fifo));
	put_module(NET_BUFFER_MODULE_NAME);

	// delete ppp_dev->KPPP_Interface;
	delete ppp_dev;

	return B_OK;
}


status_t
ppp_up(net_device *_device)
{
	dprintf("ppp_up\n");
	ppp_device *device = (ppp_device *)_device;

	if (device->KPPP_Interface == NULL) {
		dprintf("%s: warning! can not find pppinterface KPPP_Interface\n", __func__);
		return B_ERROR;
	}

	if (device->KPPP_Interface->Up() != true) {
		dprintf("%s: warning! KPPP_Interface->Up() failure\n", __func__);
		return B_ERROR;
	}

	device->mtu = device->frame_size - device->header_length;
	// s_pppoe_dev = device;

	dprintf("%s: congratulations! Find pppinterface (device->KPPP_Interface)\n", __func__);

	return B_OK;
}


void
ppp_down(net_device *_device)
{
	dprintf("%s\n", __func__);
	ppp_device *device = (ppp_device *)_device;
	device->KPPP_Interface->Down();

	MutexLocker _(sListLock);

	// if the device is still part of the list, remove it
	if (device->GetDoublyLinkedListLink()->next != NULL
		|| device->GetDoublyLinkedListLink()->previous != NULL
		|| device == sCheckList.Head())
		sCheckList.Remove(device);

	// device->KPPP_Interface = NULL;

	return;
}


status_t
ppp_control(net_device *_device, int32 op, void *argument,
	size_t length)
{
	TRACE("%s op:%" B_PRId32 "\n", __func__, op);
	ppp_device *device = (ppp_device *)_device;

	if (device->KPPP_Interface == NULL) {
		dprintf("%s: can not find KPPP_Interface for ppp\n", __func__);
		return B_OK;
	}

	return device->KPPP_Interface->Control(op, argument, length);

	return B_OK;
}


status_t
ppp_send_data(net_device *_device, net_buffer *buffer)
{
	TRACE("%s\n", __func__);
	ppp_device *device = (ppp_device *)_device;

	if (buffer->size > device->frame_size || buffer->size < device->header_length) {
		dprintf("sorry! fail send ppp packet, size wrong!\n");
		return EMSGSIZE;
	}

	if (device->KPPP_Interface == NULL) {
		dprintf("Fail send ppp packet, no eth for ppp!\n");
		return B_BAD_VALUE;
	}

	size_t net_buffer_size = buffer->size;
		// store buffer->size in case buffer freed in KPPP_Interface->Send
	status_t status = device->KPPP_Interface->Send(buffer, 0x0021); // IP_PROTOCOL 0x0021

	if (status != B_OK) {
		dprintf("KPPP_Interface->Send(buffer, 0x0021 IP) fail\n");
		return B_BAD_VALUE;
	}

	return B_OK;
}


status_t
ppp_receive_data(net_device *_device, net_buffer **_buffer)
{
	TRACE("%s\n", __func__);
	ppp_device *device = (ppp_device *)_device;

	if (device->KPPP_Interface == NULL)
		return B_FILE_ERROR;

	TRACE("%s: trying fifo_dequeue_buffer\n", __func__);
	status_t status = sStackModule->fifo_dequeue_buffer(&(device->ppp_fifo), 0, 10000000, _buffer);

	if (status < B_OK) {
		TRACE("sorry! can not fifo_dequeue_buffer!\n");
		return status;
	}

	// (*_buffer)->interface_address = NULL; // strange need to put here

	return B_OK;
}


status_t
ppp_set_mtu(net_device *_device, size_t mtu)
{
	ppp_device *device = (ppp_device *)_device;

	if (mtu > device->frame_size - ETHER_HEADER_LENGTH - 8
		|| mtu <= ETHER_HEADER_LENGTH + 8 + 10)
		return B_BAD_VALUE;

	device->mtu = mtu;
	return B_OK;
}


status_t
ppp_set_promiscuous(net_device *_device, bool promiscuous)
{
	return B_NOT_SUPPORTED;
}


status_t
ppp_set_media(net_device *device, uint32 media)
{
	return B_NOT_SUPPORTED;
}


status_t
ppp_add_multicast(struct net_device *_device, const sockaddr *_address)
{
	// ppp_device *device = (ppp_device *)_device;

	if (_address->sa_family != AF_LINK)
		return B_BAD_VALUE;

	const sockaddr_dl *address = (const sockaddr_dl *)_address;
	if (address->sdl_type != IFT_ETHER)
		return B_BAD_VALUE;

	return B_NOT_SUPPORTED;
}


status_t
ppp_remove_multicast(struct net_device *_device, const sockaddr *_address)
{
	// ppp_device *device = (ppp_device *)_device;

	if (_address->sa_family != AF_LINK)
		return B_BAD_VALUE;

	const sockaddr_dl *address = (const sockaddr_dl *)_address;
	if (address->sdl_type != IFT_ETHER)
		return B_BAD_VALUE;

	return B_NOT_SUPPORTED;
}


static status_t
ppp_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
		{
			status_t status = get_module(NET_STACK_MODULE_NAME,
				(module_info **)&sStackModule);
			if (status < B_OK)
				return status;

			status = get_module(PPP_INTERFACE_MODULE_NAME,
				(module_info**)&gPPPInterfaceModule);
			if (status < B_OK) {
				put_module(NET_STACK_MODULE_NAME);
				return status;
			}

			new (&sCheckList) DoublyLinkedList<ppp_device>;
				// static C++ objects are not initialized in the module startup

			sLinkCheckerThread = -1;

			sLinkChangeSemaphore = create_sem(0, "ppp link change");
			if (sLinkChangeSemaphore < B_OK) {
				put_module(PPP_INTERFACE_MODULE_NAME);
				put_module(NET_STACK_MODULE_NAME);
				return sLinkChangeSemaphore;
			}

			mutex_init(&sListLock, "ppp devices");

			return B_OK;
		}

		case B_MODULE_UNINIT:
		{
			delete_sem(sLinkChangeSemaphore);

			status_t status;
			wait_for_thread(sLinkCheckerThread, &status);

			mutex_destroy(&sListLock);

			put_module(PPP_INTERFACE_MODULE_NAME);
			put_module(NET_STACK_MODULE_NAME);
			return B_OK;
		}

		default:
			return B_ERROR;
	}
}


net_device_module_info spppModule = {
	{
		"network/devices/ppp/v1",
		0,
		ppp_std_ops
	},
	ppp_init,
	ppp_uninit,
	ppp_up,
	ppp_down,
	ppp_control,
	ppp_send_data,
	ppp_receive_data,
	ppp_set_mtu,
	ppp_set_promiscuous,
	ppp_set_media,
	ppp_add_multicast,
	ppp_remove_multicast,
};


module_info *modules[] = {
	(module_info *)&spppModule,
	NULL
};