#ifndef _LIVOX_GEN1_PCLOUD_AMBIENCE_STIMULUS_BUFFER_H
#define _LIVOX_GEN1_PCLOUD_AMBIENCE_STIMULUS_BUFFER_H

#include <memory>
#include <cstdint>
#include <list>
#include <cstddef>
#include <optional>
#include <vector>
#include <string>
#include <user/stimulusBuffer.h>
#include <user/stagingBuffer.h>
#include <user/deviceAttachmentSpec.h>
#include <user/intrinThresholdParams.h>
#include "pcloudAmbienceQualeIfaceApi.h"
#include "lg1PcloudAmbienceStencil.h"

namespace smo {
namespace stim_buff {

enum class IntrinStatus
{
	DISABLED,
	NEGTRIN,
	POSTRIN,
};

struct ParsedAmbienceIntrinConfig
{
	IntrinStatus status;
	uint32_t interestPercentage;
	uint32_t interestThreshold;
};

inline bool isAmbienceIntrinEnabled(IntrinStatus intrinStatus)
{
	return intrinStatus != IntrinStatus::DISABLED;
}

inline intrin::ParsedThresholdParam parseAmbienceThresholdParam(
	const std::string& paramName,
	const std::string& paramValue,
	intrin::ThresholdUnit unit)
{
	try
	{
		return intrin::ParsedThresholdParam{
			.value = std::stoi(paramValue),
			.unit = unit,
			.matchedName = paramName,
			.wasSpecified = true,
		};
	}
	catch (const std::exception& e)
	{
		throw std::runtime_error(
			"Failed to parse '" + paramName + "' param value '" + paramValue
			+ "' as integer: " + e.what());
	}
}

inline ParsedAmbienceIntrinConfig buildAmbienceIntrinConfig(
	IntrinStatus status,
	const intrin::ParsedThresholdParam& thresholdParam,
	size_t nDgramsPerFrame)
{
	return ParsedAmbienceIntrinConfig{
		.status = status,
		.interestPercentage =
			thresholdParam.unit == intrin::ThresholdUnit::Percentage
				? static_cast<uint32_t>(thresholdParam.value)
				: 0U,
		.interestThreshold = intrin::resolveThresholdValue(
			thresholdParam, nDgramsPerFrame),
	};
}

inline std::optional<ParsedAmbienceIntrinConfig> tryParseAmbienceIntrinConfig(
	const std::string& paramName,
	const std::string& paramValue,
	size_t nDgramsPerFrame)
{
	using intrin::ThresholdUnit;

	if (intrin::namesContain(intrin::kPosIntPcParamNames, paramName))
	{
		return buildAmbienceIntrinConfig(
			IntrinStatus::POSTRIN,
			parseAmbienceThresholdParam(
				paramName, paramValue, ThresholdUnit::Percentage),
			nDgramsPerFrame);
	}

	if (intrin::namesContain(intrin::kPosIntThrParamNames, paramName))
	{
		return buildAmbienceIntrinConfig(
			IntrinStatus::POSTRIN,
			parseAmbienceThresholdParam(
				paramName, paramValue, ThresholdUnit::Absolute),
			nDgramsPerFrame);
	}

	if (intrin::namesContain(intrin::kNegIntPcParamNames, paramName))
	{
		return buildAmbienceIntrinConfig(
			IntrinStatus::NEGTRIN,
			parseAmbienceThresholdParam(
				paramName, paramValue, ThresholdUnit::Percentage),
			nDgramsPerFrame);
	}

	if (intrin::namesContain(intrin::kNegIntThrParamNames, paramName))
	{
		return buildAmbienceIntrinConfig(
			IntrinStatus::NEGTRIN,
			parseAmbienceThresholdParam(
				paramName, paramValue, ThresholdUnit::Absolute),
			nDgramsPerFrame);
	}

	return std::nullopt;
}

inline ParsedAmbienceIntrinConfig parseAmbienceIntrinConfig(
	const std::shared_ptr<device::DeviceAttachmentSpec>& deviceAttachmentSpec,
	size_t nDgramsPerFrame)
{
	const auto& params = deviceAttachmentSpec->qualeIfaceApiParams;

	for (auto paramIt = params.rbegin(); paramIt != params.rend(); ++paramIt)
	{
		const auto& [paramName, paramValue] = *paramIt;
		const auto parsedConfig = tryParseAmbienceIntrinConfig(
			paramName, paramValue, nDgramsPerFrame);
		if (parsedConfig.has_value())
			{ return parsedConfig.value(); }
	}

	return ParsedAmbienceIntrinConfig{
		.status = IntrinStatus::DISABLED,
		.interestPercentage = 0U,
		.interestThreshold = 0U,
	};
}

inline void validateAmbienceIntrinComparatorConfig(
	IntrinStatus intrinStatus,
	const std::optional<ParamComparator>& ambienceCountComparator)
{
	if (isAmbienceIntrinEnabled(intrinStatus)
		&& !ambienceCountComparator.has_value())
	{
		throw std::runtime_error(
			"A pcloudAmbience stim buff instance with an intrin threshold "
			"must also specify either 'ambience-count-gt-val' or "
			"'ambience-count-lt-val'");
	}
}

// Forward declaration
class StimulusProducer;

/**
 * PcloudAmbienceStimulusBuffer is a specialized StimulusBuffer for ambience point cloud data.
 */
class PcloudAmbienceStimulusBuffer
:	public StimulusBuffer
{
public:
	explicit PcloudAmbienceStimulusBuffer(
		StimulusProducer& parent,
		const std::shared_ptr<device::DeviceAttachmentSpec>& deviceAttachmentSpec,
		int histbuffMs,
		const StagingBuffer::IOEngineConstraints& inputEngineConstraints,
		const StagingBuffer::IOEngineConstraints& outputEngineConstraints,
		const SmoCallbacks& callbacks,
		cl_mem_flags flags,
		size_t nStencils_, size_t nDgramsPerFrame_)
	:	StimulusBuffer(
			parent, deviceAttachmentSpec, histbuffMs,
			inputEngineConstraints, outputEngineConstraints,
			callbacks, flags),
	nStencils(nStencils_)
	{
		intrin::validateNoForbiddenUnitlessIntrinParams(
			deviceAttachmentSpec->qualeIfaceApiParams);

		const auto intrinConfig = parseAmbienceIntrinConfig(
			deviceAttachmentSpec, nDgramsPerFrame_);
		intrinStatus = intrinConfig.status;
		intrinInterestPercentage = intrinConfig.interestPercentage;
		intrinInterestThreshold = intrinConfig.interestThreshold;

		ambienceCountComparator = parseOptionalPcloudAmbienceParamComparator(
			deviceAttachmentSpec);
		validateAmbienceIntrinComparatorConfig(
			intrinStatus, ambienceCountComparator);

		// Construct stencils and add to list (FIFO behavior)
		for (size_t i = 0; i < nStencils; ++i) {
			stencils.emplace_back();
		}
	}

	~PcloudAmbienceStimulusBuffer() = default;

	bool shouldTriggerIntrinEvent(uint32_t ambiencePassbandCount) const
	{
		if (!isAmbienceIntrinEnabled(intrinStatus))
			{ return false; }

		return ambiencePassbandCount >= intrinInterestThreshold;
	}

	// Non-copyable, non-movable: inherited pinner lifetime is instance-bound
	PcloudAmbienceStimulusBuffer(const PcloudAmbienceStimulusBuffer&) = delete;
	PcloudAmbienceStimulusBuffer& operator=(const PcloudAmbienceStimulusBuffer&) = delete;
	PcloudAmbienceStimulusBuffer(PcloudAmbienceStimulusBuffer&&) = delete;
	PcloudAmbienceStimulusBuffer& operator=(PcloudAmbienceStimulusBuffer&&) = delete;

public:
	IntrinStatus intrinStatus;
	uint32_t intrinInterestPercentage;
	uint32_t intrinInterestThreshold;
	std::optional<ParamComparator> ambienceCountComparator;
	size_t nStencils;
	std::list<LG1PcloudAmbienceStencil> stencils;
};

} // namespace stim_buff
} // namespace smo

#endif // _LIVOX_GEN1_PCLOUD_AMBIENCE_STIMULUS_BUFFER_H