/*
 * OpenSound media addon for BeOS and Haiku
 *
 * Copyright (c) 2007, François Revol (revol@free.fr)
 * Distributed under the terms of the MIT License.
 * 
 * Based on MultiAudio media addon
 * Copyright (c) 2002, 2003 Jerome Duval (jerome.duval@free.fr)
 */
#include "OpenSoundAddOn.h"

#include <MediaDefs.h>
#include <MediaAddOn.h>
#include <Errors.h>
#include <Node.h>
#include <Mime.h>
#include <StorageDefs.h>
#include <Path.h>
#include <Directory.h>
#include <Entry.h>
#include <FindDirectory.h>
#include <Debug.h>
#include <errno.h>

#include "OpenSoundNode.h"
#include "OpenSoundDevice.h"
#include "OpenSoundDeviceEngine.h"

#include <limits.h>
#include <stdio.h>
#include <string.h>

#include "debug.h"

#define MULTI_SAVE


// instantiation function
extern "C" _EXPORT BMediaAddOn * make_media_addon(image_id image) {
	CALLED();
	return new OpenSoundAddOn(image);
}

// -------------------------------------------------------- //
// ctor/dtor
// -------------------------------------------------------- //

OpenSoundAddOn::~OpenSoundAddOn()
{
	CALLED();

	void *device = NULL;
	for (int32 i = 0; (device = fDevices.ItemAt(i)); i++)
		delete (OpenSoundDevice *)device;

	SaveSettings();
}

OpenSoundAddOn::OpenSoundAddOn(image_id image) :
	BMediaAddOn(image),
	fDevices()
{
	CALLED();
	fInitCheckStatus = B_NO_INIT;

	/* unix paths */
	if (RecursiveScan("/dev/oss/") != B_OK)
		return;
	/*
	if (RecursiveScan("/dev/audio/oss/") != B_OK)
		return;
	*/
	
	LoadSettings();

	fInitCheckStatus = B_OK;
}

// -------------------------------------------------------- //
// BMediaAddOn impl
// -------------------------------------------------------- //

status_t OpenSoundAddOn::InitCheck(
	const char ** out_failure_text)
{
	CALLED();
	return B_OK;
}

int32 OpenSoundAddOn::CountFlavors()
{
	CALLED();
	PRINT(("%" B_PRId32 " flavours\n", fDevices.CountItems()));
	return fDevices.CountItems();
}

status_t OpenSoundAddOn::GetFlavorAt(
	int32 n,
	const flavor_info ** out_info)
{
	CALLED();
	if (n < 0 || n > fDevices.CountItems() - 1) {
		fprintf(stderr, "<- B_BAD_INDEX\n");
		return B_BAD_INDEX;
	}

	OpenSoundDevice *device = (OpenSoundDevice *) fDevices.ItemAt(n);

	flavor_info * infos = new flavor_info[1];
	OpenSoundNode::GetFlavor(&infos[0], n);
	infos[0].name = device->fCardInfo.longname;
	(*out_info) = infos;
	return B_OK;
}

BMediaNode * OpenSoundAddOn::InstantiateNodeFor(
	const flavor_info * info,
	BMessage * config,
	status_t * out_error)
{
	CALLED();
	
	OpenSoundDevice *device = (OpenSoundDevice*)fDevices.ItemAt(
		info->internal_id);
	if (device == NULL) {
		*out_error = B_ERROR;
		return NULL;
	}

#ifdef MULTI_SAVE
	if (fSettings.FindMessage(device->fCardInfo.longname, config) == B_OK) {
		fSettings.RemoveData(device->fCardInfo.longname);
	}
#endif

	OpenSoundNode * node =
		new OpenSoundNode(this,
			device->fCardInfo.longname,
			device,
			info->internal_id,
			config);
	if (node == 0) {
		*out_error = B_NO_MEMORY;
		fprintf(stderr, "<- B_NO_MEMORY\n");
	} else {
		*out_error = node->InitCheck();
	}
	return node;
}

status_t
OpenSoundAddOn::GetConfigurationFor(BMediaNode * your_node, BMessage * into_message)
{
	CALLED();
#ifdef MULTI_SAVE
	{
		into_message = new BMessage();
		OpenSoundNode * node = dynamic_cast<OpenSoundNode*>(your_node);
		if (node == 0) {
			fprintf(stderr, "<- B_BAD_TYPE\n");
			return B_BAD_TYPE;
		}
		if (node->GetConfigurationFor(into_message) == B_OK) {
			fSettings.AddMessage(your_node->Name(), into_message);
		}
		return B_OK;
	}
#endif
	// currently never called by the media kit. Seems it is not implemented.
	OpenSoundNode * node = dynamic_cast<OpenSoundNode*>(your_node);
	if (node == 0) {
		fprintf(stderr, "<- B_BAD_TYPE\n");
		return B_BAD_TYPE;
	}
	return node->GetConfigurationFor(into_message);
}


bool OpenSoundAddOn::WantsAutoStart()
{
	CALLED();
	return false;
}

status_t OpenSoundAddOn::AutoStart(
	int in_count,
	BMediaNode ** out_node,
	int32 * out_internal_id,
	bool * out_has_more)
{
	CALLED();
	return B_OK;
}

status_t
OpenSoundAddOn::RecursiveScan(const char* rootPath, BEntry *rootEntry)
{
	status_t err;
	int mixer;
	oss_sysinfo sysinfo;
	oss_card_info cardinfo;
	int card, i, j;
	BList devs;
	
	CALLED();

	// make sure directories are scanned in this order
	BDirectory("/dev/audio/hmulti");
	BDirectory("/dev/audio/old");
	// OSS last, to give precedence to native drivers.
	// If other addons are loaded first it's ok as well.
	// Also, we must open it to make sure oss_loader is here,
	// else we don't get /dev/sndstat since we don't have a symlink in dev/.
	BDirectory("/dev/oss");

	mixer = open(OSS_MIXER_DEV, O_RDWR);
	if (mixer < 0) {
		// try to rescan
		// only works in BeOS
		BFile fDevFS("/dev/.", B_WRITE_ONLY);
		const char *drv = "oss_loader";
		fDevFS.Write(drv, strlen(drv));
		mixer = open(OSS_MIXER_DEV, O_RDWR);
		if (mixer < 0) {
			err = errno;
			goto err0;
		}
	}

	if (ioctl(mixer, SNDCTL_SYSINFO, &sysinfo) < 0) {
		err = errno;
		goto err1;
	}
	
	PRINT(("OSS: %s %s (0x%08X)\n", sysinfo.product, sysinfo.version, sysinfo.versionnum));
	PRINT(("OSS: %d audio cards, %d audio devs, %d audio engines, %d midi, %d mixers\n", sysinfo.numcards, sysinfo.numaudios, sysinfo.numaudioengines, sysinfo.nummidis, sysinfo.nummixers));

	/* construct an empty SoundDevice per card */
	
	for (card = 0; card < sysinfo.numcards; card++) {
		cardinfo.card = card;
		if (ioctl(mixer, SNDCTL_CARDINFO, &cardinfo) < 0) {
			err = errno;
			goto err1;
		}
		OpenSoundDevice *device = new OpenSoundDevice(&cardinfo);
		if (device)
			devs.AddItem(device);
		else {
			err = ENOMEM;
			goto err1;
		}
	}
	
	/* Add its audio engines to it */
	
	for (i = 0; i < sysinfo.numaudioengines; i++) {
		oss_audioinfo audioinfo;
		audioinfo.dev = i;
		if (ioctl(mixer, SNDCTL_ENGINEINFO, &audioinfo, sizeof(oss_audioinfo)) < 0) {
			err = errno;
			goto err1;
		}
		PRINT(("OSS: engine[%d]: card=%d, port=%d, legacy=%d, next_play=%d, next_rec=%d\n", i, audioinfo.card_number, audioinfo.port_number, audioinfo.legacy_device, audioinfo.next_play_engine, audioinfo.next_rec_engine));
		OpenSoundDevice *device = (OpenSoundDevice *)(devs.ItemAt(audioinfo.card_number));
		if (device)
			device->AddEngine(&audioinfo);
	}
	
	/* Add its mixers to it */
	
	for (i = 0; i < sysinfo.nummixers; i++) {
		oss_mixerinfo mixerinfo;
		mixerinfo.dev = i;
		if (ioctl(mixer, SNDCTL_MIXERINFO, &mixerinfo) < 0) {
			err = errno;
			goto err1;
		}
		PRINT(("OSS: mixer[%d]: card=%d\n", i, mixerinfo.card_number));
		OpenSoundDevice *device = (OpenSoundDevice *)(devs.ItemAt(mixerinfo.card_number));
		if (device)
			device->AddMixer(&mixerinfo);
	}
	
	/* resolve engine chains of shadow engines */
	
	for (card = 0; card < sysinfo.numcards; card++) {
		OpenSoundDevice *device = (OpenSoundDevice *)(devs.ItemAt(card));
		if (!device)
			continue;
		for (i = 0; i < device->CountEngines(); i++) {
			OpenSoundDeviceEngine *engine = device->EngineAt(i);
			if (engine) {
				if (engine->Info()->next_play_engine) {
					for (j = 0; j < device->CountEngines(); j++) {
						OpenSoundDeviceEngine *next = device->EngineAt(j);
						if (!next || (engine == next))
							continue;
						if (next->Info()->dev == engine->Info()->next_play_engine) {
							PRINT(("OSS: engine[%d].next_play = engine[%d]\n", i, j));
							engine->fNextPlay = next;
							break;
						}
					}
				}
				if (engine->Info()->next_rec_engine) {
					for (j = 0; j < device->CountEngines(); j++) {
						OpenSoundDeviceEngine *next = device->EngineAt(j);
						if (!next || (engine == next))
							continue;
						if (next->Info()->dev == engine->Info()->next_rec_engine) {
							PRINT(("OSS: engine[%d].next_rec = engine[%d]\n", i, j));
							engine->fNextRec = next;
							break;
						}
					}
				}
			}
		}
	}
	
	/* copy correctly initialized devs to fDevices */
	
	for (card = 0; card < sysinfo.numcards; card++) {
		OpenSoundDevice *device = (OpenSoundDevice *)(devs.ItemAt(card));
		if (device) {
			if (card == 0) { /* skip the "oss0" pseudo card device */
				delete device;
				continue;
			}
			if ((device->InitDriver() == B_OK) && (device->InitCheck() == B_OK))
				fDevices.AddItem(device);
			else
				delete device;
		}
	}
	if (fDevices.CountItems())
		err = B_OK;
	else
		err = ENOENT;
err1:
	close(mixer);
err0:
	return err;

#if MA
	BDirectory root;
	if (rootEntry != NULL)
		root.SetTo(rootEntry);
	else if (rootPath != NULL) {
		root.SetTo(rootPath);
	} else {
		PRINT(("Error in OpenSoundAddOn::RecursiveScan null params\n"));
		return B_ERROR;
	}

	BEntry entry;

	while (root.GetNextEntry(&entry) > B_ERROR) {

		if (entry.IsDirectory()) {
			BPath path;
			entry.GetPath(&path);
			OpenSoundDevice *device = new OpenSoundDevice(path.Path() + strlen(rootPath), path.Path());
			if (device) {
				if (device->InitCheck() == B_OK)
					fDevices.AddItem(device);
				else
					delete device;
			}
		}
	}

	return B_OK;
#endif
}


void
OpenSoundAddOn::SaveSettings(void)
{
	CALLED();
	BPath path;
	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) == B_OK) {
		path.Append(SETTINGS_FILE);
		BFile file(path.Path(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
		if (file.InitCheck() == B_OK)
			fSettings.Flatten(&file);
	}
}


void
OpenSoundAddOn::LoadSettings(void)
{
	CALLED();
	fSettings.MakeEmpty();

	BPath path;
	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) == B_OK) {
		path.Append(SETTINGS_FILE);
		BFile file(path.Path(), B_READ_ONLY);
		if ((file.InitCheck() == B_OK) && (fSettings.Unflatten(&file) == B_OK))
		{
			PRINT_OBJECT(fSettings);
		} else {
			PRINT(("Error unflattening settings file %s\n", path.Path()));
		}
	}
}


void
OpenSoundAddOn::RegisterMediaFormats(void)
{
	CALLED();
	// register non-raw audio formats to the Media Kit
#ifdef ENABLE_NON_RAW_SUPPORT
	OpenSoundDevice::register_media_formats();
#endif

	
}