#include "PL_Gainer.h"
#include "MaterialBuffer.h"
#include "logger.h"

#include <string.h> // for memcpy

struct PL_Gainer_Internal
{
	PL_Gainer_Config config;
	PipeMaterial lastPm;
	MB_Frame lastFrame;

	PL_Gainer_Internal() : 
		config(), lastPm(), lastFrame()
	{
	}
	
	~PL_Gainer_Internal()
	{
	}
	
	void reset()
	{
		PL_Gainer_Config _config;
		config = _config;
		
		PipeMaterial _lastPm;
		lastPm = _lastPm;
		
		MB_Frame _lastFrame;
		lastFrame = _lastFrame;
	}
};

PipeLineElem* create_PL_Gainer()
{
	return new PL_Gainer;
}

PL_Gainer::PL_Gainer() : internal(new PL_Gainer_Internal)
{
}

PL_Gainer::~PL_Gainer()
{
	delete (PL_Gainer_Internal*)internal;
	internal= nullptr;
}

bool PL_Gainer::init(void* args)
{
	PL_Gainer_Internal* in = (PL_Gainer_Internal*)internal;
	in->reset();
	
	if (args != nullptr)
	{
		PL_Gainer_Config* config = (PL_Gainer_Config*)args;
		in->config = *config;
	}

	return true;
}

void PL_Gainer::finit()
{
	PL_Gainer_Internal* in = (PL_Gainer_Internal*)internal;
	
}

void pl_gainer_deleter_func(PipeMaterial* pm, bool lastRet)
{
	PL_Gainer_Internal* in = (PL_Gainer_Internal*)(pm->args);

	if (in->config.copyData)
	{
		switch(pm->type)
		{
		case PipeMaterial::PMT_BYTES:
		{
			delete[] (uint8_t*)pm->buffer;
		}
		break;
		case PipeMaterial::PMT_FRAME:
		{
			MB_Frame* pmFrame = (MB_Frame*)(pm->buffer);
			delete[] (uint8_t*)pmFrame->buffer;
		}
		break;
		default:
			//#todo support list or pm::copier operator
			LOG_ERROR << "Only support PMT_BYTES / PMT_FRAME" << std::endl;
			return;
		}
	}
	
	PipeMaterial _pm;
	*pm = _pm;
}

bool PL_Gainer::pay(const PipeMaterial& pm)
{
	return false;
}

bool PL_Gainer::gain(PipeMaterial& pm)
{
	PL_Gainer_Internal* in = (PL_Gainer_Internal*)internal;

	if (in->config.copyData)
	{
		PipeMaterial newPm = pm;

		switch(pm.type)
		{
		case PipeMaterial::PMT_BYTES:
		{
			newPm.buffer = new uint8_t[pm.buffSize];
			memcpy(newPm.buffer, pm.buffer, pm.buffSize);
		}
		break;
		case PipeMaterial::PMT_FRAME:
		{
			MB_Frame* pmFrame = (MB_Frame*)(pm.buffer);
			in->lastFrame = *pmFrame;
			in->lastFrame.buffer = new uint8_t[pmFrame->buffSize];
			memcpy(in->lastFrame.buffer, pmFrame->buffer, pmFrame->buffSize);
			
			newPm.buffer = &(in->lastFrame);
		}
		break;
		default:
			//#todo support list or pm::copier operator
			LOG_ERROR << "Only support PMT_BYTES / PMT_FRAME" << std::endl;
			return false;
		}
		
		newPm.args = in;
		newPm.deleter = pl_gainer_deleter_func;
		
		newPm.former = this;
		
		if (pm.deleter != nullptr)
			(pm.deleter)(&pm, false);//#todo
		
		pm = newPm;
		return true;
	}
	else
	{
		pm.former = this;
		return true;
	}
}