/*
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction, 
 * including without limitation the rights to use, copy, modify, 
 * merge, publish, distribute, sublicense, and/or sell copies of 
 * the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include "DVBMediaAddon.h"
#include "DVBCard.h"
#include "DVBMediaNode.h"
#include "config.h"

#include <string.h>
#include <stdio.h>
#include <time.h>
#include <Alert.h>
#include <Directory.h>
#include <Entry.h>
#include <Path.h>

struct device_info
{
	DVBCard *		card;
	char			name[200];
	char			info[200];
	media_format 	formats[5];
	flavor_info 	flavor;
};


extern "C" BMediaAddOn *
make_media_addon(image_id id)
{
	return new DVBMediaAddon(id);
}


DVBMediaAddon::DVBMediaAddon(image_id id)
	: BMediaAddOn(id)
{
	ScanFolder("/dev/dvb");
}


DVBMediaAddon::~DVBMediaAddon()
{
	FreeDeviceList();
}


status_t
DVBMediaAddon::InitCheck(const char ** out_failure_text)
{
	debugger("");
	if (!fDeviceList.CountItems()) {
		*out_failure_text = "No supported device found";
		return B_ERROR;
	}

	return B_OK;
}


int32
DVBMediaAddon::CountFlavors()
{
	return fDeviceList.CountItems();
}


status_t
DVBMediaAddon::GetFlavorAt(int32 n, const flavor_info ** out_info)
{
	device_info *dev = (device_info *)fDeviceList.ItemAt(n);
	if (!dev)
		return B_ERROR;
	*out_info = &dev->flavor;
	return B_OK;
}

	
BMediaNode *
DVBMediaAddon::InstantiateNodeFor(const flavor_info * info, BMessage * config,	status_t * out_error)
{
	printf("DVB: DVBMediaAddon::InstantiateNodeFor\n");
	
	device_info *dev = (device_info *)fDeviceList.ItemAt(info->internal_id);
	if (!dev || dev->flavor.internal_id != info->internal_id) {
		*out_error = B_ERROR;
		return NULL;
	}
	*out_error = B_OK;
	
	return new DVBMediaNode(this, dev->name, dev->flavor.internal_id, dev->card);
}
	

bool
DVBMediaAddon::WantsAutoStart()
{
#if BUILD_FOR_HAIKU
//	printf("DVB: DVBMediaAddon::WantsAutoStart - NO\n");
	return false;
#else
//	printf("DVB: DVBMediaAddon::WantsAutoStart - YES\n");
	return true;
#endif
}


status_t
DVBMediaAddon::AutoStart(int index, BMediaNode **outNode, int32 *outInternalID, bool *outHasMore)
{
	printf("DVB: DVBMediaAddon::AutoStart, index %d\n", index);

#if BUILD_FOR_HAIKU
	return B_ERROR;
#else

	device_info *dev = (device_info *)fDeviceList.ItemAt(index);
	if (!dev) {
		printf("DVB: DVBMediaAddon::AutoStart, bad index\n");
		return B_BAD_INDEX;
	}
		
	*outHasMore = fDeviceList.ItemAt(index + 1) ? true : false;
	*outInternalID = dev->flavor.internal_id;
	*outNode = new DVBMediaNode(this, dev->name, dev->flavor.internal_id, dev->card);

	printf("DVB: DVBMediaAddon::AutoStart, success\n");

	return B_OK;
#endif
}


void
DVBMediaAddon::ScanFolder(const char *path)
{
	BDirectory dir(path);
	if (dir.InitCheck() != B_OK)
		return;

	BEntry ent;

	while (dir.GetNextEntry(&ent) == B_OK) {
		BPath path(&ent);
		if (ent.IsDirectory()) {
			ScanFolder(path.Path());
		} else {
			DVBCard *card = new DVBCard(path.Path());
			if (card->InitCheck() == B_OK)
				AddDevice(card, path.Path());
			else
				delete card;
		}
	}
}


void
DVBMediaAddon::AddDevice(DVBCard *card, const char *path)
{
	dvb_type_t type;
	char name[250];	
	char info[1000];
	const char *dvbtype;
	const char *dvbnumber;
	
	// get card name, info and type
	if (B_OK != card->GetCardType(&type)) {
		printf("DVBMediaAddon::AddDevice: getting DVB card type failed\n");
		return;
	}
	if (B_OK != card->GetCardInfo(name, sizeof(name), info, sizeof(info))) {
		printf("DVBMediaAddon::AddDevice: getting DVB card info failed\n");
		return;
	}
	
	// get type
	switch (type) {
		case DVB_TYPE_DVB_C: dvbtype = "C"; break;
		case DVB_TYPE_DVB_H: dvbtype = "H"; break;
		case DVB_TYPE_DVB_S: dvbtype = "S"; break;
		case DVB_TYPE_DVB_T: dvbtype = "T"; break;
		default:
			printf("DVBMediaAddon::AddDevice: unsupported DVB type %d\n", type);
			return;
	}
	
	// get interface number
	const char *p = strrchr(path, '/');
	dvbnumber = p ? p + 1 : "";
	
	// create device_info
	device_info *dev = new device_info;
	fDeviceList.AddItem(dev);
	
	dev->card = card;
	
	// setup name and info, it's important that name starts with "DVB"
//	snprintf(dev->name, sizeof(dev->name), "DVB-%s %s (%s)", dvbtype, dvbnumber, name);
//	strlcpy(dev->info, info, sizeof(dev->info));
	sprintf(dev->name, "DVB-%s %s %s", dvbtype, name, dvbnumber);
	strcpy(dev->info, info);
	
	// setup supported formats (the lazy way)
	memset(dev->formats, 0, sizeof(dev->formats));
	dev->formats[0].type = B_MEDIA_RAW_VIDEO;
	dev->formats[1].type = B_MEDIA_RAW_AUDIO;
	dev->formats[2].type = B_MEDIA_ENCODED_VIDEO;
	dev->formats[3].type = B_MEDIA_ENCODED_AUDIO;
	dev->formats[4].type = B_MEDIA_MULTISTREAM;
	
	// setup flavor info
	dev->flavor.name = dev->name;
	dev->flavor.info = dev->info;
	dev->flavor.kinds = B_BUFFER_PRODUCER | B_CONTROLLABLE | B_PHYSICAL_INPUT;
	dev->flavor.flavor_flags = B_FLAVOR_IS_GLOBAL;
	dev->flavor.internal_id = fDeviceList.CountItems() - 1;
	dev->flavor.possible_count = 1;
	dev->flavor.in_format_count = 0;
	dev->flavor.in_format_flags = 0;
	dev->flavor.in_formats = 0;
	dev->flavor.out_format_count = 5;
	dev->flavor.out_format_flags = 0;
	dev->flavor.out_formats = dev->formats;
}


void
DVBMediaAddon::FreeDeviceList()
{
	device_info *dev;
	while ((dev = (device_info *)fDeviceList.RemoveItem((int32)0))) {
		delete dev->card;
		delete dev;
	}
}