/*
 * Copyright 1998-1999 Be, Inc. All Rights Reserved.
 * Copyright 2003-2019 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "VideoConsumer.h"

#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <Application.h>
#include <BitmapStream.h>
#include <Buffer.h>
#include <BufferGroup.h>
#include <Catalog.h>
#include <Locale.h>
#include <MediaRoster.h>
#include <NodeInfo.h>
#include <scheduler.h>
#include <StringView.h>
#include <TimeSource.h>
#include <View.h>

#include "FileUploadClient.h"
#include "FtpClient.h"
#include "SftpClient.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "VideoConsumer.cpp"


#define M1 ((double)1000000.0)
#define JITTER		20000

#define	FUNCTION	printf
#define ERROR		printf
#define PROGRESS	printf
#define LOOP		printf


static status_t SetFileType(BFile* file, int32 translator, uint32 type);

const media_raw_video_format vid_format = {29.97, 1, 0, 239,
	B_VIDEO_TOP_LEFT_RIGHT, 1, 1, {B_RGB16, 320, 240, 320 * 4, 0, 0}};


VideoConsumer::VideoConsumer(const char* name, BView* view,
	BStringView* statusLine,
	BMediaAddOn* addon, const uint32 internalId)
	:
	BMediaNode(name),
	BMediaEventLooper(),
	BBufferConsumer(B_MEDIA_RAW_VIDEO),
	fStatusLine(statusLine),
	fInternalID(internalId),
	fAddOn(addon),
	fConnectionActive(false),
	fMyLatency(20000),
	fWindow(NULL),
	fView(view),
	fOurBuffers(false),
	fBuffers(NULL),
	fTimeToFtp(false),
	fFtpComplete(true),
	fRate(1000000),
	fImageFormat(0),
	fTranslator(0),
	fUploadClient(0),
	fPassiveFtp(true)
{
	FUNCTION("VideoConsumer::VideoConsumer\n");

	AddNodeKind(B_PHYSICAL_OUTPUT);
	SetEventLatency(0);
	fWindow = fView->Window();

	for (uint32 j = 0; j < 3; j++) {
		fBitmap[j] = NULL;
		fBufferMap[j] = NULL;
	}

	strcpy(fFileNameText, "");
	strcpy(fServerText, "");
	strcpy(fLoginText, "");
	strcpy(fPasswordText, "");
	strcpy(fDirectoryText, "");

	SetPriority(B_DISPLAY_PRIORITY);
}


VideoConsumer::~VideoConsumer()
{
	FUNCTION("VideoConsumer::~VideoConsumer\n");

	Quit();

	if (fWindow) {
		puts(B_TRANSLATE("Locking the window"));
		if (fWindow->Lock()) {
			puts(B_TRANSLATE("Closing the window"));
			fWindow->Close();
			fWindow = NULL;
		}
	}

	// clean up ftp thread
	// wait up to 30 seconds if ftp is in progress
	int32 count = 0;
	while (!fFtpComplete && count < 30) {
		snooze(1000000);
		count++;
	}

	if (count == 30)
		kill_thread(fFtpThread);

	DeleteBuffers();
}

/********************************
	From BMediaNode
********************************/


BMediaAddOn*
VideoConsumer::AddOn(int32* cookie) const
{
	FUNCTION("VideoConsumer::AddOn\n");
	// do the right thing if we're ever used with an add-on
	*cookie = fInternalID;
	return fAddOn;
}


// This implementation is required to get around a bug in
// the ppc compiler.

void
VideoConsumer::Start(bigtime_t performanceTime)
{
	BMediaEventLooper::Start(performanceTime);
}


void
VideoConsumer::Stop(bigtime_t performanceTime, bool immediate)
{
	BMediaEventLooper::Stop(performanceTime, immediate);
}


void
VideoConsumer::Seek(bigtime_t mediaTime, bigtime_t performanceTime)
{
	BMediaEventLooper::Seek(mediaTime, performanceTime);
}


void
VideoConsumer::TimeWarp(bigtime_t atRealTime, bigtime_t toPerformanceTime)
{
	BMediaEventLooper::TimeWarp(atRealTime, toPerformanceTime);
}


status_t
VideoConsumer::DeleteHook(BMediaNode* node)
{
	return BMediaEventLooper::DeleteHook(node);
}


void
VideoConsumer::NodeRegistered()
{
	FUNCTION("VideoConsumer::NodeRegistered\n");
	fIn.destination.port = ControlPort();
	fIn.destination.id = 0;
	fIn.source = media_source::null;
	fIn.format.type = B_MEDIA_RAW_VIDEO;
	fIn.format.u.raw_video = vid_format;

	Run();
}


status_t
VideoConsumer::RequestCompleted(const media_request_info& info)
{
	FUNCTION("VideoConsumer::RequestCompleted\n");
	switch (info.what) {
		case media_request_info::B_SET_OUTPUT_BUFFERS_FOR:
			if (info.status != B_OK)
					ERROR("VideoConsumer::RequestCompleted: "
						  "Not using our buffers!\n");
			break;

		default:
			ERROR("VideoConsumer::RequestCompleted: Invalid argument\n");
			break;
	}

	return B_OK;
}


status_t
VideoConsumer::HandleMessage(int32 message, const void* data, size_t size)
{
	//FUNCTION("VideoConsumer::HandleMessage\n");
	ftp_msg_info* info = (ftp_msg_info*)data;

	switch (message) {
		case FTP_INFO:
			PROGRESS("VideoConsumer::HandleMessage - FTP_INFO message\n");
			fRate = info->rate;
			fImageFormat = info->imageFormat;
			fTranslator = info->translator;
			fPassiveFtp = info->passiveFtp;
			fUploadClient = info->uploadClient;
			strcpy(fFileNameText, info->fileNameText);
			strcpy(fServerText, info->serverText);
			strcpy(fLoginText, info->loginText);
			strcpy(fPasswordText, info->passwordText);
			strcpy(fDirectoryText, info->directoryText);
			// remove old user events
			EventQueue()->FlushEvents(TimeSource()->Now(),
				BTimedEventQueue::B_ALWAYS, true,
				BTimedEventQueue::B_USER_EVENT);
			if (fRate != B_INFINITE_TIMEOUT) {
				// if rate is not "Never," push an event
				// to restart captures 5 seconds from now
				media_timed_event event(TimeSource()->Now() + 5000000,
					BTimedEventQueue::B_USER_EVENT);
				EventQueue()->AddEvent(event);
			}
			break;
	}

	return B_OK;
}


void
VideoConsumer::BufferReceived(BBuffer* buffer)
{
	LOOP("VideoConsumer::Buffer #%" B_PRId32 " received, start_time %"
		B_PRIdBIGTIME "\n", buffer->ID(), buffer->Header()->start_time);

	if (RunState() == B_STOPPED) {
		buffer->Recycle();
		return;
	}

	media_timed_event event(buffer->Header()->start_time,
		BTimedEventQueue::B_HANDLE_BUFFER, buffer,
		BTimedEventQueue::B_RECYCLE_BUFFER);
	EventQueue()->AddEvent(event);
}


void
VideoConsumer::ProducerDataStatus(const media_destination& forWhom,
	int32 status, bigtime_t atMediaTime)
{
	FUNCTION("VideoConsumer::ProducerDataStatus\n");

	if (forWhom != fIn.destination)
		return;
}


status_t
VideoConsumer::CreateBuffers(const media_format& withFormat)
{
	FUNCTION("VideoConsumer::CreateBuffers\n");

	DeleteBuffers();
		// delete any old buffers

	status_t status = B_OK;

	// create a buffer group
	uint32 xSize = withFormat.u.raw_video.display.line_width;
	uint32 ySize = withFormat.u.raw_video.display.line_count;
	color_space colorspace = withFormat.u.raw_video.display.format;
	PROGRESS("VideoConsumer::CreateBuffers - Colorspace = %d\n", colorspace);

	fBuffers = new BBufferGroup();
	status = fBuffers->InitCheck();
	if (status != B_OK) {
		ERROR("VideoConsumer::CreateBuffers - ERROR CREATING BUFFER GROUP\n");
		return status;
	}
	// and attach the  bitmaps to the buffer group
	for (uint32 j = 0; j < 3; j++) {
		fBitmap[j] = new BBitmap(BRect(0, 0, (xSize - 1), (ySize - 1)),
			colorspace, false, true);
		if (fBitmap[j]->IsValid()) {
			buffer_clone_info info;
			if ((info.area = area_for(fBitmap[j]->Bits())) == B_ERROR)
				ERROR("VideoConsumer::CreateBuffers - ERROR IN AREA_FOR\n");
			info.offset = 0;
			info.size = (size_t)fBitmap[j]->BitsLength();
			info.flags = j;
			info.buffer = 0;

			if ((status = fBuffers->AddBuffer(info)) != B_OK) {
				ERROR("VideoConsumer::CreateBuffers - "
					  "ERROR ADDING BUFFER TO GROUP\n");
				return status;
			}
			else
				PROGRESS("VideoConsumer::CreateBuffers - "
						 "SUCCESSFUL ADD BUFFER TO GROUP\n");
		} else {
			ERROR("VideoConsumer::CreateBuffers - ERROR CREATING VIDEO RING "
				"BUFFER: %08" B_PRIx32 "\n", status);
			return B_ERROR;
		}
	}

	BBuffer* buffList[3];
	for (int j = 0; j < 3; j++)
		buffList[j] = NULL;

	status = fBuffers->GetBufferList(3, buffList);
	if (status == B_OK)
		for (int j = 0; j < 3; j++)
			if (buffList[j] != NULL) {
				fBufferMap[j] = buffList[j];
				PROGRESS(" j = %d buffer = %p\n", j, fBufferMap[j]);
			} else {
				ERROR("VideoConsumer::CreateBuffers "
					  "ERROR MAPPING RING BUFFER\n");
				return B_ERROR;
			}
	else
		ERROR("VideoConsumer::CreateBuffers ERROR IN GET BUFFER LIST\n");

	fFtpBitmap = new BBitmap(BRect(0, 0, xSize - 1, ySize - 1), B_RGB32, false,
		false);

	FUNCTION("VideoConsumer::CreateBuffers - EXIT\n");
	return status;
}


void
VideoConsumer::DeleteBuffers()
{
	FUNCTION("VideoConsumer::DeleteBuffers\n");

	if (fBuffers) {
		delete fBuffers;
		fBuffers = NULL;

		for (uint32 j = 0; j < 3; j++)
			if (fBitmap[j]->IsValid()) {
				delete fBitmap[j];
				fBitmap[j] = NULL;
			}
	}

	FUNCTION("VideoConsumer::DeleteBuffers - EXIT\n");
}


status_t
VideoConsumer::Connected(const media_source& producer,
	const media_destination& where, const media_format& withFormat,
	media_input* outInput)
{
	FUNCTION("VideoConsumer::Connected\n");

	fIn.source = producer;
	fIn.format = withFormat;
	fIn.node = Node();
	sprintf(fIn.name, "Video Consumer");
	*outInput = fIn;

	uint32 userData = 0;
	int32 changeTag = 1;
	if (CreateBuffers(withFormat) == B_OK)
		BBufferConsumer::SetOutputBuffersFor(producer, fDestination,
			fBuffers, (void*)&userData, &changeTag, true);
	else {
		ERROR("VideoConsumer::Connected - COULDN'T CREATE BUFFERS\n");
		return B_ERROR;
	}

	fConnectionActive = true;

	FUNCTION("VideoConsumer::Connected - EXIT\n");
	return B_OK;
}


void
VideoConsumer::Disconnected(const media_source& producer,
	const media_destination& where)
{
	FUNCTION("VideoConsumer::Disconnected\n");

	if (where == fIn.destination && producer == fIn.source) {
		// disconnect the connection
		fIn.source = media_source::null;
		delete fFtpBitmap;
		fConnectionActive = false;
	}

}


status_t
VideoConsumer::AcceptFormat(const media_destination& dest, media_format* format)
{
	FUNCTION("VideoConsumer::AcceptFormat\n");

	if (dest != fIn.destination) {
		ERROR("VideoConsumer::AcceptFormat - BAD DESTINATION\n");
		return B_MEDIA_BAD_DESTINATION;
	}

	if (format->type == B_MEDIA_NO_TYPE)
		format->type = B_MEDIA_RAW_VIDEO;

	if (format->type != B_MEDIA_RAW_VIDEO) {
		ERROR("VideoConsumer::AcceptFormat - BAD FORMAT\n");
		return B_MEDIA_BAD_FORMAT;
	}

	if (format->u.raw_video.display.format != B_RGB32
		&& format->u.raw_video.display.format != B_RGB16
		&& format->u.raw_video.display.format != B_RGB15
		&& format->u.raw_video.display.format != B_GRAY8
		&&
		format->u.raw_video.display.format
			!= media_raw_video_format::wildcard.display.format) {
		ERROR("AcceptFormat - not a format we know about!\n");
		return B_MEDIA_BAD_FORMAT;
	}

	if (format->u.raw_video.display.format
		== media_raw_video_format::wildcard.display.format) {
		format->u.raw_video.display.format = B_RGB16;
	}

	char formatString[256];
	string_for_format(*format, formatString, 256);
	FUNCTION("VideoConsumer::AcceptFormat: %s\n", formatString);

	return B_OK;
}


status_t
VideoConsumer::GetNextInput(int32* cookie, media_input* outInput)
{
	FUNCTION("VideoConsumer::GetNextInput\n");

	// custom build a destination for this connection
	// put connection number in id

	if (*cookie < 1) {
		fIn.node = Node();
		fIn.destination.id = *cookie;
		sprintf(fIn.name, "Video Consumer");
		*outInput = fIn;
		(*cookie)++;

		return B_OK;
	}

	ERROR("VideoConsumer::GetNextInput - - BAD INDEX\n");
	return B_MEDIA_BAD_DESTINATION;
}


void
VideoConsumer::DisposeInputCookie(int32 /*cookie*/)
{
}


status_t
VideoConsumer::GetLatencyFor(const media_destination& forWhom,
	bigtime_t* outLatency, media_node_id* out_timesource)
{
	FUNCTION("VideoConsumer::GetLatencyFor\n");

	if (forWhom != fIn.destination)
		return B_MEDIA_BAD_DESTINATION;

	*outLatency = fMyLatency;
	*out_timesource = TimeSource()->ID();
	return B_OK;
}


status_t
VideoConsumer::FormatChanged(const media_source& producer,
	const media_destination& consumer, int32 fromChangeCount,
	const media_format& format)
{
	FUNCTION("VideoConsumer::FormatChanged\n");

	if (consumer != fIn.destination)
		return B_MEDIA_BAD_DESTINATION;

	if (producer != fIn.source)
		return B_MEDIA_BAD_SOURCE;

	fIn.format = format;

	return CreateBuffers(format);
}


void
VideoConsumer::HandleEvent(const media_timed_event* event, bigtime_t lateness,
	bool realTimeEvent)
{
	LOOP("VideoConsumer::HandleEvent\n");

	BBuffer* buffer;

	switch (event->type) {
		case BTimedEventQueue::B_START:
			PROGRESS("VideoConsumer::HandleEvent - START\n");
			break;

		case BTimedEventQueue::B_STOP:
			PROGRESS("VideoConsumer::HandleEvent - STOP\n");
			EventQueue()->FlushEvents(event->event_time,
				BTimedEventQueue::B_ALWAYS, true,
				BTimedEventQueue::B_HANDLE_BUFFER);
			break;

		case BTimedEventQueue::B_USER_EVENT:
			PROGRESS("VideoConsumer::HandleEvent - USER EVENT\n");
			if (RunState() == B_STARTED) {
				fTimeToFtp = true;
				PROGRESS("Pushing user event for %.4f, time now %.4f\n",
					(event->event_time + fRate) / M1, event->event_time/M1);
				media_timed_event newEvent(event->event_time + fRate,
					BTimedEventQueue::B_USER_EVENT);
				EventQueue()->AddEvent(newEvent);
			}
			break;

		case BTimedEventQueue::B_HANDLE_BUFFER:
		{
			LOOP("VideoConsumer::HandleEvent - HANDLE BUFFER\n");
			buffer = (BBuffer*)event->pointer;
			if (RunState() == B_STARTED && fConnectionActive) {
				// see if this is one of our buffers
				uint32 index = 0;
				fOurBuffers = true;
				while (index < 3)
					if (buffer == fBufferMap[index])
						break;
					else
						index++;

				if (index == 3) {
					// no, buffers belong to consumer
					fOurBuffers = false;
					index = 0;
				}

				if (fFtpComplete && fTimeToFtp) {
					PROGRESS("VidConsumer::HandleEvent - "
							 "SPAWNING FTP THREAD\n");
					fTimeToFtp = false;
					fFtpComplete = false;
					memcpy(fFtpBitmap->Bits(), buffer->Data(),
						fFtpBitmap->BitsLength());
					fFtpThread = spawn_thread(FtpRun, "Video Window Ftp",
						B_NORMAL_PRIORITY, this);
					resume_thread(fFtpThread);
				}

				if ((RunMode() == B_OFFLINE)
					|| ((TimeSource()->Now() >
						(buffer->Header()->start_time - JITTER))
					&& (TimeSource()->Now() <
					   (buffer->Header()->start_time + JITTER)))) {
					if (!fOurBuffers)
						// not our buffers, so we need to copy
						memcpy(fBitmap[index]->Bits(), buffer->Data(),
							fBitmap[index]->BitsLength());

					if (fWindow->Lock()) {
						uint32 flags;
						if ((fBitmap[index]->ColorSpace() == B_GRAY8) &&
							!bitmaps_support_space(fBitmap[index]->ColorSpace(),
								&flags)) {
							// handle mapping of GRAY8 until app server
							// knows how
							uint32* start = (uint32*)fBitmap[index]->Bits();
							int32 size = fBitmap[index]->BitsLength();
							uint32* end = start + size / 4;
							for (uint32* p = start; p < end; p++)
								*p = (*p >> 3) & 0x1f1f1f1f;
						}

						fView->DrawBitmap(fBitmap[index], fView->Bounds());
						fWindow->Unlock();
					}
				}
				else
					PROGRESS("VidConsumer::HandleEvent - DROPPED FRAME\n");
				buffer->Recycle();
			}
			else
				buffer->Recycle();
			break;
		}

		default:
			ERROR("VideoConsumer::HandleEvent - BAD EVENT\n");
			break;
	}
}


status_t
VideoConsumer::FtpRun(void* data)
{
	FUNCTION("VideoConsumer::FtpRun\n");

	((VideoConsumer*)data)->FtpThread();

	return 0;
}


void
VideoConsumer::FtpThread()
{
	char fullPath[B_PATH_NAME_LENGTH];
	FUNCTION("VideoConsumer::FtpThread\n");
	if (fUploadClient == 2) {
		// 64 + 64 = 128 max
		snprintf(fullPath, B_PATH_NAME_LENGTH, "%s/%s", fDirectoryText,
			fFileNameText);
		LocalSave(fullPath, fFtpBitmap);
	} else if (LocalSave(fFileNameText, fFtpBitmap) == B_OK)
		FtpSave(fFileNameText);

#if 0
	// save a small version, too
	BBitmap* b = new BBitmap(BRect(0,0,159,119), B_RGB32, true, false);
	BView* v = new BView(BRect(0,0,159,119), "SmallView 1", 0, B_WILL_DRAW);
	b->AddChild(v);

	b->Lock();
	v->DrawBitmap(fFtpBitmap, v->Frame());
	v->Sync();
	b->Unlock();

	if (LocalSave("small.jpg", b) == B_OK)
		FtpSave("small.jpg");

	delete b;
#endif

	fFtpComplete = true;
}


void
VideoConsumer::UpdateFtpStatus(const char* status)
{
	printf("FTP STATUS: %s\n",status);
	if (fView->Window()->Lock()) {
		fStatusLine->SetText(status);
		fView->Window()->Unlock();
	}
}


status_t
VideoConsumer::LocalSave(char* filename, BBitmap* bitmap)
{
	BFile* output;

	UpdateFtpStatus(B_TRANSLATE("Capturing Image" B_UTF8_ELLIPSIS));

	/* save a local copy of the image in the requested format */
	output = new BFile();
	if (output->SetTo(filename, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE)
		== B_NO_ERROR) {
		BBitmapStream input(bitmap);
		status_t err = BTranslatorRoster::Default()->Translate(&input, NULL,
			NULL, output, fImageFormat);
		if (err == B_OK) {
			err = SetFileType(output, fTranslator, fImageFormat);
			if (err != B_OK)
				UpdateFtpStatus(
					B_TRANSLATE("Error setting type of output file"));
		}
		else
			UpdateFtpStatus(B_TRANSLATE("Error writing output file"));

		input.DetachBitmap(&bitmap);
		output->Unset();
		delete output;

		return B_OK;
	}

	UpdateFtpStatus(B_TRANSLATE("Error creating output file"));
	return B_ERROR;
}


status_t
VideoConsumer::FtpSave(char* filename)
{
	FileUploadClient* ftp;

	//XXX: make that cleaner
	switch (fUploadClient) {
		case 0:
			ftp = new FtpClient;
			break;
		case 1:
			ftp = new SftpClient;
			break;
		case 2:
			return B_OK;
		default:
			fprintf(stderr, B_TRANSLATE("invalid upload client %ld\n"), (long int)fUploadClient);
			return EINVAL;
	}

	ftp->SetPassive(fPassiveFtp);
		// ftp the local file to our web site

	UpdateFtpStatus(B_TRANSLATE("Logging in" B_UTF8_ELLIPSIS));
	if (ftp->Connect((string)fServerText, (string)fLoginText,
		(string)fPasswordText)) {
		// connect to server
		UpdateFtpStatus(B_TRANSLATE("Connected" B_UTF8_ELLIPSIS));

		if (ftp->ChangeDir((string)fDirectoryText)) {
			// cd to the desired directory
			UpdateFtpStatus(B_TRANSLATE("Upload" B_UTF8_ELLIPSIS));

			if (ftp->PutFile((string)filename, (string)"temp")) {
				// send the file to the server

				ftp->Chmod((string)"temp", (string)"644");
				// make it world readable

				UpdateFtpStatus(B_TRANSLATE("Renaming" B_UTF8_ELLIPSIS));

				if (ftp->MoveFile((string)"temp", (string)filename)) {
					// change to the desired name
					uint32 time = real_time_clock();
					char s[80];
					strcpy(s, B_TRANSLATE("Last Capture: "));
					strcat(s, ctime((const time_t*)&time));
					s[strlen(s) - 1] = 0;
					UpdateFtpStatus(s);
					delete ftp;
					return B_OK;
				} else
					UpdateFtpStatus(B_TRANSLATE("Rename failed"));
			} else
				UpdateFtpStatus(B_TRANSLATE("File upload failed"));
		} else
			UpdateFtpStatus(B_TRANSLATE("Couldn't find requested directory on "
				"server"));
	}
	else
		UpdateFtpStatus(B_TRANSLATE("Server login failed"));

	delete ftp;
	return B_ERROR;
}


status_t
SetFileType(BFile* file, int32 translator, uint32 type)
{
	translation_format* formats;
	int32 count;

	status_t err = BTranslatorRoster::Default()->GetOutputFormats(translator,
		(const translation_format**)&formats, &count);
	if (err < B_OK)
		return err;

	const char* mime = NULL;
	for (int ix = 0; ix < count; ix++) {
		if (formats[ix].type == type) {
			mime = formats[ix].MIME;
			break;
		}
	}

	if (mime == NULL) {
		/* this should not happen, but being defensive might be prudent */
		return B_ERROR;
	}

	/* use BNodeInfo to set the file type */
	BNodeInfo ninfo(file);
	return ninfo.SetType(mime);
}