// Returns true if there is no collision, and false if there is a collision.
bool TestSAT(AABB a, AABB b)
{
	// Since these are AABB collisions, we can easily determine the normals. That said, this was left this way for understanding and future implementation.
	// The first step is to get the normals for the two colliding objects, as these will be the axes on which we test for collisions.
	std::vector<glm::vec3> aNormals = GetNormals(a);
	std::vector<glm::vec3> bNormals = GetNormals(b);
	
	// A quick method that exists for getting the points of the AABB. In a regular implementation, we might instead pass in the actual points to this algorithm, skipping
	// this step.
	std::vector<glm::vec3> aPoints = GetPoints(a);
	std::vector<glm::vec3> bPoints = GetPoints(b);

	// This boolean gets returned, and will be true if there is no collision.
	bool isSeparated = false;

	// For each normal
	for (int i = 0; i < aNormals.size(); i++)
	{
		// Get the Min and Max projections for each object along the normal.
		float aMin, aMax;
		GetMinMax(aPoints, aNormals[i], aMin, aMax);

		float bMin, bMax;
		GetMinMax(bPoints, aNormals[i], bMin, bMax);

		// If the maximum projection of one of the objects is less than the minimum projection of the other object, then we can determine that there is a separation 
		// along this axis. Thus, we set isSeparated to true and break out of the for loop.
		isSeparated = aMax < bMin || bMax < aMin;
		if (isSeparated) break;
	}

	// This only runs if we still haven't proven that there is a separation between the two objects.
	// SAT is an optimistic algorithm in that it will stop the moment it determines there isn't a collision, and as such the less collisions there are the faster it will run.
	if (!isSeparated)
	{
		// Loop through the normals for the second object.
		// Note that since this is an AABB, the normals will be the same as the previous object. Again, this is left for future implementation and understanding.
		// The process below is exactly the same as above, only with object b's normals instead of object a.
		for (int i = 0; i < bNormals.size(); i++)
		{
			float aMin, aMax;
			GetMinMax(aPoints, bNormals[i], aMin, aMax);

			float bMin, bMax;
			GetMinMax(bPoints, bNormals[i], bMin, bMax);

			isSeparated = aMax < bMin || bMax < aMin;
			if (isSeparated) break;
		}
	}

	// At this point, isSeparated has been tested against each normal. If it has been set to true, then there is a separation. If it is false, that means none of the axes 
	// were separated, and there is a collision.
	return isSeparated;
}

bool DragRect::PtIn(const DPoint& pt) const {
    // Look at the z portion of the cross product on each side. The result
    // should be all negative or positive to be inside.

    DPoint apt[4];
    GetPoints(apt);

    double d0 = (pt.x - apt[0].x) * (apt[1].y - apt[0].y) -
            (pt.y - apt[0].y) * (apt[1].x - apt[0].x);
    double d1 = (pt.x - apt[1].x) * (apt[2].y - apt[1].y) -
            (pt.y - apt[1].y) * (apt[2].x - apt[1].x);
    double d2 = (pt.x - apt[2].x) * (apt[3].y - apt[2].y) -
            (pt.y - apt[2].y) * (apt[3].x - apt[2].x);
    double d3 = (pt.x - apt[3].x) * (apt[0].y - apt[3].y) -
            (pt.y - apt[3].y) * (apt[0].x - apt[3].x);

    if (d0 < 0.0 && d1 < 0.0 && d2 < 0.0 && d3 < 0.0) {
        return true;
    }
    if (d0 >= 0.0 && d1 >= 0.0 && d2 >= 0.0 && d3 >= 0.0) {
        return true;
    }

    return false;
}

void ArenaTeam::UpdateArenaPointsHelper(std::map<uint32, uint32>& playerPoints)
{
    // Called after a match has ended and the stats are already modified
    // Helper function for arena point distribution (this way, when distributing, no actual calculation is required, just a few comparisons)
    // 10 played games per week is a minimum
    if (Stats.WeekGames < 10)
        return;

    // To get points, a player has to participate in at least 30% of the matches
    uint32 requiredGames = (uint32)ceil(Stats.WeekGames * 0.3f);

    for (MemberList::const_iterator itr = Members.begin(); itr !=  Members.end(); ++itr)
    {
        // The player participated in enough games, update his points
        uint32 pointsToAdd = 0;
        if (itr->WeekGames >= requiredGames)
            pointsToAdd = GetPoints(itr->PersonalRating);

        std::map<uint32, uint32>::iterator player_itr = playerPoints.find(GUID_LOPART(itr->Guid));
        if (player_itr != playerPoints.end())
        {
            // Check if there is already more points
            if (player_itr->second < pointsToAdd)
                playerPoints[GUID_LOPART(itr->Guid)] = pointsToAdd;
        }
        else
            playerPoints[GUID_LOPART(itr->Guid)] = pointsToAdd;
    }
}

void
PolyBezierSegment::Append (moon_path *path)
{
	PointCollection *col;
	GPtrArray *points;

	col = GetPoints ();
	int points_count = col->GetCount ();

	// we need at least 3 points
	if (!col || (points_count % 3) != 0)
		return;

	points = col->Array();
	
	for (int i = 0; i < points_count - 2; i += 3) {
		moon_curve_to (path,
			       ((Value*)g_ptr_array_index(points, i))->AsPoint()->x,
			       ((Value*)g_ptr_array_index(points, i))->AsPoint()->y,

			       ((Value*)g_ptr_array_index(points, i+1))->AsPoint()->x,
			       ((Value*)g_ptr_array_index(points, i+1))->AsPoint()->y,

			       ((Value*)g_ptr_array_index(points, i+2))->AsPoint()->x,
			       ((Value*)g_ptr_array_index(points, i+2))->AsPoint()->y);
	}
}

bool Tan::IsOutsidePanel(){
    wxPoint* points=GetPoints();
    for(int i=0;i<GetSize();i++){
        if(points[i].x < 0 || points[i].x > WIDTH || points[i].y < 0 || points[i].y > HEIGHT) return true;
    }   
    return false;
}

std::vector<sf::Vector2f> Polygon::GetAxes()
{
	std::vector<sf::Vector2f> result;

	auto points = GetPoints();
	double length;
	sf::Vector2f axis, edge;
	for (int i = 0; i < points.size(); ++i)
	{
		//Calculate the edge between each point and its neighbor
		edge.x = points[(i + 1) % points.size()].x - points[i].x;
		edge.y = points[(i + 1) % points.size()].y - points[i].y;

		//Get length of edge
		length = sqrt(edge.x * edge.x + edge.y * edge.y);

		//Normalize
		edge.x /= length;
		edge.y /= length;

		//Push the pependiular vector to edge into the axes vector
		result.push_back(sf::Vector2f(-edge.y, edge.x));
	}

	return result;
}

void ArenaTeam::UpdateArenaPointsHelper(std::map<uint32, uint32>& PlayerPoints)
{
    // called after a match has ended and the stats are already modified
    // helper function for arena point distribution (this way, when distributing, no actual calculation is required, just a few comparisons)
    // 10 played games per week is a minimum
    if (m_stats.games_week < 10)
        return;
    // to get points, a player has to participate in at least 30% of the matches
    uint32 min_plays = (uint32) ceil(m_stats.games_week * 0.3);
    for (MemberList::const_iterator itr = m_members.begin(); itr !=  m_members.end(); ++itr)
    {
        // the player participated in enough games, update his points
        uint32 points_to_add = 0;
        if (itr->games_week >= min_plays)
            points_to_add = GetPoints(itr->personal_rating);
        // OBSOLETE : CharacterDatabase.PExecute("UPDATE arena_team_member SET points_to_add = '%u' WHERE arenateamid = '%u' AND guid = '%u'", points_to_add, m_TeamId, itr->guid);

        std::map<uint32, uint32>::iterator plr_itr = PlayerPoints.find(GUID_LOPART(itr->guid));
        if (plr_itr != PlayerPoints.end())
        {
            //check if there is already more points
            if (plr_itr->second < points_to_add)
                PlayerPoints[GUID_LOPART(itr->guid)] = points_to_add;
        }
        else
            PlayerPoints[GUID_LOPART(itr->guid)] = points_to_add;
    }
}

FilterPoints2::FilterPoints2(potrace_path_t *path, float proportionXY, /*float tolerance, */float minlen)
{
	Path = path;
	koefProportionXY = proportionXY;
	//Tolerance = tolerance;
	MinLen = minlen;
	GetPoints();
}

/**
 * Send a new point request
 * @param point
 *
 * Info sent: AddPoints - Points...
 */
void Sender::sendPoints(Point* point)//std::vector<Point> points)
{
    std::string toSend = separator;
    toSend += NumberToString(ADD_POINTS);
    toSend += separator;

    toSend += GetPoints(point);

    client->sendMessage(toSend);
}

/**
 * @brief LengthBezier return spline length using 4 spline point.
 * @param p1 first spline point
 * @param p2 first control point.
 * @param p3 second control point.
 * @param p4 last spline point.
 * @return length.
 */
qreal VSpline::LengthBezier ( const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &p4 ) const
{
    QPainterPath splinePath;
    QVector<QPointF> points = GetPoints (p1, p2, p3, p4);
    splinePath.moveTo(points.at(0));
    for (qint32 i = 1; i < points.count(); ++i)
    {
        splinePath.lineTo(points.at(i));
    }
    return splinePath.length();
}

void BodyInst::GetOBB(myBody *b)
{
  GetPoints(b);
  for(int i=0;i<8;i++)
  {
      float p[3] = {b->pts[i*3]-b->center[0],b->pts[i*3+1]-b->center[1], b->pts[i*3+2]-b->center[2]};
      QuaternionTransform(p, b->orientation);
      b->pts[i*3] = p[0]+b->center[0];
      b->pts[i*3+1] = p[1]+b->center[1];
      b->pts[i*3+2] = p[2]+b->center[2];
  }
}

wxPoint Tan::GetCenter(){
    wxPoint* points=GetPoints();
    int centerX=0;
    int centerY=0;
    for(int i=0;i<GetSize();i++){
        centerX+=points[i].x;
        centerY+=points[i].y;   
    }
    centerX/=GetSize();
    centerY/=GetSize();
    return wxPoint(centerX,centerY);
}

bool Tan::IsCrossing(Tan* tan) {
    wxPoint* points=GetPoints();
    wxPoint* pointsToCheck=tan->GetPoints();
    for(int i=0;i<GetSize();i++){
        for(int j=0;j<tan->GetSize();j++){
            if(VectorUtils::IsCrossing(points[i],points[(i+1)%GetSize()],pointsToCheck[j],pointsToCheck[(j+1)%tan->GetSize()])) {
                return true;
            }
        }   
    }
    return false;
}

BOOL CDoc::FileOpen(LPCTSTR szFilename)
{
	GetPoints().clear();
	BOOL bResult = FALSE;

	try
	{
		CArchive ar(szFilename, CArchive::load);
		ar >> *this;
		bResult = TRUE;
	}

	catch (const CFileException &e)
	{
		// An exception occurred. Display the relevant information.
		::MessageBox(NULL, e.GetText(), _T("Failed to Load File"), MB_ICONWARNING);
		
		GetPoints().clear();
	}

	return bResult;
}

float* Box::GetOBB()
{
  GetPoints();
  float* center = GetCenter();
  for(int i=0;i<8;i++)
  {
      float p[3] = {pts[i*3]-center[0],pts[i*3+1]-center[1], pts[i*3+2]-center[2]};
      QuaternionTransform(p, GetOrientation());
      pts[i*3] = p[0]+center[0];
      pts[i*3+1] = p[1]+center[1];
      pts[i*3+2] = p[2]+center[2];
  }

  return pts;
}

int CGraphBSpline::Draw( CFmlDrawEngine& fde, const PointFde& tl, CNode* )
{
	RectFde rc = GetPositionRect();
	rc.translate( tl.x(), tl.y() );

	QVector<qint8> tp;
	QVector<PointFde> xy;
	GetPoints( rc, xy, tp );

	QColor color = (GetColor() == DEFAULT_GRAPH_COLOR ? ::getCurrentFormulatorStyle().getLogPen().m_color : GetColor());

	fde.DrawFillPath( xy, tp, FS_LogPen( color, (Qt::PenStyle) GetStyle(), GetWidth() ), FS_LogBrush(GetColor(), Qt::SolidPattern) );

	return 1;
}

// cppcheck-suppress unusedFunction
QVector<QPointF> VSpline::SplinePoints(const QPointF &p1, const QPointF &p4, qreal angle1, qreal angle2, qreal kAsm1,
                                       qreal kAsm2, qreal kCurve)
{
    QLineF p1pX(p1.x(), p1.y(), p1.x() + 100, p1.y());
    p1pX.setAngle( angle1 );
    qreal L = 0, radius = 0, angle = 90;
    radius = QLineF(QPointF(p1.x(), p4.y()), p4).length();
    L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
    QLineF p1p2(p1.x(), p1.y(), p1.x() + L * kAsm1, p1.y());
    p1p2.setAngle(angle1);
    QLineF p4p3(p4.x(), p4.y(), p4.x() + L * kAsm2, p4.y());
    p4p3.setAngle(angle2);
    QPointF p2 = p1p2.p2();
    QPointF p3 = p4p3.p2();
    return GetPoints(p1, p2, p3, p4);
}

	void MeshPhysicsShape::Save(Archive& archive)
	{
		PhysicsSystem::SERIAL_CreateMesh.Save(archive);

		int count = GetNumPoints();
		archive.Write(&count);

		Vector3* verts = GetPoints();
		for (int x = 0; x < count; ++x)
		{
			archive.Write(&verts[x].x);
			archive.Write(&verts[x].y);
			archive.Write(&verts[x].z);
		}

		Vector3& scale = GetScale();
		archive.Write(&scale);
	}