#include "Line.h"

Line::Line() : Branch() {}
Line::~Line() {}
bool Line::Contains(wxPoint2DDouble position) const
{
    if(PointToLineDistance(position) < 5.0) {
	    return true;
	}
    return false;
}

void Line::Draw(wxPoint2DDouble translation, double scale) const
{
    std::vector<wxPoint2DDouble> pointList = m_pointList;
    if(!m_inserted && pointList.size() > 0) {
	    wxPoint2DDouble secondPoint = m_position;
	    if(pointList.size() > 2) {
		    secondPoint = pointList[2];
		}
	    pointList[1] = GetSwitchPoint(m_parentList[0], pointList[0], secondPoint);
	    pointList.push_back(m_position);
	}

    // Line selected (Layer 1).
    if(m_selected) {
	    glLineWidth(1.5 + m_borderSize * 2.0);
	    glColor4d(0.0, 0.5, 1.0, 0.5);
	    DrawLine(pointList);

	    // Draw nodes selection.
	    if(pointList.size() > 0) {
		    DrawCircle(pointList[0], 5.0 + m_borderSize / scale, 10, GL_POLYGON);
		    if(m_inserted) {
			    DrawCircle(pointList[pointList.size() - 1], 5.0 + m_borderSize / scale, 10, GL_POLYGON);
			}
		}
	}

    // Draw line (Layer 2)
    glLineWidth(1.5);
    glColor4d(0.2, 0.2, 0.2, 1.0);
    DrawLine(pointList);
	
	DrawSwitches();

    // Draw nodes.
    if(pointList.size() > 0) {
	    glColor4d(0.2, 0.2, 0.2, 1.0);
	    DrawCircle(pointList[0], 5.0, 10, GL_POLYGON);
	    if(m_inserted) {
		    DrawCircle(pointList[pointList.size() - 1], 5.0, 10, GL_POLYGON);
		}
	}

    // Draw pickboxes (Layer 3).
    if(m_showPickbox) {
	    glPushMatrix();
	    glLoadIdentity();

	    for(int i = 2; i < (int)m_pointList.size() - 2; i++) {
		    DrawPickbox(WorldToScreen(m_pointList[i], translation, scale));
		}

	    glPopMatrix();
	}
}

void Line::Move(wxPoint2DDouble position)
{
    if(!m_parentList[0]) {
	    m_pointList[0] = m_movePts[0] + position - m_moveStartPt;
	    UpdateSwitchesPosition();
	}
    if(!m_parentList[1]) {
	    m_pointList[m_pointList.size() - 1] = m_movePts[m_pointList.size() - 1] + position - m_moveStartPt;
	    UpdateSwitchesPosition();
	}

    if(!m_parentList[0] && !m_parentList[1]) {
	    for(int i = 2; i < (int)m_pointList.size() - 2; i++) {
		    m_pointList[i] = m_movePts[i] + position - m_moveStartPt;
		}
	}
}

bool Line::AddParent(Element* parent, wxPoint2DDouble position)
{
    if(parent) {
	    // First bus.
	    if(m_parentList.size() == 0) {
		    m_position = position;
		    m_parentList.push_back(parent);
		    wxPoint2DDouble parentPt = parent->RotateAtPosition(
		        position, -parent->GetAngle());        // Rotate click to horizontal position.
		    parentPt.m_y = parent->GetPosition().m_y;  // Centralize on bus.
		    parentPt = parent->RotateAtPosition(parentPt, parent->GetAngle());  // Rotate back.
		    m_pointList.push_back(parentPt);                                    // First point
		    m_pointList.push_back(GetSwitchPoint(parent, parentPt, m_position));
			
			wxRect2DDouble genRect(0,0,0,0);
			m_switchRect.push_back(genRect);
			UpdateSwitches();
			
		    return false;
		}
	    // Second bus.
	    else if(parent != m_parentList[0])
		{
		    m_parentList.push_back(parent);
		    wxPoint2DDouble parentPt = parent->RotateAtPosition(
		        position, -parent->GetAngle());        // Rotate click to horizontal position.
		    parentPt.m_y = parent->GetPosition().m_y;  // Centralize on bus.
		    parentPt = parent->RotateAtPosition(parentPt, parent->GetAngle());  // Rotate back.

		    // Set first switch point.
		    wxPoint2DDouble secondPoint = parentPt;
		    if(m_pointList.size() > 2) {
			    secondPoint = m_pointList[2];
			}
		    m_pointList[1] = GetSwitchPoint(m_parentList[0], m_pointList[0], secondPoint);

		    // Set the second switch point.
		    m_pointList.push_back(GetSwitchPoint(parent, parentPt, m_pointList[m_pointList.size() - 1]));

		    m_pointList.push_back(parentPt);  // Last point.
			
			wxRect2DDouble genRect(0,0,0,0);
			m_switchRect.push_back(genRect);
			UpdateSwitches();
			
		    m_inserted = true;
		    return true;
		}
	}
    return false;
}
bool Line::Intersects(wxRect2DDouble rect) const
{
    for(auto it = m_pointList.begin(); it != m_pointList.end(); ++it) {
	    if(rect.Contains(*it)) return true;
	}
    return false;
}
void Line::MovePickbox(wxPoint2DDouble position)
{
    if(m_activePickboxID == ID_PB_NONE) return;

    for(int i = 2; i < (int)m_pointList.size() - 2; i++) {
	    if(m_activePickboxID == i) {
		    m_pointList[i] = m_movePts[i] + position - m_moveStartPt;
		    UpdateSwitchesPosition();
		}
	}
}
bool Line::PickboxContains(wxPoint2DDouble position)
{
    for(int i = 2; i < (int)m_pointList.size() - 2; i++) {
	    wxRect2DDouble rect(m_pointList[i].m_x - 5.0, m_pointList[i].m_y - 5.0, 10.0, 10.0);
	    if(rect.Contains(position)) {
		    m_activePickboxID = i;
		    return true;
		}
	}
    return false;
}

void Line::AddPoint(wxPoint2DDouble point)
{
    if(m_parentList.size() != 0) {
	    m_pointList.push_back(point);
	}
}

void Line::StartMove(wxPoint2DDouble position)
{
    m_moveStartPt = position;
    m_movePts = m_pointList;
}

void Line::MoveNode(Element* parent, wxPoint2DDouble position)
{
    if(parent) {
	    // First bus.
	    if(parent == m_parentList[0]) {
		    m_pointList[0] = m_movePts[0] + position - m_moveStartPt;
		}
	    // Second bus.
	    else if(parent == m_parentList[1])
		{
		    m_pointList[m_pointList.size() - 1] = m_movePts[m_pointList.size() - 1] + position - m_moveStartPt;
		}

	    // If the line is selected, move all the points, except the switches and buses points.
	    if(m_selected) {
		    for(int i = 2; i < (int)m_pointList.size() - 2; i++) {
			    m_pointList[i] = m_movePts[i] + position - m_moveStartPt;
			}
		}
	}
    else
	{
	    if(m_activeNodeID == 1) {
		    m_pointList[0] = m_movePts[0] + position - m_moveStartPt;
		    m_parentList[0] = NULL;
			m_online = false;
		}
	    else if(m_activeNodeID == 2)
		{
		    m_pointList[m_pointList.size() - 1] = m_movePts[m_pointList.size() - 1] + position - m_moveStartPt;
		    m_parentList[1] = NULL;
			m_online = false;
		}
	}

    // Recalculate switches positions
    UpdateSwitchesPosition();
}

double Line::PointToLineDistance(wxPoint2DDouble point, int* segmentNumber) const
{
    //[Ref] http://geomalgorithms.com/a02-_lines.html
    double distance = 100.0;  // Big initial distance.
    wxPoint2DDouble p0 = point;

    for(int i = 1; i < (int)m_pointList.size() - 2; i++) {
	    double d = 0.0;

	    wxPoint2DDouble p1 = m_pointList[i];
	    wxPoint2DDouble p2 = m_pointList[i + 1];

	    wxPoint2DDouble v = p2 - p1;
	    wxPoint2DDouble w = p0 - p1;

	    double c1 = w.m_x * v.m_x + w.m_y * v.m_y;
	    double c2 = v.m_x * v.m_x + v.m_y * v.m_y;

	    if(c1 <= 0.0) {
		    d = std::sqrt(std::pow(p0.m_y - p1.m_y, 2) + std::pow(p0.m_x - p1.m_x, 2));
		}
	    else if(c2 <= c1)
		{
		    d = std::sqrt(std::pow(p0.m_y - p2.m_y, 2) + std::pow(p0.m_x - p2.m_x, 2));
		}
	    else
		{
		    d = std::abs((p2.m_y - p1.m_y) * p0.m_x - (p2.m_x - p1.m_x) * p0.m_y + p2.m_x * p1.m_y -
		                 p2.m_y * p1.m_x) /
		        std::sqrt(std::pow(p2.m_y - p1.m_y, 2) + std::pow(p2.m_x - p1.m_x, 2));
		}
	    if(d < distance) {
		    distance = d;
		    if(segmentNumber) *segmentNumber = i;
		}
	}

    return distance;
}

bool Line::GetContextMenu(wxMenu& menu)
{
    menu.Append(ID_EDIT_LINE, _("Edit line"));
    if(m_activePickboxID == ID_PB_NONE) {
	    menu.Append(ID_LINE_ADD_NODE, _("Insert node"));
	}
    else
	{
	    menu.Append(ID_LINE_REMOVE_NODE, _("Remove node"));
	}
	menu.Append(ID_DELETE, _("Delete"));
    return true;
}

void Line::RemoveNode(wxPoint2DDouble point)
{
    if(PickboxContains(point)) {
	    for(int i = 2; i < (int)m_pointList.size() - 2; i++) {
		    if(m_activePickboxID == i) {
			    m_pointList.erase(m_pointList.begin() + i);
			    break;
			}
		}
	}
    UpdateSwitchesPosition();
}

void Line::AddNode(wxPoint2DDouble point)
{
    int segmentNumber = 0;
    PointToLineDistance(point, &segmentNumber);
    if(segmentNumber > 0 && segmentNumber < (int)m_pointList.size() - 2) {
	    m_pointList.insert(m_pointList.begin() + segmentNumber + 1, point);
	}
    UpdateSwitchesPosition();
}

void Line::CalculateBoundaries(wxPoint2DDouble& leftUp, wxPoint2DDouble& rightBottom) const
{
	if(m_pointList.size() > 0) {
		// Check points list boundaries.
		leftUp = m_pointList[0];
		rightBottom = m_pointList[0];
		for(int i = 1; i < (int)m_pointList.size(); i++) {
			if(m_pointList[i].m_x < leftUp.m_x) leftUp.m_x = m_pointList[i].m_x;
			if(m_pointList[i].m_y < leftUp.m_y) leftUp.m_y = m_pointList[i].m_y;
			if(m_pointList[i].m_x > rightBottom.m_x) rightBottom.m_x = m_pointList[i].m_x;
			if(m_pointList[i].m_y > rightBottom.m_y) rightBottom.m_y = m_pointList[i].m_y;
		}
	}
}