/***************************************************************************
 *   Copyright (c) 2018 Abdullah Tahiri <abdullah.tahiri.yo@gmail.com>     *
 *   Copyright (c) 2013 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef SKETCHER_SKETCHANALYSIS_H
#define SKETCHER_SKETCHANALYSIS_H

#include <vector>
#include <memory>
#include <Base/Vector3D.h>
#include "Analyse.h"
#include "SketchObject.h"

namespace Sketcher {

class SketchObject;

class SketcherExport SketchAnalysis
{
public:
    /// Creates an instance of the SketchAnalysis object, taking as parameter a pointer to an SketchObject.
    ///
    /// There is a first type of routines, simple routines, which work in the following order:
    /// Detect - (Analyse) - [Get] - [Set] - Make
    ///
    /// The Detect step just identifies possible missing constraints.
    ///
    /// The Analyse, which is not available for all the routines, operates in detected constraints of the same routine, to
    /// look for alternatives. For example, a general pointonpoint detection leads to a search for coincident constraints, which
    /// can be later run via Analyse if it is intended to convert endpoint coincidence to endpoint perpendicular and tangent constraints.
    ///
    /// The Get retrieves the result of the analysis as a vector of ConstraintIds, indicating the suggested constraints. This step is intended
    /// for enabling the user to check the result of the analysis, rather than applying it. If only applying is intended, this step is not necessary
    /// as the Make will operate on the result of the Detect - Analyse directly.
    ///
    /// The Set changes the detected result. It modifies the SketchAnalysis object. It only modifies the SketchObject as far as the SketchAnalysis is changed.
    /// It does not apply any changes to the sketch. It is intended so as to enable the user to change the result that will be applied.
    ///
    /// Neither the Detect, nor the Analyse, nor the Get steps modify the Sketch geometry.
    ///
    /// Make applies the constraints stored internally in the SketchAnalysis object.
    ///
    /// A second type of routines, complex routines, are thought for running fully automatic and they Detect, Analyse and Make.
    /// They may also apply a variaty of types of Constraints.
    ///
    /// A third type of routines do not relate to autoconstraining at all, and include validation methods for sketches.
    SketchAnalysis(Sketcher::SketchObject * Obj);
    ~SketchAnalysis();

    // Simple routines (see constructor)

    /// Point on Point constraint simple routine Detect step (see constructor)
    /// Detect detects only coincident constraints, Analyse converts coincident to endpoint perpendicular/tangent where appropriate
    int detectMissingPointOnPointConstraints(double precision = Precision::Confusion() * 1000, bool includeconstruction = true);
    /// Point on Point constraint simple routine Analyse step (see constructor)
    void analyseMissingPointOnPointCoincident(double angleprecision = M_PI/8);
    /// Point on Point constraint simple routine Get step (see constructor)
    std::vector<ConstraintIds> &getMissingPointOnPointConstraints(void) {return vertexConstraints;};
    /// Vertical/Horinzontal constraints simple routine Set step (see constructor)
    void setMissingPointOnPointConstraints(std::vector<ConstraintIds>& cl) {vertexConstraints = cl;};
    /// Point on Point constraint simple routine Make step (see constructor)
    /// if onebyone, then the sketch is solved after each individual constraint addition and any redundancy removed.
    void makeMissingPointOnPointCoincident(bool onebyone = false);

    /// Vertical/Horizontal constraints simple routine Detect step (see constructor)
    int detectMissingVerticalHorizontalConstraints(double angleprecision = M_PI/8);
    /// Vertical/Horizontal constraints simple routine Get step (see constructor)
    std::vector<ConstraintIds> &getMissingVerticalHorizontalConstraints(void) {return verthorizConstraints;};
    /// Vertical/Horinzontal constraints simple routine Set step (see constructor)
    void setMissingVerticalHorizontalConstraints(std::vector<ConstraintIds>& cl) {verthorizConstraints = cl;};
    /// Vertical/Horizontal constraints simple routine Make step (see constructor)
    void makeMissingVerticalHorizontal(bool onebyone = false);

    /// Equality constraints simple routine Detect step (see constructor)
    int detectMissingEqualityConstraints(double precision);
    /// Equality constraints simple routine Get step for line segments (see constructor)
    std::vector<ConstraintIds> &getMissingLineEqualityConstraints(void) {return lineequalityConstraints;};
    /// Equality constraints simple routine Get step for radii (see constructor)
    std::vector<ConstraintIds> &getMissingRadiusConstraints(void) {return radiusequalityConstraints;};
    /// Equality constraints simple routine Set step for line segments (see constructor)
    void setMissingLineEqualityConstraints(std::vector<ConstraintIds>& cl) {lineequalityConstraints = cl;};
    /// Equality constraints simple routine Set step for radii (see constructor)
    void setMissingRadiusConstraints(std::vector<ConstraintIds>& cl) {radiusequalityConstraints = cl;};
    /// Equality constraints simple routine Make step (see constructor)
    void makeMissingEquality(bool onebyone = true);

    // Complex routines (see constructor)

    /// Fully automated multi-constraint autoconstraining
    ///
    /// It DELETES all the constraints currently present in the Sketcher. The reason is that it makes assumptions to avoid redundancies.
    ///
    /// It applies coincidents - vertical/horizontal constraints and equality constraints.
    int autoconstraint(double precision = Precision::Confusion() * 1000, double angleprecision = M_PI/8, bool includeconstruction = true);

    // helper functions, which may be used by more complex methods, and/or called directly by user space (python) methods

    /// solves the sketch and retrieves the error status, and the degrees of freedom.
    /// It enables to solve updating the geometry (so moving the geometry to match the constraints) or preserving the geometry.
    void solvesketch(int &status, int &dofs, bool updategeo);

    // third type of routines
    std::vector<Base::Vector3d> getOpenVertices(void) const;

protected:
    Sketcher::SketchObject* sketch;

    struct VertexIds;
    struct Vertex_Less;
    struct Vertex_EqualTo;
    struct EdgeIds;
    struct Edge_Less;
    struct Edge_EqualTo;
    std::vector<ConstraintIds> vertexConstraints;
    std::vector<ConstraintIds> verthorizConstraints;
    std::vector<ConstraintIds> lineequalityConstraints;
    std::vector<ConstraintIds> radiusequalityConstraints;

protected:
    bool checkHorizontal(Base::Vector3d dir, double angleprecision);
    bool checkVertical(Base::Vector3d dir, double angleprecision);

};

} //namespace Sketcher

#endif // SKETCHER_SKETCHANALYSIS_H
