/*
	Copyright 2006-2026 The QElectroTech Team
	This file is part of QElectroTech.
	
	QElectroTech is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 2 of the License, or
	(at your option) any later version.
	
	QElectroTech is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.
	
	You should have received a copy of the GNU General Public License
	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "terminalstripdrawer.h"

#include <QPainter>
#include <QHash>

#include <algorithm>

namespace TerminalStripDrawer {

/**
 * @brief TerminalStripDrawer::TerminalStripDrawer
 * @param strip
 * @param pattern
 */
TerminalStripDrawer::TerminalStripDrawer(QSharedPointer<AbstractTerminalStripInterface> strip,
										 QSharedPointer<TerminalStripLayoutPattern> layout) :
	m_strip { strip },
	m_pattern { layout }
{}

void TerminalStripDrawer::setStrip(QSharedPointer<AbstractTerminalStripInterface> strip)
{
	m_strip = strip;
}

namespace {

/*
 * The symbols are described in a box of 20 x 14 units centered on (0,0).
 * The current flow from the top to the bottom, like in the terminal strip.
 * drawTypeSymbol() scale this box to fit the real available area.
 */
constexpr qreal symbol_width{20};
constexpr qreal symbol_height{14};

void drawFuseSymbol(QPainter *painter)
{
	painter->drawLine(QPointF{0, -7}, QPointF{0, 7});
	painter->drawRect(QRectF{-3, -5, 6, 10});
}

void drawSectionalSymbol(QPainter *painter)
{
	painter->drawLine(QPointF{0, -7}, QPointF{0, 7});
	painter->drawLine(QPointF{-4, 2}, QPointF{4, -2});
}

void drawDiodeSymbol(QPainter *painter)
{
	const qreal t{symbol_height / 3};
	const QPointF triangle[3] { {-t, -t}, {t, -t}, {0, t} };
	painter->drawLine(QPointF{0, -7}, QPointF{0, -t});
	painter->drawPolygon(triangle, 3);
	painter->drawLine(QPointF{-t, t}, QPointF{t, t});
	painter->drawLine(QPointF{0, t}, QPointF{0, 7});
}

void drawLedSymbol(QPainter *painter)
{
	drawDiodeSymbol(painter);
	const qreal t{symbol_height / 3};
		//The two rays
	painter->drawLine(QPointF{t + 0.5, -1}, QPointF{t + 3.5, -4});
	painter->drawLine(QPointF{t + 0.5, 2}, QPointF{t + 3.5, -1});
}

void drawGroundSymbol(QPainter *painter)
{
	painter->drawLine(QPointF{0, -7}, QPointF{0, -2});
	painter->drawLine(QPointF{-5, -2}, QPointF{5, -2});
	painter->drawLine(QPointF{-3, 1}, QPointF{3, 1});
	painter->drawLine(QPointF{-1, 4}, QPointF{1, 4});
}

/**
 * @brief drawScaled
 * Call @a draw with the painter moved by @a dx and scaled by @a factor.
 * The width of the pen is kept constant.
 */
template<typename Func>
void drawScaled(QPainter *painter, qreal dx, qreal factor, Func draw)
{
	painter->save();
	painter->translate(dx, 0);
	painter->scale(factor, factor);
	auto pen_{painter->pen()};
	pen_.setWidthF(pen_.widthF() / factor);
	painter->setPen(pen_);
	draw(painter);
	painter->restore();
}

/**
 * @brief drawTypeSymbol
 * Draw the symbol of a terminal type in @a box. The symbol is scaled
 * to fit in @a box, so it never overflow on the neighbouring terminal.
 * The painter must have a pen set, the brush is ignored.
 * @param painter
 * @param box : area available for the symbol, in the painter coordinates
 * @param type : type of the terminal, a generic terminal have no symbol
 * @param led : if true a led symbol is drawn. If the terminal have
 * also a type (fuse...), the type symbol and the led are drawn side by side.
 */
void drawTypeSymbol(QPainter *painter, const QRectF &box, ElementData::TerminalType type, bool led)
{
	const bool have_type{type != ElementData::TTGeneric};
	if (!led && !have_type) {
		return;
	}

	const qreal scale_{qMin(box.width() / symbol_width, box.height() / symbol_height)};
	if (scale_ <= 0) {
		return;
	}

	painter->save();
	painter->setBrush(Qt::NoBrush);
	painter->translate(box.center());
	painter->scale(scale_, scale_);
	auto pen_{painter->pen()};
	pen_.setWidthF(pen_.widthF() / scale_);
	painter->setPen(pen_);

	auto draw_type = [type](QPainter *p)
	{
		switch (type)
		{
			case ElementData::TTFuse      : drawFuseSymbol(p); break;
			case ElementData::TTSectional : drawSectionalSymbol(p); break;
			case ElementData::TTDiode     : drawDiodeSymbol(p); break;
			case ElementData::TTGround    : drawGroundSymbol(p); break;
			default: break;
		}
	};

	if (led && have_type)
	{
			//Not enough place for two full size symbols, draw them smaller side by side
		drawScaled(painter, -5, 0.7, draw_type);
		drawScaled(painter, 2.5, 0.7, drawLedSymbol);
	}
	else if (led) {
		drawLedSymbol(painter);
	}
	else {
		draw_type(painter);
	}

	painter->restore();
}

/**
 * @brief drawConnections
 * Draw a connection above and a connection under @a terminal_rect, in the middle
 * of the rect. A connection is a short line ended by a little circle.
 * @param painter
 * @param terminal_rect
 * @param length : the total length of a connection, circle included
 */
void drawConnections(QPainter *painter, const QRectF &terminal_rect, qreal length)
{
	const qreal radius{qMin<qreal>(length / 4, 2)};
	const qreal x{terminal_rect.width() / 2};
	const qreal top{terminal_rect.top()};
	const qreal bottom{terminal_rect.top() + terminal_rect.height()};

	painter->drawLine(QPointF{x, top}, QPointF{x, top - length + radius * 2});
	painter->drawEllipse(QPointF{x, top - length + radius}, radius, radius);

	painter->drawLine(QPointF{x, bottom}, QPointF{x, bottom + length - radius * 2});
	painter->drawEllipse(QPointF{x, bottom + length - radius}, radius, radius);
}

} //End anonymous namespace

/**
 * @brief TerminalStripDrawer::paint
 * @param painter
 */
void TerminalStripDrawer::paint(QPainter *painter)
{
    if (m_strip && m_pattern)
    {
		m_united_xref_text_rect = QRectF();
            //To draw text, QPainter need a Qrect. Instead of create an instance
            //for each text, we re-use the same instance of QRect.
        QRect text_rect;
        painter->save();

		auto pen_{painter->pen()};
		pen_.setColor(Qt::black);
		pen_.setWidth(1);

		auto brush_ = painter->brush();
		brush_.setColor(Qt::white);

        painter->setFont(m_pattern->font());

        painter->setPen(pen_);
        painter->setBrush(brush_);

        if (m_preview_draw)
        {
            painter->save();
            painter->setPen(Qt::blue);
            painter->drawRect(boundingRect());
            painter->drawLine(QPointF{boundingRect().left(), boundingRect().center().y()},
                              QPointF{boundingRect().right(), boundingRect().center().y()});
            painter->restore();
        }

			//Draw header
		painter->drawRect(m_pattern->m_header_rect);

			//Draw the header text
		painter->save();

		if (m_pattern->m_header_text_orientation == Qt::Horizontal)
		{
			text_rect.setRect(0,m_pattern->m_header_rect.y(),m_pattern->m_header_rect.width(),m_pattern->m_header_rect.height());
		}
		else
		{
			painter->translate(m_pattern->m_header_rect.bottomLeft());
			painter->rotate(270);
			text_rect.setRect(0,0,m_pattern->m_header_rect.height(),m_pattern->m_header_rect.width());
		}

        const auto text_{m_strip->installation() + " " + m_strip->location() + " " + m_strip->name()};
        painter->drawText(text_rect, text_, m_pattern->headerTextOption());
		painter->restore();

            //Move painter pos to next drawing
        painter->translate(m_pattern->m_header_rect.width(),0);
        qreal x_offset{m_pattern->m_header_rect.width()};

			//Draw spacer
		painter->drawRect(m_pattern->m_spacer_rect);
			//Move painter pos to next drawing
		painter->translate(m_pattern->m_spacer_rect.width(),0);
		x_offset += m_pattern->m_spacer_rect.width();

            //Draw terminals
        const auto terminals_text_orientation{m_pattern->m_terminals_text_orientation};
        const auto terminals_text_option{m_pattern->terminalsTextOption()};
        const auto terminals_text_height{m_pattern->m_terminals_text_height};
        const auto terminals_text_y{m_pattern->m_terminals_text_y};
        QRectF terminal_rect;

		const auto xref_text_orientation{m_pattern->m_xref_text_orientation};
		const auto xref_text_option{m_pattern->xrefTextOption()};
		const auto xref_text_height{m_pattern->m_xref_text_height};
		const auto xref_text_y{m_pattern->m_xref_text_y};
		QRectF xref_rect;

		QHash<QUuid, QVector<QPointF>> bridges_anchor_points;

		m_hovered_xref = hoverTerminal{};
		int physical_index = 0;
            //Loop over physical terminals
        for (const auto &physical_t : m_strip->physicalTerminal())
        {
                //Get the good offset according to how many level have the current physical terminal
            const QVector<QSharedPointer<AbstractRealTerminalInterface>> real_terminal_vector{physical_t->realTerminals()};
            const auto real_t_count{real_terminal_vector.size()};
            const auto offset_{4 - real_t_count};

				//Loop over real terminals
			for (auto i=0 ; i<real_t_count ; ++i)
			{
				const auto index_ = offset_ + i;
				if (index_ >= 4) {
					break;
				}

                terminal_rect = m_pattern->m_terminal_rect[index_];
                    //Draw terminal rect
                painter->drawRect(terminal_rect);

					//Draw the symbol of the terminal type (fuse, ground, led...)
				if (m_pattern->m_type_symbol_height > 0 && real_terminal_vector[i])
				{
					drawTypeSymbol(painter,
								   QRectF{0, m_pattern->m_type_symbol_y,
										  terminal_rect.width(), m_pattern->m_type_symbol_height},
								   real_terminal_vector[i]->type(),
								   real_terminal_vector[i]->isLed());
				}

					//Draw the connections, above and under the terminal
				if (m_pattern->m_connection_length > 0) {
					drawConnections(painter, terminal_rect, m_pattern->m_connection_length);
				}
                    //Draw a stronger line if the current terminal have level
                    //and the current level is the first
                if (real_t_count > 1 && i == 0)
                {
                    painter->save();
                    pen_ = painter->pen();
                    pen_.setWidth(4);
                    pen_.setCapStyle(Qt::FlatCap);
                    painter->setPen(pen_);
                    const auto p1 { terminal_rect.topLeft() };
                        //We can't use terminal_rect.bottomLeft for p2 because
                        //the returned value deviate from the true value
                        //(see Qt documentation about QRect)
                    const QPointF p2 { p1.x(), p1.y() + terminal_rect.height() };
                    painter->drawLine(p1, p2);
                    painter->restore();
                }

				if(m_preview_draw)
                {
                    painter->save();
                    painter->setPen(Qt::yellow);
                    painter->drawLine(QPointF{terminal_rect.x(), terminal_rect.y() + terminal_rect.height()/2},
                                      QPointF{terminal_rect.width(), terminal_rect.y() + terminal_rect.height()/2});
                    painter->restore();
				}

                    //Draw text
                painter->save();
                text_rect.setRect(0, terminals_text_y, terminal_rect.width(), terminals_text_height);
                if (terminals_text_orientation == Qt::Vertical)
                {
                    painter->translate(text_rect.bottomLeft());
                    painter->rotate(270);
                    text_rect.setRect(0, 0, text_rect.height(), text_rect.width());
                }

                const auto shared_real_terminal{real_terminal_vector[i]};
				painter->drawText(text_rect,
								  shared_real_terminal ? shared_real_terminal->label() : QLatin1String(),
								  terminals_text_option);

				if (m_preview_draw)
				{
					painter->setPen(Qt::blue);
					painter->drawRect(text_rect);
				}

				painter->restore();

					//Draw xref
				xref_rect.setRect(0, xref_text_y, terminal_rect.width(), xref_text_height);
				painter->save();
				if (xref_text_orientation == Qt::Vertical)
				{
					painter->translate(xref_rect.bottomLeft());
					painter->rotate(270);
					xref_rect.setRect(0, 0, xref_rect.height(), xref_rect.width());
				}

				QTransform transform;
				transform.translate(x_offset, 0);

				if (xref_text_orientation == Qt::Vertical)
				{
					transform.translate(0, xref_text_y + xref_text_height);
					transform.rotate(270);
				}

				auto xref_string = shared_real_terminal->xref();

				const auto mapped_xref_text_rect = transform.mapRect(painter->boundingRect(xref_rect, xref_string, xref_text_option));
				if (m_united_xref_text_rect.isNull()) {
					m_united_xref_text_rect = mapped_xref_text_rect;
				} else {
					m_united_xref_text_rect = m_united_xref_text_rect.united(mapped_xref_text_rect);
				}

					//if mouse hover the xref text, draw it in blue to advise user the xref is clickable.
				if (!m_mouse_hover_pos.isNull() && mapped_xref_text_rect.contains(m_mouse_hover_pos)) {
					painter->setPen(Qt::blue);
					m_hovered_xref.physical = physical_index;
					m_hovered_xref.real = i;
				}

				painter->drawText(xref_rect, xref_string, xref_text_option);

				if (m_preview_draw)
				{
					painter->setPen(Qt::blue);
					painter->drawRect(xref_rect);
				}
				painter->restore();

                    //Add bridge anchor
                if (shared_real_terminal->isBridged())
                {
                    painter->save();
                    if (QScopedPointer<AbstractBridgeInterface> bridge_ {
                        shared_real_terminal->bridge() })
                    {
                        const auto x_anchor{terminal_rect.width()/2};
                        const auto y_anchor {m_pattern->m_bridge_point_y_offset[index_]};
                        const auto radius_anchor{m_pattern->m_bridge_point_d/2};

						painter->setBrush(Qt::SolidPattern);
						painter->drawEllipse(QPointF(x_anchor, y_anchor),
											 radius_anchor, radius_anchor);

						auto anchor_points{bridges_anchor_points.value(bridge_->uuid())};
						anchor_points.append(QPointF(x_offset + x_anchor, y_anchor));
						bridges_anchor_points.insert(bridge_->uuid(), anchor_points);
					}
					painter->restore();
				}

                    //Move painter pos to next drawing
                painter->translate(terminal_rect.width(),0);
                x_offset += terminal_rect.width();
            }
			physical_index++;
        }
        painter->restore();

			//Draw the bridges
		for (const auto &points_ : std::as_const(bridges_anchor_points))
		{
			painter->save();
			auto pen_{painter->pen()};
			pen_.setWidth(2);
			painter->setPen(pen_);
			painter->drawPolyline(QPolygonF(points_));
			painter->restore();
		}
	}
}

QRectF TerminalStripDrawer::boundingRect() const
{
	QRectF rect_{0, 0, width(), height()};

		//The connections are drawn above and under the terminals
	if (m_pattern && m_pattern->m_connection_length > 0)
	{
		const auto length_{m_pattern->m_connection_length};
		qreal top_{0};
		for (const auto &terminal_rect : std::as_const(m_pattern->m_terminal_rect)) {
			top_ = std::min(top_, terminal_rect.top() - length_);
		}
		rect_.setBottom(rect_.bottom() + length_);
		rect_.setTop(top_);
	}

	return rect_;
}

void TerminalStripDrawer::setLayout(QSharedPointer<TerminalStripLayoutPattern> layout)
{
	m_pattern = layout;
}

bool TerminalStripDrawer::haveLayout() const
{
	return !m_pattern.isNull();
}

void TerminalStripDrawer::setPreviewDraw(bool draw) {
	m_preview_draw = draw;
}

void TerminalStripDrawer::setMouseHoverPos(const QPointF &pos)
{
	m_last_mouse_pos_in_xrefs_rect = m_united_xref_text_rect.contains(m_mouse_hover_pos);
	m_mouse_hover_pos = pos;
}

/**
 * @brief TerminalStripDrawer::mouseHoverXref
 * @return True if the mouse position (given through the function setMouseHoverPos)
 * hover the rect of a xref.
 */
bool TerminalStripDrawer::mouseHoverXref() const {
	return m_united_xref_text_rect.contains(m_mouse_hover_pos);
}

bool TerminalStripDrawer::needUpdate()
{
	if (mouseHoverXref()) {
		return true;
	} else if (m_last_mouse_pos_in_xrefs_rect) {
		return true;
	}
	return false;
}

/**
 * @brief TerminalStripDrawer::hoveredXref
 * @return the current terminal hovered by the mouse
 * in the xref bounding rectangle
 */
hoverTerminal TerminalStripDrawer::hoveredXref() const
{
	return m_hovered_xref;
}

qreal TerminalStripDrawer::height() const
{
	if (m_pattern)
	{
		auto height_{m_pattern->m_header_rect.y() + m_pattern->m_header_rect.height()};

		height_ = std::max(height_, m_pattern->m_spacer_rect.y() + m_pattern->m_spacer_rect.height());

		for (const auto &rect : m_pattern->m_terminal_rect) {
			height_ = std::max(height_, rect.y() + rect.height());
		}

		return height_;
	}

	return 0;
}

qreal TerminalStripDrawer::width() const
{
    if (m_pattern)
    {
        qreal width_{m_pattern->m_header_rect.width() + m_pattern->m_spacer_rect.width()};

		if (m_strip)
		{
			//Loop over physical terminals
			for (const auto &physical_t : m_strip->physicalTerminal())
			{
				//Get the good offset according to how many level have the current physical terminal
				const QVector<QSharedPointer<AbstractRealTerminalInterface>> real_terminal_vector{physical_t->realTerminals()};
				const auto real_t_count{real_terminal_vector.size()};
				const auto offset_{4 - real_t_count};

				//Loop over real terminals
				for (auto i=0 ; i<real_t_count ; ++i)
				{
					const auto index_ = offset_ + i;
					if (index_ >= 4) {
						break;
					}

					width_ += m_pattern->m_terminal_rect[index_].width();
				}
			}
		}

		return width_;
	}

	return 0;
}

} //End namespace TerminalStripDrawer