#include "PostProcessor.hh"

#include "AviRecorder.hh"

#include "CliComm.hh"

#include "CommandException.hh"

#include "Deflicker.hh"

#include "DeinterlacedFrame.hh"

#include "Display.hh"

#include "DoubledFrame.hh"

#include "Event.hh"

#include "EventDistributor.hh"

#include "FloatSetting.hh"

#include "GLContext.hh"

#include "GLScaler.hh"

#include "GLScalerFactory.hh"

#include "MSXMotherBoard.hh"

#include "OutputSurface.hh"

#include "PNG.hh"

#include "RawFrame.hh"

#include "Reactor.hh"

#include "RenderSettings.hh"

#include "SuperImposedFrame.hh"

#include "gl_transform.hh"

#include "MemBuffer.hh"

#include "aligned.hh"

#include "inplace_buffer.hh"

#include "narrow.hh"

#include "random.hh"

#include "ranges.hh"

#include "stl.hh"

#include "xrange.hh"

#include <algorithm>

#include <cassert>

#include <cstdint>

#include <memory>

#include <numeric>

using namespace gl;

namespace openmsx {

PostProcessor::PostProcessor(

	MSXMotherBoard& motherBoard_, Display& display_,

	OutputSurface& screen_, const std::string& videoSource,

	unsigned maxWidth_, unsigned height_, bool canDoInterlace_)

	: VideoLayer(motherBoard_, videoSource)

	, Schedulable(motherBoard_.getScheduler())

	, display(display_)

	, renderSettings(display_.getRenderSettings())

	, eventDistributor(motherBoard_.getReactor().getEventDistributor())

	, screen(screen_)

	, maxWidth(maxWidth_)

	, height(height_)

	, canDoInterlace(canDoInterlace_)

	, lastRotate(motherBoard_.getCurrentTime())

{

	if (canDoInterlace) {

		deinterlacedFrame = std::make_unique<DeinterlacedFrame>();

		interlacedFrame   = std::make_unique<DoubledFrame>();

		deflicker = std::make_unique<Deflicker>(lastFrames);

		superImposedFrame = std::make_unique<SuperImposedFrame>();

	} else {

		// Laserdisc always produces non-interlaced frames, so we don't

		// need lastFrames[1..3], deinterlacedFrame and

		// interlacedFrame. Also it produces a complete frame at a

		// time, so we don't need lastFrames[0] (and have a separate

		// work buffer, for partially rendered frames).

	}

	preCalcNoise(renderSettings.getNoise());

	initBuffers();

	VertexShader   vertexShader  ("monitor3D.vert");

	FragmentShader fragmentShader("monitor3D.frag");

	monitor3DProg.attach(vertexShader);

	monitor3DProg.attach(fragmentShader);

	monitor3DProg.bindAttribLocation(0, "a_position");

	monitor3DProg.bindAttribLocation(1, "a_normal");

	monitor3DProg.bindAttribLocation(2, "a_texCoord");

	monitor3DProg.link();

	preCalcMonitor3D(renderSettings.getHorizontalStretch());

	pbo.allocate(maxWidth * height * 2); // *2 for interlace    TODO only when 'canDoInterlace'

	renderSettings.getNoiseSetting().attach(*this);

	renderSettings.getHorizontalStretchSetting().attach(*this);

}

PostProcessor::~PostProcessor()

{

	renderSettings.getHorizontalStretchSetting().detach(*this);

	renderSettings.getNoiseSetting().detach(*this);

	if (recorder) {

		getCliComm().printWarning(

			"Video recording stopped, because you "

			"changed machine or changed a video setting "

			"during recording.");

		recorder->stop();

	}

}

void PostProcessor::initBuffers()

{

	// combined positions and texture coordinates

	static constexpr std::array pos_tex = {

		vec2(-1, 1), vec2(-1,-1), vec2( 1,-1), vec2( 1, 1), // pos

		vec2( 0, 1), vec2( 0, 0), vec2( 1, 0), vec2( 1, 1), // tex

	};

	glBindBuffer(GL_ARRAY_BUFFER, vbo.get());

	glBufferData(GL_ARRAY_BUFFER, sizeof(pos_tex), pos_tex.data(), GL_STATIC_DRAW);

	glBindBuffer(GL_ARRAY_BUFFER, 0);

}

CliComm& PostProcessor::getCliComm()

{

	return display.getCliComm();

}

unsigned PostProcessor::getLineWidth(

	FrameSource* frame, unsigned y, unsigned step)

{

	return max_value(xrange(step), [&](auto i) { return frame->getLineWidth(y + i); });

}

void PostProcessor::executeUntil(EmuTime /*time*/)

{

	// insert fake end of frame event

	eventDistributor.distributeEvent(FinishFrameEvent(

		getVideoSource(), getVideoSourceSetting(), false));

}

using WorkBuffer = std::vector<MemBuffer<FrameSource::Pixel, SSE_ALIGNMENT>>;

static void getScaledFrame(const FrameSource& paintFrame,

                           std::span<const FrameSource::Pixel*> lines,

                           WorkBuffer& workBuffer)

{

	auto height = narrow<unsigned>(lines.size());

	unsigned width = (height == 240) ? 320 : 640;

	const FrameSource::Pixel* linePtr = nullptr;

	FrameSource::Pixel* work = nullptr;

	for (auto i : xrange(height)) {

		if (linePtr == work) {

			// If work buffer was used in previous iteration,

			// then allocate a new one.

			work = workBuffer.emplace_back(width).data();

		}

		if (height == 240) {

			auto line = paintFrame.getLinePtr320_240(i, std::span<uint32_t, 320>{work, 320});

			linePtr = line.data();

		} else {

			assert (height == 480);

			auto line = paintFrame.getLinePtr640_480(i, std::span<uint32_t, 640>{work, 640});

			linePtr = line.data();

		}

		lines[i] = linePtr;

	}

}

void PostProcessor::takeRawScreenShot(std::optional<unsigned> desiredHeight, const std::string& filename)

{

	if (!paintFrame) {

		throw CommandException("TODO");

	}

	const unsigned targetHeight = desiredHeight ? *desiredHeight : [this] {

		auto maxLineWidth = getLineWidth(paintFrame, 0, paintFrame->getHeight());

		if (maxLineWidth == 320) return 240;

		// in all other cases (there could be other than 640), we go for 640x480

		return 480;

	}();

	inplace_buffer<const FrameSource::Pixel*, 480> lines(uninitialized_tag{}, targetHeight);

	WorkBuffer workBuffer;

	getScaledFrame(*paintFrame, lines, workBuffer);

	unsigned width = (targetHeight == 240) ? 320 : 640;

	PNG::saveRGBA(width, lines, filename);

}

void PostProcessor::createRegions()

{

	regions.clear();

	const unsigned srcHeight = paintFrame->getHeight();

	const unsigned dstHeight = screen.getLogicalHeight();

	regionsDstHeight = dstHeight;

	unsigned g = std::gcd(srcHeight, dstHeight);

	unsigned srcStep = srcHeight / g;

	unsigned dstStep = dstHeight / g;

	// TODO: Store all MSX lines in RawFrame and only scale the ones that fit

	//       on the PC screen, as a preparation for resizable output window.

	unsigned srcStartY = 0;

	unsigned dstStartY = 0;

	while (dstStartY < dstHeight) {

		// Currently this is true because the source frame height

		// is always >= dstHeight/(dstStep/srcStep).

		assert(srcStartY < srcHeight);

		// get region with equal lineWidth

		unsigned lineWidth = getLineWidth(paintFrame, srcStartY, srcStep);

		unsigned srcEndY = srcStartY + srcStep;

		unsigned dstEndY = dstStartY + dstStep;

		while ((srcEndY < srcHeight) && (dstEndY < dstHeight) &&

		       (getLineWidth(paintFrame, srcEndY, srcStep) == lineWidth)) {

			srcEndY += srcStep;

			dstEndY += dstStep;

		}

		regions.emplace_back(srcStartY, srcEndY,

		                     dstStartY, dstEndY,

		                     lineWidth);

		// next region

		srcStartY = srcEndY;

		dstStartY = dstEndY;

	}

}

void PostProcessor::paint(OutputSurface& /*output*/)

{

	if (renderSettings.getInterleaveBlackFrame()) {

		interleaveCount ^= 1;

		if (interleaveCount) {

			glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

			glClear(GL_COLOR_BUFFER_BIT);

			return;

		}

	}

	auto deform = renderSettings.getDisplayDeform();

	float horStretch = renderSettings.getHorizontalStretch();

	int glow = renderSettings.getGlow();

	if ((screen.getViewOffset() != ivec2()) || // any part of the screen not covered by the viewport?

	    (deform == RenderSettings::DisplayDeform::_3D) || !paintFrame) {

		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

		glClear(GL_COLOR_BUFFER_BIT);

		if (!paintFrame) {

			return;

		}

	}

	auto size = screen.getLogicalSize();

	bool needReUpload = size.y != int(regionsDstHeight);

	// New scaler algorithm selected?

	if (auto algo = renderSettings.getScaleAlgorithm();

	    scaleAlgorithm != algo) {

		scaleAlgorithm = algo;

		currScaler = GLScalerFactory::createScaler(renderSettings, maxWidth, height * 2); // *2 for interlace   TODO only when canDoInterlace

		needReUpload = true;

	}

	if (needReUpload) {

		// Re-upload frame data, this is both

		//  - Chunks of RawFrame with a specific line width, possibly

		//    with some extra lines above and below each chunk that are

		//    also converted to this line width.

		//  - Extra data that is specific for the scaler (ATM only the

		//    hq and hqlite scalers require this).

		// Re-uploading the first is not strictly needed. But switching

		// scalers doesn't happen that often, so it also doesn't hurt

		// and it keeps the code simpler.

		uploadFrame();

	}

	glViewport(0, 0, size.x, size.y);

	glBindTexture(GL_TEXTURE_2D, 0);

	auto& renderedFrame = renderedFrames[frameCounter & 1];

	if (renderedFrame.size != size) {

		renderedFrame.tex.bind();

		renderedFrame.tex.setInterpolation(true);

		glTexImage2D(GL_TEXTURE_2D,     // target

			     0,                 // level

			     GL_RGB,            // internal format

			     size.x,            // width

			     size.y,            // height

			     0,                 // border

			     GL_RGB,            // format

			     GL_UNSIGNED_BYTE,  // type

			     nullptr);          // data

		renderedFrame.fbo = FrameBufferObject(renderedFrame.tex);

	}

	renderedFrame.fbo.push();

	for (const auto& r : regions) {

		auto it = find_unguarded(textures, r.lineWidth, &TextureData::width);

		auto* superImpose = superImposeVideoFrame

		                  ? &superImposeTex : nullptr;

		currScaler->scaleImage(

			it->tex, superImpose,

			r.srcStartY, r.srcEndY, r.lineWidth, // src

			r.dstStartY, r.dstEndY, size.x,   // dst

			paintFrame->getHeight()); // dst

	}

	drawNoise();

	drawGlow(glow);

	renderedFrame.fbo.pop();

	renderedFrame.tex.bind();

	if (renderSettings.getFullStretch()) {

		auto [w, h] = screen.getPhysicalSize();

		glViewport(0, 0, w, h);

	} else {

		auto [x, y] = screen.getViewOffset();

		auto [w, h] = screen.getViewSize();

		glViewport(x, y, w, h);

	}

	if (deform == RenderSettings::DisplayDeform::_3D) {

		drawMonitor3D();

	} else {

		float x1 = (320.0f - horStretch) * (1.0f / (2.0f * 320.0f));

		float x2 = 1.0f - x1;

		std::array tex = {

			vec2(x1, 1), vec2(x1, 0), vec2(x2, 0), vec2(x2, 1)

		};

		const auto& glContext = *gl::context;

		glContext.progTex.activate();

		glUniform4f(glContext.unifTexColor,

				1.0f, 1.0f, 1.0f, 1.0f);

		mat4 I;

		glUniformMatrix4fv(glContext.unifTexMvp, 1, GL_FALSE, I.data());

		glBindBuffer(GL_ARRAY_BUFFER, vbo.get());

		glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);

		glEnableVertexAttribArray(0);

		glBindBuffer(GL_ARRAY_BUFFER, stretchVBO.get());

		glBufferData(GL_ARRAY_BUFFER, sizeof(tex), tex.data(), GL_STREAM_DRAW);

		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);

		glEnableVertexAttribArray(1);

		glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

		glDisableVertexAttribArray(1);

		glDisableVertexAttribArray(0);

		glBindBuffer(GL_ARRAY_BUFFER, 0);

	}

	storedFrame = true;

	//gl::checkGLError("PostProcessor::paint");

}

std::unique_ptr<RawFrame> PostProcessor::rotateFrames(

	std::unique_ptr<RawFrame> finishedFrame, EmuTime time)

{

	if (renderSettings.getInterleaveBlackFrame()) {

		auto delta = time - lastRotate; // time between last two calls

		auto middle = time + delta / 2; // estimate for middle between now

		                                // and next call

		setSyncPoint(middle);

	}

	lastRotate = time;

	// Figure out how many past frames we want to use.

	int numRequired = 1;

	bool doDeinterlace = false;

	bool doInterlace   = false;

	bool doDeflicker   = false;

	auto currType = finishedFrame->getField();

	if (canDoInterlace) {

		if (currType != FrameSource::FieldType::NONINTERLACED) {

			if (renderSettings.getDeinterlace()) {

				doDeinterlace = true;

				numRequired = 2;

			} else {

				doInterlace = true;

			}

		} else if (renderSettings.getDeflicker()) {

			doDeflicker = true;

			numRequired = 4;

		}

	}

	// Which frame can be returned (recycled) to caller. Prefer to return

	// the youngest frame to improve cache locality.

	int recycleIdx = (lastFramesCount < numRequired)

		? lastFramesCount++  // store one more

		: (numRequired - 1); // youngest that's no longer needed

	assert(recycleIdx < 4);

	auto recycleFrame = std::move(lastFrames[recycleIdx]); // might be nullptr

	// Insert new frame in front of lastFrames[], shift older frames

	std::move_backward(&lastFrames[0], &lastFrames[recycleIdx],

	                   &lastFrames[recycleIdx + 1]);

	lastFrames[0] = std::move(finishedFrame);

	// Are enough frames available?

	if (lastFramesCount >= numRequired) {

		// Only the last 'numRequired' are kept up to date.

		lastFramesCount = numRequired;

	} else {

		// Not enough past frames, fall back to 'regular' rendering.

		// This situation can only occur when:

		// - The very first frame we render needs to be deinterlaced.

		//   In other case we have at least one valid frame from the

		//   past plus one new frame passed via the 'finishedFrame'

		//   parameter.

		// - Or when (re)enabling the deflicker setting. Typically only

		//   1 frame in lastFrames[] is kept up-to-date (and we're

		//   given 1 new frame), so it can take up-to 2 frame after

		//   enabling deflicker before it actually takes effect.

		doDeinterlace = false;

		doInterlace   = false;

		doDeflicker   = false;

	}

	// Setup the to-be-painted frame

	if (doDeinterlace) {

		if (currType == FrameSource::FieldType::ODD) {

			deinterlacedFrame->init(lastFrames[1].get(), lastFrames[0].get());

		} else {

			deinterlacedFrame->init(lastFrames[0].get(), lastFrames[1].get());

		}

		paintFrame = deinterlacedFrame.get();

	} else if (doInterlace) {

		interlacedFrame->init(

			lastFrames[0].get(),

			(currType == FrameSource::FieldType::ODD) ? 1 : 0);

		paintFrame = interlacedFrame.get();

	} else if (doDeflicker) {

		deflicker->init();

		paintFrame = deflicker.get();

	} else {

		paintFrame = lastFrames[0].get();

	}

	if (superImposeVdpFrame) {

		superImposedFrame->init(paintFrame, superImposeVdpFrame);

		paintFrame = superImposedFrame.get();

	}

	// Possibly record this frame

	if (recorder && needRecord()) {

		try {

			recorder->addImage(paintFrame, time);

		} catch (MSXException& e) {

			getCliComm().printWarning(

				"Recording stopped with error: ",

				e.getMessage());

			recorder->stop();

			assert(!recorder);

		}

	}

	// Return recycled frame to the caller

	std::unique_ptr<RawFrame> reuseFrame = [&] {

		if (canDoInterlace) {

			if (!recycleFrame) [[unlikely]] {

				recycleFrame = std::make_unique<RawFrame>(maxWidth, height);

			}

			return std::move(recycleFrame);

		} else {

			return std::move(lastFrames[0]);

		}

	}();

	uploadFrame();

	++frameCounter;

	noiseX = random_float(0.0f, 1.0f);

	noiseY = random_float(0.0f, 1.0f);

	return reuseFrame;

}

void PostProcessor::update(const Setting& setting) noexcept

{

	VideoLayer::update(setting);