/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.

For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "ui/grouped_layout.h"

namespace Ui {
namespace {

int Round(float64 value) {
	return int(std::round(value));
}

class Layouter {
public:
	Layouter(
		const std::vector<QSize> &sizes,
		int maxWidth,
		int minWidth,
		int spacing);

	std::vector<GroupMediaLayout> layout() const;

private:
	static std::vector<float64> CountRatios(const std::vector<QSize> &sizes);
	static std::string CountProportions(const std::vector<float64> &ratios);

	std::vector<GroupMediaLayout> layoutTwo() const;
	std::vector<GroupMediaLayout> layoutThree() const;
	std::vector<GroupMediaLayout> layoutFour() const;

	std::vector<GroupMediaLayout> layoutOne() const;
	std::vector<GroupMediaLayout> layoutTwoTopBottom() const;
	std::vector<GroupMediaLayout> layoutTwoLeftRightEqual() const;
	std::vector<GroupMediaLayout> layoutTwoLeftRight() const;
	std::vector<GroupMediaLayout> layoutThreeLeftAndOther() const;
	std::vector<GroupMediaLayout> layoutThreeTopAndOther() const;
	std::vector<GroupMediaLayout> layoutFourLeftAndOther() const;
	std::vector<GroupMediaLayout> layoutFourTopAndOther() const;

	const std::vector<QSize> &_sizes;
	const std::vector<float64> _ratios;
	const std::string _proportions;
	const int _count = 0;
	const int _maxWidth = 0;
	const int _maxHeight = 0;
	const int _minWidth = 0;
	const int _spacing = 0;
	const float64 _averageRatio = 1.;
	const float64 _maxSizeRatio = 1.;

};

class ComplexLayouter {
public:
	ComplexLayouter(
		const std::vector<float64> &ratios,
		float64 averageRatio,
		int maxWidth,
		int minWidth,
		int spacing);

	std::vector<GroupMediaLayout> layout() const;

private:
	struct Attempt {
		std::vector<int> lineCounts;
		std::vector<float64> heights;
	};

	static std::vector<float64> CropRatios(
		const std::vector<float64> &ratios,
		float64 averageRatio);

	const std::vector<float64> _ratios;
	const int _count = 0;
	const int _maxWidth = 0;
	const int _maxHeight = 0;
	const int _minWidth = 0;
	const int _spacing = 0;
	const float64 _averageRatio = 1.;

};

Layouter::Layouter(
	const std::vector<QSize> &sizes,
	int maxWidth,
	int minWidth,
	int spacing)
: _sizes(sizes)
, _ratios(CountRatios(_sizes))
, _proportions(CountProportions(_ratios))
, _count(int(_ratios.size()))
// All apps currently use square max size first.
// In complex case they use maxWidth * 4 / 3 as maxHeight.
, _maxWidth(maxWidth)
, _maxHeight(maxWidth)
, _minWidth(minWidth)
, _spacing(spacing)
, _averageRatio(ranges::accumulate(_ratios, 1.) / _count)
, _maxSizeRatio(_maxWidth / float64(_maxHeight)) {
}

std::vector<float64> Layouter::CountRatios(const std::vector<QSize> &sizes) {
	return ranges::views::all(
		sizes
	) | ranges::views::transform([](const QSize &size) {
		return size.width() / float64(size.height());
	}) | ranges::to_vector;
}

std::string Layouter::CountProportions(const std::vector<float64> &ratios) {
	return ranges::views::all(
		ratios
	) | ranges::views::transform([](float64 ratio) {
		return (ratio > 1.2) ? 'w' : (ratio < 0.8) ? 'n' : 'q';
	}) | ranges::to<std::string>();
}

std::vector<GroupMediaLayout> Layouter::layout() const {
	if (!_count) {
		return {};
	} else if (_count == 1) {
		return layoutOne();
	}

	using namespace rpl::mappers;
	if (_count >= 5 || ranges::find_if(_ratios, _1 > 2) != _ratios.end()) {
		return ComplexLayouter(
			_ratios,
			_averageRatio,
			_maxWidth,
			_minWidth,
			_spacing).layout();
	}

	if (_count == 2) {
		return layoutTwo();
	} else if (_count == 3) {
		return layoutThree();
	}
	return layoutFour();
}

std::vector<GroupMediaLayout> Layouter::layoutTwo() const {
	Expects(_count == 2);

	if ((_proportions == "ww")
		&& (_averageRatio > 1.4 * _maxSizeRatio)
		&& (_ratios[1] - _ratios[0] < 0.2)) {
		return layoutTwoTopBottom();
	} else if (_proportions == "ww" || _proportions == "qq") {
		return layoutTwoLeftRightEqual();
	}
	return layoutTwoLeftRight();
}

std::vector<GroupMediaLayout> Layouter::layoutThree() const {
	Expects(_count == 3);

	auto result = std::vector<GroupMediaLayout>(_count);
	if (_proportions[0] == 'n') {
		return layoutThreeLeftAndOther();
	}
	return layoutThreeTopAndOther();
}

std::vector<GroupMediaLayout> Layouter::layoutFour() const {
	Expects(_count == 4);

	auto result = std::vector<GroupMediaLayout>(_count);
	if (_proportions[0] == 'w') {
		return layoutFourTopAndOther();
	}
	return layoutFourLeftAndOther();
}

std::vector<GroupMediaLayout> Layouter::layoutOne() const {
	Expects(_count == 1);

	const auto width = _maxWidth;
	const auto height = (_sizes[0].height() * width) / _sizes[0].width();

	return {
		{
			QRect(0, 0, width, height),
			RectPart::Left | RectPart::Top | RectPart::Right | RectPart::Bottom
		},
	};
}

std::vector<GroupMediaLayout> Layouter::layoutTwoTopBottom() const {
	Expects(_count == 2);

	const auto width = _maxWidth;
	const auto height = Round(std::min(
		width / _ratios[0],
		std::min(
			width / _ratios[1],
			(_maxHeight - _spacing) / 2.)));

	return {
		{
			QRect(0, 0, width, height),
			RectPart::Left | RectPart::Top | RectPart::Right
		},
		{
			QRect(0, height + _spacing, width, height),
			RectPart::Left | RectPart::Bottom | RectPart::Right
		},
	};
}

std::vector<GroupMediaLayout> Layouter::layoutTwoLeftRightEqual() const {
	Expects(_count == 2);

	const auto width = (_maxWidth - _spacing) / 2;
	const auto height = Round(std::min(
		width / _ratios[0],
		std::min(width / _ratios[1], _maxHeight * 1.)));

	return {
		{
			QRect(0, 0, width, height),
			RectPart::Top | RectPart::Left | RectPart::Bottom
		},
		{
			QRect(width + _spacing, 0, width, height),
			RectPart::Top | RectPart::Right | RectPart::Bottom
		},
	};
}

std::vector<GroupMediaLayout> Layouter::layoutTwoLeftRight() const {
	Expects(_count == 2);

	const auto minimalWidth = Round(_minWidth * 1.5);
	const auto secondWidth = std::min(
		Round(std::max(
			0.4 * (_maxWidth - _spacing),
			(_maxWidth - _spacing) / _ratios[0]
				/ (1. / _ratios[0] + 1. / _ratios[1]))),
		_maxWidth - _spacing - minimalWidth);
	const auto firstWidth = _maxWidth
		- secondWidth
		- _spacing;
	const auto height = std::min(
		_maxHeight,
		Round(std::min(
			firstWidth / _ratios[0],
			secondWidth / _ratios[1])));

	return {
		{
			QRect(0, 0, firstWidth, height),
			RectPart::Top | RectPart::Left | RectPart::Bottom
		},
		{
			QRect(firstWidth + _spacing, 0, secondWidth, height),
			RectPart::Top | RectPart::Right | RectPart::Bottom
		},
	};
}

std::vector<GroupMediaLayout> Layouter::layoutThreeLeftAndOther() const {
	Expects(_count == 3);

	const auto firstHeight = _maxHeight;
	const auto thirdHeight = Round(std::min(
		(_maxHeight - _spacing) / 2.,
		(_ratios[1] * (_maxWidth - _spacing)
			/ (_ratios[2] + _ratios[1]))));
	const auto secondHeight = firstHeight
		- thirdHeight
		- _spacing;
	const auto rightWidth = std::max(
		_minWidth,
		Round(std::min(
			(_maxWidth - _spacing) / 2.,
			std::min(
				thirdHeight * _ratios[2],
				secondHeight * _ratios[1]))));
	const auto leftWidth = std::min(
		Round(firstHeight * _ratios[0]),
		_maxWidth - _spacing - rightWidth);

	return {
		{
			QRect(0, 0, leftWidth, firstHeight),
			RectPart::Top | RectPart::Left | RectPart::Bottom
		},
		{
			QRect(leftWidth + _spacing, 0, rightWidth, secondHeight),
			RectPart::Top | RectPart::Right
		},
		{
			QRect(leftWidth + _spacing, secondHeight + _spacing, rightWidth, thirdHeight),
			RectPart::Bottom | RectPart::Right
		},
	};
}

std::vector<GroupMediaLayout> Layouter::layoutThreeTopAndOther() const {
	Expects(_count == 3);

	const auto firstWidth = _maxWidth;
	const auto firstHeight = Round(std::min(
		firstWidth / _ratios[0],
		(_maxHeight - _spacing) * 0.66));
	const auto secondWidth = (_maxWidth - _spacing) / 2;
	const auto secondHeight = std::min(
		_maxHeight - firstHeight - _spacing,
		Round(std::min(
			secondWidth / _ratios[1],
			secondWidth / _ratios[2])));
	const auto thirdWidth = firstWidth - secondWidth - _spacing;

	return {
		{
			QRect(0, 0, firstWidth, firstHeight),
			RectPart::Left | RectPart::Top | RectPart::Right
		},
		{
			QRect(0, firstHeight + _spacing, secondWidth, secondHeight),
			RectPart::Bottom | RectPart::Left
		},
		{
			QRect(secondWidth + _spacing, firstHeight + _spacing, thirdWidth, secondHeight),
			RectPart::Bottom | RectPart::Right
		},
	};
}

std::vector<GroupMediaLayout> Layouter::layoutFourTopAndOther() const {
	Expects(_count == 4);

	const auto w = _maxWidth;
	const auto h0 = Round(std::min(
		w / _ratios[0],
		(_maxHeight - _spacing) * 0.66));
	const auto h = Round(
		(_maxWidth - 2 * _spacing)
			/ (_ratios[1] + _ratios[2] + _ratios[3]));
	const auto w0 = std::max(
		_minWidth,
		Round(std::min(
			(_maxWidth - 2 * _spacing) * 0.4,
			h * _ratios[1])));
	const auto w2 = Round(std::max(
		std::max(
			_minWidth * 1.,
			(_maxWidth - 2 * _spacing) * 0.33),
		h * _ratios[3]));
	const auto w1 = w - w0 - w2 - 2 * _spacing;
	const auto h1 = std::min(
		_maxHeight - h0 - _spacing,
		h);

	return {
		{
			QRect(0, 0, w, h0),
			RectPart::Left | RectPart::Top | RectPart::Right
		},
		{
			QRect(0, h0 + _spacing, w0, h1),
			RectPart::Bottom | RectPart::Left
		},
		{
			QRect(w0 + _spacing, h0 + _spacing, w1, h1),
			RectPart::Bottom,
		},
		{
			QRect(w0 + _spacing + w1 + _spacing, h0 + _spacing, w2, h1),
			RectPart::Right | RectPart::Bottom
		},
	};
}

std::vector<GroupMediaLayout> Layouter::layoutFourLeftAndOther() const {
	Expects(_count == 4);

	const auto h = _maxHeight;
	const auto w0 = Round(std::min(
		h * _ratios[0],
		(_maxWidth - _spacing) * 0.6));

	const auto w = Round(
		(_maxHeight - 2 * _spacing)
			/ (1. / _ratios[1] + 1. / _ratios[2] + 1. / _ratios[3])
	);
	const auto h0 = Round(w / _ratios[1]);
	const auto h1 = Round(w / _ratios[2]);
	const auto h2 = h - h0 - h1 - 2 * _spacing;
	const auto w1 = std::max(
		_minWidth,
		std::min(_maxWidth - w0 - _spacing, w));

	return {
		{
			QRect(0, 0, w0, h),
			RectPart::Top | RectPart::Left | RectPart::Bottom
		},
		{
			QRect(w0 + _spacing, 0, w1, h0),
			RectPart::Top | RectPart::Right
		},
		{
			QRect(w0 + _spacing, h0 + _spacing, w1, h1),
			RectPart::Right
		},
		{
			QRect(w0 + _spacing, h0 + h1 + 2 * _spacing, w1, h2),
			RectPart::Bottom | RectPart::Right
		},
	};
}

ComplexLayouter::ComplexLayouter(
	const std::vector<float64> &ratios,
	float64 averageRatio,
	int maxWidth,
	int minWidth,
	int spacing)
: _ratios(CropRatios(ratios, averageRatio))
, _count(int(_ratios.size()))
// All apps currently use square max size first.
// In complex case they use maxWidth * 4 / 3 as maxHeight.
, _maxWidth(maxWidth)
, _maxHeight(maxWidth * 4 / 3)
, _minWidth(minWidth)
, _spacing(spacing)
, _averageRatio(averageRatio) {
}

std::vector<float64> ComplexLayouter::CropRatios(
		const std::vector<float64> &ratios,
		float64 averageRatio) {
	return ranges::views::all(
		ratios
	) | ranges::views::transform([&](float64 ratio) {
		constexpr auto kMaxRatio = 2.75;
		constexpr auto kMinRatio = 0.6667;
		return (averageRatio > 1.1)
			? std::clamp(ratio, 1., kMaxRatio)
			: std::clamp(ratio, kMinRatio, 1.);
	}) | ranges::to_vector;
}

std::vector<GroupMediaLayout> ComplexLayouter::layout() const {
	Expects(_count > 1);

	auto result = std::vector<GroupMediaLayout>(_count);

	auto attempts = std::vector<Attempt>();
	const auto multiHeight = [&](int offset, int count) {
		const auto ratios = gsl::make_span(_ratios).subspan(offset, count);
		const auto sum = ranges::accumulate(ratios, 0.);
		return (_maxWidth - (count - 1) * _spacing) / sum;
	};
	const auto pushAttempt = [&](std::vector<int> lineCounts) {
		auto heights = std::vector<float64>();
		heights.reserve(lineCounts.size());
		auto offset = 0;
		for (auto count : lineCounts) {
			heights.push_back(multiHeight(offset, count));
			offset += count;
		}
		attempts.push_back({ std::move(lineCounts), std::move(heights) });
	};

	for (auto first = 1; first != _count; ++first) {
		const auto second = _count - first;
		if (first > 3 || second > 3) {
			continue;
		}
		pushAttempt({ first, second });
	}
	for (auto first = 1; first != _count - 1; ++first) {
		for (auto second = 1; second != _count - first; ++second) {
			const auto third = _count - first - second;
			if ((first > 3)
				|| (second > ((_averageRatio < 0.85) ? 4 : 3))
				|| (third > 3)) {
				continue;
			}
			pushAttempt({ first, second, third });
		}
	}
	for (auto first = 1; first != _count - 1; ++first) {
		for (auto second = 1; second != _count - first; ++second) {
			for (auto third = 1; third != _count - first - second; ++third) {
				const auto fourth = _count - first - second - third;
				if (first > 3 || second > 3 || third > 3 || fourth > 3) {
					continue;
				}
				pushAttempt({ first, second, third, fourth });
			}
		}
	}

	auto optimalAttempt = (const Attempt*)nullptr;
	auto optimalDiff = 0.;
	for (const auto &attempt : attempts) {
		const auto &heights = attempt.heights;
		const auto &counts = attempt.lineCounts;
		const auto lineCount = int(counts.size());
		const auto totalHeight = ranges::accumulate(heights, 0.)
			+ _spacing * (lineCount - 1);
		const auto minLineHeight = ranges::min(heights);
		const auto maxLineHeight = ranges::max(heights);
		const auto bad1 = (minLineHeight < _minWidth) ? 1.5 : 1.;
		const auto bad2 = [&] {
			for (auto line = 1; line != lineCount; ++line) {
				if (counts[line - 1] > counts[line]) {
					return 1.5;
				}
			}
			return 1.;
		}();
		const auto diff = std::abs(totalHeight - _maxHeight) * bad1 * bad2;
		if (!optimalAttempt || diff < optimalDiff) {
			optimalAttempt = &attempt;
			optimalDiff = diff;
		}
	}
	Assert(optimalAttempt != nullptr);

	const auto &optimalCounts = optimalAttempt->lineCounts;
	const auto &optimalHeights = optimalAttempt->heights;
	const auto rowCount = int(optimalCounts.size());

	auto index = 0;
	auto y = 0.;
	for (auto row = 0; row != rowCount; ++row) {
		const auto colCount = optimalCounts[row];
		const auto lineHeight = optimalHeights[row];
		const auto height = Round(lineHeight);

		auto x = 0;
		for (auto col = 0; col != colCount; ++col) {
			const auto sides = RectPart::None
				| (row == 0 ? RectPart::Top : RectPart::None)
				| (row == rowCount - 1 ? RectPart::Bottom : RectPart::None)
				| (col == 0 ? RectPart::Left : RectPart::None)
				| (col == colCount - 1 ? RectPart::Right : RectPart::None);

			const auto ratio = _ratios[index];
			const auto width = (col == colCount - 1)
				? (_maxWidth - x)
				: Round(ratio * lineHeight);
			result[index] = {
				QRect(x, y, width, height),
				sides
			};

			x += width + _spacing;
			++index;
		}
		y += height + _spacing;
	}

	return result;
}

} // namespace

std::vector<GroupMediaLayout> LayoutMediaGroup(
		const std::vector<QSize> &sizes,
		int maxWidth,
		int minWidth,
		int spacing) {
	return Layouter(sizes, maxWidth, minWidth, spacing).layout();
}

RectParts GetCornersFromSides(RectParts sides) {
	const auto convert = [&](
			RectPart side1,
			RectPart side2,
			RectPart corner) {
		return ((sides & side1) && (sides & side2))
			? corner
			: RectPart::None;
	};
	return RectPart::None
		| convert(RectPart::Top, RectPart::Left, RectPart::TopLeft)
		| convert(RectPart::Top, RectPart::Right, RectPart::TopRight)
		| convert(RectPart::Bottom, RectPart::Left, RectPart::BottomLeft)
		| convert(RectPart::Bottom, RectPart::Right, RectPart::BottomRight);
}

QSize GetImageScaleSizeForGeometry(QSize original, QSize geometry) {
	const auto width = geometry.width();
	const auto height = geometry.height();
	auto tw = original.width();
	auto th = original.height();
	if (tw * height > th * width) {
		if (th > height || tw * height < 2 * th * width) {
			tw = (height * tw) / th;
			th = height;
		} else if (tw < width) {
			th = (width * th) / tw;
			tw = width;
		}
	} else {
		if (tw > width || th * width < 2 * tw * height) {
			th = (width * th) / tw;
			tw = width;
		} else if (tw > 0 && th < height) {
			tw = (height * tw) / th;
			th = height;
		}
	}
	if (tw < 1) tw = 1;
	if (th < 1) th = 1;
	return { tw, th };
}

} // namespace Ui