plotbuilder.cpp

#include "plotbuilder.h"

#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <map>
#include <memory>
#include <optional>
#include <ranges>
#include <stdexcept>
#include <tuple>
#include <utility>
#include <vector>

#include "base/anim/interpolated.h"
#include "base/math/floating.h"
#include "base/math/range.h"
#include "base/refl/auto_enum.h"
#include "base/text/naturalcmp.h"
#include "chart/main/style.h"
#include "chart/options/align.h"
#include "chart/options/channel.h"
#include "chart/options/coordsystem.h"
#include "chart/options/options.h"
#include "chart/options/shapetype.h"
#include "chart/options/sort.h"
#include "chart/speclayout/bubblechartbuilder.h"
#include "chart/speclayout/tablechart.h"
#include "chart/speclayout/treemap.h"
#include "dataframe/old/datatable.h"
#include "dataframe/old/types.h"

#include "buckets.h"
#include "colorbase.h"
#include "plot.h"

namespace Vizzu::Gen
{

PlotBuilder::PlotBuilder(const Data::DataTable &dataTable,
    const PlotOptionsPtr &options,
    const Styles::Chart &style) :
    dataCube(dataTable, *options),
    plot(std::make_shared<Plot>(options, style))
{
	initDimensionTrackers();

	std::size_t mainBucketSize{};
	std::size_t subBucketSize{};
	auto &&buckets = generateMarkers(mainBucketSize, subBucketSize);

	if (!plot->getOptions()->getChannels().anyAxisSet()) {
		addSpecLayout(buckets);
		normalizeSizes();
	}
	else {
		normalizeSizes();
		addAxisLayout(buckets,
		    mainBucketSize,
		    subBucketSize,
		    dataTable);
	}

	normalizeColors();
	calcLegendAndLabel(dataTable);
}

void PlotBuilder::addAxisLayout(Buckets &buckets,
    const std::size_t &mainBucketSize,
    const std::size_t &subBucketSize,
    const Data::DataTable &dataTable)
{
	linkMarkers(buckets, mainBucketSize, subBucketSize);
	calcAxises(dataTable);
	addAlignment(buckets, plot->getOptions()->subAxisType());
	addAlignment(buckets.sort(&Marker::mainId),
	    plot->getOptions()->mainAxisType());
}

void PlotBuilder::initDimensionTrackers()
{
	for (auto type : Refl::enum_values<ChannelId>())
		if (auto &&ch = plot->getOptions()->getChannels().at(type);
		    !ch.hasMeasure())
			stats.tracked.at(type).emplace<1>(
			    dataCube.combinedSizeOf(ch.dimensions()).second);
}

Buckets PlotBuilder::generateMarkers(std::size_t &mainBucketSize,
    std::size_t &subBucketSize)
{
	const auto &mainIds(plot->getOptions()->mainAxis().dimensions());
	auto subIds(plot->getOptions()->subAxis().dimensions());
	if (!dataCube.empty()) {
		if (plot->getOptions()->geometry == ShapeType::area)
			subIds.split_by(mainIds);

		mainBucketSize = dataCube.combinedSizeOf(mainIds).first;
		subBucketSize = dataCube.combinedSizeOf(subIds).first;
		plot->markers.reserve(dataCube.df->get_record_count());
	}

	std::multimap<Marker::MarkerIndex, Options::MarkerInfoId> map;
	for (auto &&[ix, mid] : plot->getOptions()->markersInfo)
		map.emplace(mid, ix);

	for (auto first = map.begin(); auto &&index : dataCube)
		for (auto &marker =
		         plot->markers.emplace_back(*plot->getOptions(),
		             dataCube,
		             stats,
		             mainIds,
		             subIds,
		             index,
		             map.contains(index.marker_id));
		     first != map.end() && first->first == marker.idx;
		     ++first)
			plot->markersInfo.insert({first->second,
			    Plot::MarkerInfo{Plot::MarkerInfoContent{marker}}});

	if (!std::ranges::is_sorted(plot->markers, {}, &Marker::idx))
		throw std::runtime_error(
		    "One of your series name or category contains control "
		    "character (possible tab/endline).");

	return Buckets{plot->markers};
}

std::vector<PlotBuilder::BucketInfo> PlotBuilder::sortedBuckets(
    const Buckets &buckets,
    AxisId axisIndex) const
{
	std::vector<BucketInfo> sorted;

	for (auto &&bucket : buckets)
		for (auto &&[marker, idx] : bucket) {
			if (!marker.enabled) continue;

			// NOLINTNEXTLINE(misc-include-cleaner)
			auto it = std::ranges::lower_bound(sorted,
			    idx.itemId,
			    {},
			    &BucketInfo::index);
			if (it == sorted.end() || it->index != idx.itemId)
				it = sorted.emplace(it,
				    idx.itemId,
				    0.0,
				    (marker.*buckets.marker_id_get).label
				        ? &(marker.*buckets.marker_id_get)
				               .label->value
				        : nullptr);

			it->size += marker.size.getCoord(
			    !plot->getOptions()->getOrientation());
		}

	switch (plot->getOptions()
	            ->getChannels()
	            .axisPropsAt(axisIndex)
	            .sort) {
	case Sort::byValue:
		std::ranges::stable_sort(sorted,
		    [](const BucketInfo &lhs, const BucketInfo &rhs)
		    {
			    return Math::Floating::less(lhs.size, rhs.size);
		    });
		break;
	case Sort::byLabel:
		std::ranges::stable_sort(sorted,
		    [](const BucketInfo &lhs, const BucketInfo &rhs)
		    {
			    if (rhs.label == nullptr || lhs.label == nullptr)
				    return lhs.label != nullptr;
			    return Text::NaturalCmp{}(*lhs.label, *rhs.label);
		    });
		break;
	default: break;
	}

	if (plot->getOptions()
	        ->getChannels()
	        .axisPropsAt(axisIndex)
	        .reverse)
		std::reverse(sorted.begin(), sorted.end());

	return sorted;
}

void PlotBuilder::addSpecLayout(Buckets &buckets)
{
	auto geometry = plot->getOptions()->geometry->value;
	if (auto &markers = plot->markers; isConnecting(geometry))
		Charts::TableChart::setupVector(markers, true);
	else if (!plot->getOptions()->isMeasure(ChannelId::size))
		Charts::TableChart::setupVector(markers);
	else if (!dataCube.empty()) {
		if (buckets.sort(&Marker::sizeId);
		    geometry == ShapeType::circle) {
			Charts::BubbleChartBuilder::setupVector(
			    *plot->getStyle().plot.marker.circleMaxRadius,
			    buckets);

			plot->keepAspectRatio = true;
		}
		else
			Charts::TreeMapBuilder::setupVector(buckets);
	}
}

void PlotBuilder::linkMarkers(Buckets &buckets,
    const std::size_t &mainBucketSize,
    const std::size_t &subBucketSize)
{
	auto &&hasMarkerConnection =
	    linkMarkers(buckets.sort(&Marker::mainId),
	        plot->getOptions()->mainAxisType());
	addSeparation(buckets,
	    plot->getOptions()->mainAxisType(),
	    subBucketSize);
	std::ignore = linkMarkers(buckets.sort(&Marker::subId),
	    plot->getOptions()->subAxisType());
	addSeparation(buckets,
	    plot->getOptions()->subAxisType(),
	    mainBucketSize);

	if (hasMarkerConnection
	    && plot->getOptions()->geometry.get() == ShapeType::line
	    && !plot->getOptions()
	            ->getChannels()
	            .at(AxisId::x)
	            .hasMeasure()
	    && !plot->getOptions()
	            ->getChannels()
	            .at(AxisId::y)
	            .hasMeasure()) {
		plot->markerConnectionOrientation.emplace(
		    *plot->getOptions()->orientation.get());
	}
}

bool PlotBuilder::linkMarkers(const Buckets &buckets,
    AxisId axisIndex) const
{
	auto isMain = axisIndex == plot->getOptions()->mainAxisType();
	auto &&sorted = sortedBuckets(buckets, axisIndex);

	std::vector dimOffset(sorted.size(),
	    std::numeric_limits<double>::lowest());

	auto isAggregatable =
	    !plot->getOptions()->isMeasure(+axisIndex)
	    || (isMain && plot->getOptions()->isMeasure(+!axisIndex)
	        && plot->getOptions()->geometry.get()
	               == ShapeType::rectangle);

	if (isAggregatable) {
		double pre_neg{};
		double pre_pos{};
		for (std::size_t ix{}, max = sorted.size(); ix < max; ++ix) {
			auto &o = dimOffset[ix];
			for (const auto &bucket : buckets) {
				auto &&ids = std::ranges::views::values(bucket);
				auto sIx = sorted[ix].index;
				auto it = std::ranges::lower_bound(ids,
				    sIx,
				    {},
				    &Data::MarkerId::itemId);
				if (it == ids.end() || (*it).itemId != sIx) continue;

				auto &marker = **it.base().base().base();
				if (!marker.enabled) continue;
				o = std::max(o,
				    marker.size.getCoord(orientation(axisIndex)),
				    Math::Floating::less);
			}
			if (o == std::numeric_limits<double>::lowest()) o = 0.0;

			if (std::signbit(o))
				std::swap(o += pre_neg, pre_neg);
			else
				std::swap(o += pre_pos, pre_pos);
		}
	}

	bool hasConnection{};

	auto polar =
	    plot->getOptions()->coordSystem.get() == CoordSystem::polar;
	auto connecting =
	    isConnecting(plot->getOptions()->geometry.get());

	auto needPolarConnection = polar && connecting && isMain
	                        && plot->getOptions()->isHorizontal();

	for (const auto &bucket : buckets) {
		double prevPos{};
		for (auto i = 0U; i < sorted.size(); ++i) {
			auto idAct = sorted[i].index;
			auto &&ids = std::ranges::views::values(bucket);
			auto it = std::ranges::lower_bound(ids,
			    idAct,
			    {},
			    &Data::MarkerId::itemId);
			Marker *act = it == ids.end() || (*it).itemId != idAct
			                ? nullptr
			                : *it.base().base().base();

			auto iNext = (i + 1) % sorted.size();
			auto idNext = sorted[iNext].index;
			it = std::ranges::lower_bound(ids,
			    idNext,
			    {},
			    &Data::MarkerId::itemId);
			Marker *next = it == ids.end() || (*it).itemId != idNext
			                 ? nullptr
			                 : *it.base().base().base();

			if (act)
				prevPos =
				    act->position.getCoord(orientation(axisIndex)) +=
				    isAggregatable ? dimOffset[i] : prevPos;

			hasConnection |=
			    Marker::connectMarkers(iNext == 0 && act != next,
			        act,
			        next,
			        isMain,
			        needPolarConnection);
		}
	}
	return hasConnection;
}

void PlotBuilder::calcAxises(const Data::DataTable &dataTable)
{
	const auto &xrange =
	    plot->getOptions()->getHorizontalAxis().range;
	const auto &yrange = plot->getOptions()->getVerticalAxis().range;

	auto markerIt = plot->markers.begin();
	while (markerIt != plot->markers.end()
	       && !static_cast<bool>(markerIt->enabled))
		++markerIt;

	if (markerIt == plot->markers.end()) {
		stats.setIfRange(AxisId::x, xrange.getRange({0.0, 0.0}));
		stats.setIfRange(AxisId::y, xrange.getRange({0.0, 0.0}));
	}
	else {
		auto boundRect = markerIt->toRectangle().positive();

		while (++markerIt != plot->markers.end()) {
			if (!markerIt->enabled) continue;
			boundRect = boundRect.boundary(markerIt->toRectangle());
		}

		plot->getOptions()->setAutoRange(
		    !std::signbit(boundRect.hSize().min),
		    !std::signbit(boundRect.vSize().min));

		boundRect.setHSize(xrange.getRange(boundRect.hSize()));
		boundRect.setVSize(yrange.getRange(boundRect.vSize()));

		for (auto &marker : plot->markers) {
			if (!boundRect.positive().intersects(
			        marker.toRectangle().positive()))
				marker.enabled = false;

			auto rect = marker.toRectangle();
			auto newRect = boundRect.normalize(rect);
			marker.fromRectangle(newRect);
		}

		stats.setIfRange(AxisId::x,
		    {boundRect.left(), boundRect.right()});
		stats.setIfRange(AxisId::y,
		    {boundRect.bottom(), boundRect.top()});
	}

	for (const AxisId &ch : {AxisId::x, AxisId::y})
		calcAxis(dataTable, ch);
}

void PlotBuilder::calcLegendAndLabel(const Data::DataTable &dataTable)
{
	if (auto &&legend = plot->getOptions()->legend.get()) {
		auto type{*legend};
		const auto &scale =
		    plot->getOptions()->getChannels().at(type);

		auto &calcLegend = plot->axises.create(type);
		auto isAutoTitle = scale.title.isAuto();
		if (scale.title) calcLegend.title = *scale.title;

		if (auto &&meas = scale.measure()) {
			if (plot->getOptions()->isMeasure(+type)) {
				if (isAutoTitle)
					calcLegend.title = dataCube.getName(*meas);
				calcLegend.measure = {std::get<0>(stats.at(type)),
				    meas->getColIndex(),
				    dataTable.getUnit(meas->getColIndex()),
				    {1}};
			}
		}
		else if (!scale.isEmpty()) {
			const auto &indices = std::get<1>(stats.at(type));
			auto merge =
			    type == LegendId::size
			    || (type == LegendId::lightness
			        && plot->getOptions()->dimLabelIndex(+type) == 0);
			for (std::uint32_t i{}, count{}; i < indices.size(); ++i)
				if (const auto &sliceIndex = indices[i]) {
					auto rangeId = static_cast<double>(i);
					std::optional<ColorBase> color;
					if (type == LegendId::color)
						color = ColorBase(i, 0.5);
					else if (type == LegendId::lightness) {
						rangeId = stats.lightness.rescale(rangeId);
						color = ColorBase(0U, rangeId);
					}

					if (calcLegend.dimension.add(*sliceIndex,
					        {rangeId, rangeId},
					        count,
					        color,
					        true,
					        merge))
						++count;
				}

			if (auto &&series = plot->getOptions()->labelSeries(type);
			    series && isAutoTitle && calcLegend.dimension.empty())
				calcLegend.title = series.value().getColIndex();
		}
	}

	if (auto &&meas = plot->getOptions()
	                      ->getChannels()
	                      .at(ChannelId::label)
	                      .measure())
		plot->axises.label = {
		    ::Anim::String{
		        std::string{dataTable.getUnit(meas->getColIndex())}},
		    ::Anim::String{meas->getColIndex()}};
}

void PlotBuilder::calcAxis(const Data::DataTable &dataTable,
    AxisId type)
{
	const auto &scale = plot->getOptions()->getChannels().at(type);
	if (scale.isEmpty()) return;

	auto &axisProps =
	    plot->getOptions()->getChannels().axisPropsAt(type);

	auto &axis = plot->axises.at(type);

	auto isAutoTitle = scale.title.isAuto();
	if (scale.title) axis.title = *scale.title;

	if (plot->getOptions()->isMeasure(+type)) {
		const auto &meas = *scale.measure();
		if (isAutoTitle) axis.title = dataCube.getName(meas);

		if (type == plot->getOptions()->subAxisType()
		    && axisProps.align == Base::Align::Type::stretch)
			axis.measure = {{0, 100},
			    meas.getColIndex(),
			    "%",
			    axisProps.step.getValue()};
		else
			axis.measure = {std::get<0>(stats.at(type)),
			    meas.getColIndex(),
			    dataTable.getUnit(meas.getColIndex()),
			    axisProps.step.getValue()};
	}
	else {
		for (auto merge =
		         axisProps.sort == Sort::byLabel
		         || (plot->getOptions()->dimLabelIndex(+type) == 0
		             && (axisProps.sort == Sort::none
		                 || scale.dimensions().size() == 1));
		     const auto &marker : plot->markers) {
			if (!marker.enabled) continue;

			const auto &id =
			    type == plot->getOptions()->mainAxisType()
			        ? marker.mainId
			        : marker.subId;

			if (const auto &slice = id.label)
				axis.dimension.add(*slice,
				    marker.getSizeBy(type),
				    {},
				    {},
				    false,
				    merge);
		}
		if (auto &&series = plot->getOptions()->labelSeries(type);
		    !axis.dimension.setLabels(axisProps.step.getValue(1.0))
		    && series && isAutoTitle)
			axis.title = series.value().getColIndex();
		for (std::uint32_t pos{};
		     DimensionAxis::Item & i : axis.dimension.sortedItems())
			i.endPos = i.startPos =
			    DimensionAxis::Item::PosType{pos++};
	}
}

void PlotBuilder::addAlignment(const Buckets &buckets,
    AxisId axisIndex) const
{
	if (plot->getOptions()->isSplit(axisIndex)) return;

	auto &axisRange = plot->axises.at(axisIndex).measure.range;
	if (std::signbit(axisRange.min) || std::signbit(axisRange.max))
		return;

	const auto &axisProps =
	    plot->getOptions()->getChannels().axisPropsAt(axisIndex);

	if (axisProps.align == Base::Align::Type::none) return;

	if (axisProps.align == Base::Align::Type::center) {
		auto &&halfSize = axisRange.size() / 2.0;
		if (!Math::Floating::is_zero(halfSize))
			axisRange = {axisRange.min - halfSize,
			    axisRange.max - halfSize};
	}

	const Base::Align align{axisProps.align, {0.0, 1.0}};
	for (auto &&bucket : buckets) {
		Math::Range<> range;

		for (auto &&[marker, idx] : bucket)
			if (marker.enabled)
				range.include(marker.getSizeBy(axisIndex));

		auto &&transform = align.getAligned(range) / range;

		for (auto &&[marker, idx] : bucket)
			marker.setSizeBy(axisIndex,
			    marker.getSizeBy(axisIndex) * transform);
	}
}

void PlotBuilder::addSeparation(const Buckets &buckets,
    AxisId axisIndex,
    const std::size_t &otherBucketSize) const
{
	if (!plot->getOptions()->isSplit(axisIndex)) return;

	const auto &axisProps =
	    plot->getOptions()->getChannels().axisPropsAt(axisIndex);
	auto align = axisProps.align;

	std::vector ranges{otherBucketSize, Math::Range<>{{}, {}}};
	std::vector<bool> anyEnabled(otherBucketSize);

	for (auto &&bucket : buckets)
		for (std::size_t i{}, prIx{}; auto &&[marker, idx] : bucket) {
			if (!marker.enabled) continue;
			(i += idx.itemId - std::exchange(prIx, idx.itemId)) %=
			    ranges.size();
			ranges[i].include(marker.getSizeBy(axisIndex).size());
			anyEnabled[i] = true;
		}

	auto max = Math::Range<>{{}, {}};
	for (auto i = 0U; i < ranges.size(); ++i)
		if (anyEnabled[i]) max = max + ranges[i];

	auto splitSpace =
	    plot->getStyle().plot.getAxis(axisIndex).spacing->get(max.max,
	        plot->getStyle().calculatedSize());

	for (auto i = 1U; i < ranges.size(); ++i)
		ranges[i] = ranges[i] + ranges[i - 1].max
		          + (anyEnabled[i - 1] ? splitSpace : 0);

	for (auto &&bucket : buckets)
		for (std::size_t i{}, prIx{}; auto &&[marker, idx] : bucket) {
			(i += idx.itemId - std::exchange(prIx, idx.itemId)) %=
			    ranges.size();
			marker.setSizeBy(axisIndex,
			    Base::Align{align, ranges[i]}.getAligned(
			        marker.getSizeBy(axisIndex)));
		}
}

void PlotBuilder::normalizeSizes()
{
	if (plot->getOptions()->geometry == ShapeType::circle
	    && !plot->getOptions()->getChannels().anyAxisSet())
		return;

	if (plot->getOptions()->geometry == ShapeType::circle
	    || plot->getOptions()->geometry == ShapeType::line) {
		Math::Range<> size;

		for (auto &marker : plot->markers) {
			if (std::isnan(marker.sizeFactor)) marker.enabled = false;
			if (!marker.enabled) continue;
			size.include(marker.sizeFactor);
		}

		size = plot->getOptions()
		           ->getChannels()
		           .at(ChannelId::size)
		           .range.getRange(size);

		for (auto &marker : plot->markers)
			marker.sizeFactor = size.max == size.min
			                      ? 0
			                      : size.normalize(marker.sizeFactor);

		stats.setIfRange(LegendId::size, size);
	}
	else
		for (auto &marker : plot->markers) marker.sizeFactor = 0;
}

void PlotBuilder::normalizeColors()
{
	auto &lightness = stats.lightness;
	Math::Range<> color;

	bool wasValidMarker{};
	for (auto &marker : plot->markers) {
		if (!marker.enabled) continue;
		auto &&cbase = marker.colorBase.get();
		if (!cbase.isDiscrete()) color.include(cbase.getPos());
		lightness.include(cbase.getLightness());
		wasValidMarker = true;
	}

	if (!wasValidMarker) {
		lightness.include(0.5);
		color.include(0);
	}

	color = plot->getOptions()
	            ->getChannels()
	            .at(ChannelId::color)
	            .range.getRange(color);
	lightness = plot->getOptions()
	                ->getChannels()
	                .at(ChannelId::lightness)
	                .range.getRange(lightness);

	for (auto &marker : plot->markers) {
		auto &&cbase = marker.colorBase->value;
		cbase.setLightness(lightness.rescale(cbase.getLightness()));

		if (!cbase.isDiscrete())
			cbase.setPos(color.rescale(cbase.getPos()));
	}

	if (auto &&legend = plot->getOptions()->legend.get()) {
		switch (*legend) {
		case LegendId::color:
			stats.setIfRange(LegendId::color, color);
			break;
		case LegendId::lightness:
			stats.setIfRange(LegendId::lightness, lightness);
			break;
		default:;
		}
	}
}

}