/*
 * 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 <stdio.h>
#include <string.h>
#include <Debug.h>
#include <ParameterWeb.h>
#include <TimeSource.h>

#include "Controller.h"
#include "DeviceRoster.h"
#include "VideoView.h"
#include "VideoNode.h"

extern bool gOverlayDisabled;

status_t MediaRoster_Disconnect(const media_output &output, const media_input &input);



media_node		dvb_node;
media_node		audio_mixer_node;
media_node		video_window_node;
media_node		time_node;

media_input		audio_input;
media_output	audio_output;
media_input		video_input;
media_output	video_output;

BMediaRoster *gMediaRoster;

void 
HandleError(const char *text, status_t err)
{
	if (err != B_OK) { 
		printf("%s. error 0x%08x (%s)\n",text, (int)err, strerror(err));
		fflush(NULL);
		exit(1);
	}
}


Controller::Controller()
 :	fCurrentInterface(-1)
 ,	fCurrentChannel(-1)
 ,	fVideoView(NULL)
 ,	fVideoNode(NULL)
 ,	fWeb(NULL)
 ,	fChannelParam(NULL)
 ,	fConnected(false)
 , 	fInput()
 ,	fOutput()
{
	gMediaRoster = BMediaRoster::Roster();
}


Controller::~Controller()
{
	delete fWeb;
}


void
Controller::SetVideoView(VideoView *view)
{
	fVideoView = view;
}


void
Controller::SetVideoNode(VideoNode *node)
{
	fVideoNode = node;
}


void
Controller::DisconnectInterface()
{
	DisconnectNodes();
	fCurrentInterface = -1;
	fCurrentChannel = -1;
	delete fWeb;
	fWeb = 0;
	fChannelParam = 0;
}


status_t
Controller::ConnectInterface(int i)
{
	if (i < 0) {
		printf("Controller::ConnectInterface: wrong index\n");
		return B_ERROR;
	}
	if (fCurrentInterface != -1) {
		printf("Controller::ConnectInterface: already connected\n");
		return B_ERROR;
	}

	BParameterWeb *web;
	status_t err;

	err = gDeviceRoster->MediaRoster()->GetParameterWebFor(gDeviceRoster->DeviceNode(i), &web);
	if (err != B_OK) {
		printf("Controller::ConnectInterface: can't get parameter web\n");
		return B_ERROR;
	}

	delete fWeb;
	fWeb = web;
	fCurrentInterface = i;

	// XXX we may need to monitor for parameter web changes
	// and reassing fWeb and fChannelParam on demand.

	// find the channel control	and assign it to fChannelParam
	fChannelParam = NULL;
	int count = fWeb->CountParameters();
	for (int i = 0; i < count; i++) {
		BParameter *parameter = fWeb->ParameterAt(i);

		printf("parameter %d\n", i);
		printf("  name '%s'\n", parameter->Name());
		printf("  kind '%s'\n", parameter->Kind());
		printf("  unit '%s'\n", parameter->Unit());
		printf("  flags 0x%08" B_PRIx32 "\n", parameter->Flags());

		// XXX TODO: matching on Name is weak
		if (strcmp(parameter->Name(), "Channel") == 0 || strcmp(parameter->Kind(), B_TUNER_CHANNEL) == 0) {
			fChannelParam = dynamic_cast<BDiscreteParameter *>(parameter);
			if (fChannelParam)
				break;
		}
	}
	if (!fChannelParam) {
		printf("Controller::ConnectInterface: can't find channel parameter control\n");
		fCurrentChannel = -1;
	} else {
	if (fChannelParam->CountItems() == 0) {
			fCurrentChannel = -1;
			printf("Controller::ConnectInterface: channel control has 0 items\n");
		} else {
			int32 index;
			size_t size;
			status_t err;
			bigtime_t when;
			size = sizeof(index);
			err = fChannelParam->GetValue(&index, &size, &when);
			if (err == B_OK && size == sizeof(index)) {
				fCurrentChannel = index;
				printf("Controller::ConnectInterface: selected channel is %d\n", fCurrentChannel);
			} else {
				fCurrentChannel = -1;
				printf("Controller::ConnectInterface: can't get channel control value\n");
			}
		}
	}

	ConnectNodes();

	return B_OK;
}


bool
Controller::IsInterfaceAvailable(int i)
{
	return gDeviceRoster->IsRawAudioOutputFree(i) && gDeviceRoster->IsRawVideoOutputFree(i);
}


int
Controller::CurrentInterface()
{
	return fCurrentInterface;
}


int
Controller::CurrentChannel()
{
	return fCurrentChannel;
}


status_t
Controller::SelectChannel(int i)
{
	if (!fChannelParam)
		return B_ERROR;

	int32 index;
	status_t err;
	index = i;
	err = fChannelParam->SetValue(&index, sizeof(index), 0);
	if (err != B_OK) {
		printf("Controller::SelectChannel %d failed\n", i);
		return err;
	}

	fCurrentChannel = i;
	return B_OK;
}


int
Controller::ChannelCount()
{
	if (fCurrentInterface == -1)
		return 0;

	if (!fChannelParam)
		return 0;

	return fChannelParam->CountItems();
}


const char *
Controller::ChannelName(int i)
{
	if (fCurrentInterface == -1)
		return NULL;

	if (!fChannelParam)
		return NULL;

	return fChannelParam->ItemNameAt(i);
}


void
Controller::VolumeUp()
{
}


void
Controller::VolumeDown()
{
}


status_t
Controller::ConnectNodes()
{
	status_t err;

//	dvb_node = gDeviceRoster->DeviceNode(fCurrentInterface);

	err = gMediaRoster->GetNodeFor(gDeviceRoster->DeviceNode(fCurrentInterface).node, &dvb_node);
	HandleError("GetNodeFor failed", err);

	video_window_node = fVideoNode->Node();

	err = gMediaRoster->GetAudioMixer(&audio_mixer_node);
	HandleError("GetAudioMixer failed", err);

	media_input		input;
	media_output	output;
	media_format	fmt;
	int32			count;

	// Connect audio

	err = gMediaRoster->GetFreeOutputsFor(dvb_node, &output, 1, &count, B_MEDIA_RAW_AUDIO);
	HandleError("Can't find free audio output", err);
	if (count < 1)
		HandleError("No free audio output", -1);

	err = gMediaRoster->GetFreeInputsFor(audio_mixer_node, &input, 1, &count, B_MEDIA_RAW_AUDIO);
	HandleError("Can't find free audio input", err);
	if (count < 1)
		HandleError("No free audio input", -1);

	err = gMediaRoster->Connect(output.source, input.destination, &fmt, &audio_output, &audio_input);
	HandleError("Can't connect audio", err);

	// Connect video

	err = gMediaRoster->GetFreeOutputsFor(dvb_node, &output, 1, &count, B_MEDIA_RAW_VIDEO);
	HandleError("Can't find free video output", err);
	if (count < 1)
		HandleError("No free video output", -1);

	err = gMediaRoster->GetFreeInputsFor(video_window_node, &input, 1, &count, B_MEDIA_RAW_VIDEO);
	HandleError("Can't find free video input", err);
	if (count < 1)
		HandleError("No free video input", -1);

	color_space cspaces_overlay[] = { B_YCbCr422, B_RGB32, B_NO_COLOR_SPACE };
	color_space cspaces_bitmap[] = { B_RGB32, B_NO_COLOR_SPACE };

	if (gOverlayDisabled) {
		err = B_ERROR;
	} else {
		fVideoNode->SetOverlayEnabled(true);
		for (int i = 0; cspaces_overlay[i] != B_NO_COLOR_SPACE; i++) {
			printf("trying connect with colorspace 0x%08x\n", cspaces_overlay[i]);
			fmt.Clear();
			fmt.type = B_MEDIA_RAW_VIDEO;
			fmt.u.raw_video.display.format = cspaces_overlay[i];
			err = gMediaRoster->Connect(output.source, input.destination, &fmt, &video_output, &video_input);
			if (err == B_OK)
				break;
		}
	}
	if (err) {
		fVideoNode->SetOverlayEnabled(false);
		for (int i = 0; cspaces_bitmap[i] != B_NO_COLOR_SPACE; i++) {
			printf("trying connect with colorspace 0x%08x\n", cspaces_bitmap[i]);
			fmt.Clear();
			fmt.type = B_MEDIA_RAW_VIDEO;
			fmt.u.raw_video.display.format = cspaces_bitmap[i];
			err = gMediaRoster->Connect(output.source, input.destination, &fmt, &video_output, &video_input);
			if (err == B_OK)
				break;
		}
	}
	HandleError("Can't connect video", err);

	// set time sources

	err = gMediaRoster->GetTimeSource(&time_node);
	HandleError("Can't get time source", err);

	BTimeSource *ts = gMediaRoster->MakeTimeSourceFor(time_node);

	err = gMediaRoster->SetTimeSourceFor(dvb_node.node, time_node.node);
	HandleError("Can't set dvb time source", err);

	err = gMediaRoster->SetTimeSourceFor(audio_mixer_node.node, time_node.node);
	HandleError("Can't set audio mixer time source", err);

	err = gMediaRoster->SetTimeSourceFor(video_window_node.node, time_node.node);
	HandleError("Can't set video window time source", err);

	// Add a delay of (2 video frames) to the buffers send by the DVB node,
	// because as a capture device in B_RECORDING run mode it's supposed to
	// deliver buffers that were captured in the past (and does so).
	// It is important that the audio buffer size used by the connection with
	// the DVB node is smaller than this, optimum is the same length as one 
	// video frame (40 ms). However, this is not yet guaranteed.
	err = gMediaRoster->SetProducerRunModeDelay(dvb_node, 80000);
	HandleError("Can't set DVB producer delay", err);

	bigtime_t start_time = ts->Now() + 50000;

	ts->Release();

	// start nodes

	err = gMediaRoster->StartNode(dvb_node, start_time);
	HandleError("Can't start dvb node", err);

	err = gMediaRoster->StartNode(audio_mixer_node, start_time);
	HandleError("Can't start audio mixer node", err);

	err = gMediaRoster->StartNode(video_window_node, start_time);
	HandleError("Can't start video window node", err);

	printf("running...\n");

	fConnected = true;

	return B_OK;
}


status_t
Controller::DisconnectNodes()
{
	printf("stopping...\n");

	if (!fConnected)
		return B_OK;

	status_t err;

	// stop nodes

	err = gMediaRoster->StopNode(dvb_node, 0, true);
	HandleError("Can't stop dvb node", err);

	err = gMediaRoster->StopNode(audio_mixer_node, 0, true);
	HandleError("Can't stop audio mixer node", err);

	err = gMediaRoster->StopNode(video_window_node, 0, true);
	HandleError("Can't stop video window node", err);

	// disconnect nodes

	err = MediaRoster_Disconnect(video_output, video_input);
	HandleError("Can't disconnect video", err);

	err = MediaRoster_Disconnect(audio_output, audio_input);
	HandleError("Can't disconnect audio", err);

	// disable overlay, or erase image

	fVideoView->RemoveVideoDisplay();

	// release other nodes

	err = gMediaRoster->ReleaseNode(audio_mixer_node);
	HandleError("Can't release audio mixer node", err);

//	err = gMediaRoster->ReleaseNode(video_window_node);
//	HandleError("Can't release video window node", err);

//	err = gMediaRoster->ReleaseNode(time_node);
//	HandleError("Can't release time source node", err);

	// release dvb

	err = gMediaRoster->ReleaseNode(dvb_node);
	HandleError("Can't release DVB node", err);

	fConnected = false;

	return B_OK;
}


status_t 
MediaRoster_Disconnect(const media_output &output, const media_input &input)
{
	if (output.node.node <= 0) {
		printf("MediaRoster_Disconnect: output.node.node %d invalid\n",
			(int)output.node.node);
		return B_MEDIA_BAD_NODE;
	}
	if (input.node.node <= 0) {
		printf("MediaRoster_Disconnect: input.node.node %d invalid\n",
			(int)input.node.node);
		return B_MEDIA_BAD_NODE;
	}
	if (!(output.node.kind & B_BUFFER_PRODUCER)) {
		printf("MediaRoster_Disconnect: output.node.kind 0x%x is no B_BUFFER_PRODUCER\n",
			(int)output.node.kind);
		return B_MEDIA_BAD_NODE;
	}
	if (!(input.node.kind & B_BUFFER_CONSUMER)) {
		printf("MediaRoster_Disconnect: input.node.kind 0x%x is no B_BUFFER_PRODUCER\n",
			(int)input.node.kind);
		return B_MEDIA_BAD_NODE;
	}
	if (input.source.port != output.source.port) {
		printf("MediaRoster_Disconnect: input.source.port %d doesn't match output.source.port %d\n",
			(int)input.source.port, (int)output.source.port);
		return B_MEDIA_BAD_NODE;
	}
	if (input.source.id != output.source.id) {
		printf("MediaRoster_Disconnect: input.source.id %d doesn't match output.source.id %d\n",
			(int)input.source.id, (int)output.source.id);
		return B_MEDIA_BAD_NODE;
	}
	if (input.destination.port != output.destination.port) {
		printf("MediaRoster_Disconnect: input.destination.port %d doesn't match output.destination.port %d\n",
			(int)input.destination.port, (int)output.destination.port);
		return B_MEDIA_BAD_NODE;
	}
	if (input.destination.id != output.destination.id) {
		printf("MediaRoster_Disconnect: input.destination.id %d doesn't match output.destination.id %d\n",
			(int)input.destination.id, (int)output.destination.id);
		return B_MEDIA_BAD_NODE;
	}
	return BMediaRoster::Roster()->Disconnect(output.node.node, output.source, input.node.node, input.destination);
}