/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////
#ifndef DWGAssocActionPE_INCLUDED_
#define DWGAssocActionPE_INCLUDED_

#include "DWGConstraintsExport.h"
#include "AssocActionPE.h"
#include "OdConstrainedGeometry.h"
#include "OdConstraintGroupNode.h"
#include "CsGeometry.h"
#include "CsConstraintSystem.h"
#include "CsConstraint.h"
#include "DWGTransfTyper.h"
#include "OdArray.h"
#include "ConstraintSolver.h"
#define STL_USING_MAP
#include "OdaSTL.h"

#include "TD_PackPush.h"

#include "OdImplicitConstr.h"

typedef OdArray<OdConstraintGroupNodeId,
    OdMemoryAllocator<OdConstraintGroupNodeId> > OdGroupNodeIdArray;

using OdConstrainedGeometryPtr = OdSmartPtr<OdConstrainedGeometry>;
using OdConstrainedGeometryArray = OdArray<OdConstrainedGeometry*>;
using OdGeomConstraintArray = OdArray<OdGeomConstraint*>;
using OdConstrainedGeometryPtrArray = OdArray<OdConstrainedGeometryPtr>;

/** <group Extension_Classes>
*/
class DWGCONSTRAINTS_EXPORT DWGAssocActionPE : public AssocActionPE
{
public:
  ODRX_DECLARE_MEMBERS(DWGAssocActionPE);

  DWGAssocActionPE();
  virtual ~DWGAssocActionPE(){}

  virtual void evaluate(OdDbAssocAction *action);

  virtual void runDiagnostics(const OdDbAssocAction*) {}


  struct Solver2DRX 
  {
    OdCsGeometryPtr _solverId;
    OdConstraintGroupNodeId _drxId = 0;
  };

  typedef std::map<OdConstraintGroupNodeId, OdCsConstraintPtr> Solver2Constraint;

private:
  struct InfoMUC
  {
    InfoMUC() : _ptMoveCoordinate(HUGE_VAL, HUGE_VAL) {}

    OdConstrainedGeometry* _geomMUC = NULL;
    OdConstrainedGeometry* _ptMove = NULL;
    OdCsGeometryPtr _geomCs = NULL; // is set from _geomMUC
    OdGePoint2d _ptMoveCoordinate; // is set from _ptMove, but may be set directly
    //OdCsPointPtr _ptCS = NULL;
  };

  void CreateContext();
  void DestroyContext(OdCsConstraintSystem& iContext);

  void CreateSolverModel(OdDbAssoc2dConstraintGroup * ipConstraintGroup);
  void CreateOriginalSolverModel(OdDbAssoc2dConstraintGroup * ipConstraintGroup, InfoMUC* infoMUC = NULL);

  void ProcessActions(OdDbObjectIdArray iaActionIds);

  void ProcessAssoc2dConstraintGroup(OdDbAssoc2dConstraintGroup *pCnGr);

  OdCsGeometryPtr CreateSolverPoint(OdConstrainedPoint* ipPoint, bool& alreadyExist, bool original);
  OdCsGeometryPtr CreateSolverLine(OdConstrainedLine* ipLine);
  OdCsGeometryPtr CreateSolverCircle(OdConstrainedCircle* ipCircle);
  OdCsGeometryPtr CreateSolverEllipse(OdConstrainedEllipse* ipEllipse);
  OdCsGeometryPtr CreateSolverSpline(OdConstrainedSpline* ipSpline, bool original);

  OdCsGeometryPtr CreateOriginalSolverLine(OdConstrainedLine* ipLine);
  OdCsGeometryPtr CreateOriginalSolverCircle(OdConstrainedCircle* ipCircle);
  OdCsGeometryPtr CreateOriginalSolverEllipse(OdConstrainedEllipse* ipEllipse);
  OdCsGeometryPtr CreateSolverRigidSet(const OdConstrainedRigidSet* rigidSet, bool& alreadyExist, bool original);
  void RigidSetNestedGeometries(const OdConstrainedRigidSet* rigidSet, OdVector<OdCsGeometryPtr>& nestedGeometries);
  void CreateSolverConstraints(OdDbAssoc2dConstraintGroup * ipConstraintGroup, bool original, InfoMUC* infoMUC = NULL);
  void CreateSolverConstraint(OdGeomConstraint* ipConstraint, bool original, InfoMUC* infoMUC = NULL);
  void CreateDistanceConstraint(OdGePoint3d& startPtCoord, OdGeVector2d& solverDir, OdCsGeometryPtr  args[4], OdCsConstraintPtr& solverCnstr, double val);
  using OdConstrainedRigidSetArray = OdArray<OdConstrainedRigidSet*>;
  void CreateSolverRigidSets(const OdConstrainedRigidSetArray &rigidSets, bool original);

  bool CreateContextAndApplyChanges(OdDbAssoc2dConstraintGroup * ipConstraintGroup);

  void UpdateFromSolver(OdDbAssoc2dConstraintGroup * ipConstraintGroup);
  void RestoreOriginalGeom(OdConstrainedCurve* pCurve);
  void RestoreOriginalGeom(OdConstrainedGeometryPtrArray& aConstrainedGeometry);
  bool UpdateDRXPoint(OdConstrainedPoint* ipPoint, OdCsPointPtr iPt);
  bool UpdateDRXLine(OdConstrainedLine* ipLine, OdCsLinePtr iLn);
  bool UpdateDRXCircle(OdConstrainedCircle* ipCircle, OdCsCirclePtr iCi);
  bool UpdateDRXEllipse(OdConstrainedEllipse* ipEllipse, OdCsEllipsePtr iEl);
  bool UpdateDRXRigidSet(OdConstrainedRigidSet* ipRigidSet, OdCsRigidSetPtr iRs);
  bool UpdateDRXSpline(OdConstrainedSpline* ipSpline, OdCsSplinePtr iSpline);

  void getAllModifiedGeomPoints(const OdDbAssoc2dConstraintGroup* ipConstraintGroup,
                                OdConstrainedGeometryPtrArray& aConstGeom);

  void getAllModifiedCurves(const OdDbAssoc2dConstraintGroup* ipConstraintGroup,
                            OdConstrainedGeometryPtrArray& aConstGeom);

  inline void createTangentAuxiliaryConstraints(const OdTangentConstraint* pTangent,
                                                const OdCsGeometryPtr args[4],
                                                const OdArray<OdConstrainedGeometry*>& apConsGeoms);
  void deleteChangedPlainGeometries(OdDbAssoc2dConstraintGroup* constraintGroup,
                                    OdConstrainedGeometryPtrArray& constrainedGeometris);

  /*
  * \brief Find all modified geometries, deletes geometries which changed plain and
  *        returns others
  */
  void getModifiedGeometries(OdDbAssoc2dConstraintGroup* constraintGroup,
                             OdConstrainedGeometryPtrArray& constrainedCurves,
                             OdConstrainedGeometryPtrArray& constrainedPoints);

public:
  OdCsGeometryPtr FindSolverObject(OdConstraintGroupNodeId iId) const;

  SolverTransfTyper getTransformation(const OdGePoint3d& srcPtS, const OdGePoint3d& srcPtE,
                                       const OdGePoint3d& dstPtS, const OdGePoint3d& dstPtE);

  SolverTransfTyper getTransformation(const OdConstrainedGeometry* pGeom);
  SolverTransfTyper getTransformation(const OdConstrainedCurve* pCurve);
  SolverTransfTyper getTransformation(const OdConstrainedPoint* pPoint);
  SolverTransfTyper getTransformation(const OdConstrainedLine* pLine);
  SolverTransfTyper getTransformation(const OdConstrainedBoundedLine* pLine);
  SolverTransfTyper getTransformation(const OdConstrainedCircle* pCircle);
  SolverTransfTyper getTransformation(const OdConstrainedArc* pCircleArc);
  SolverTransfTyper getTransformation(const OdConstrainedEllipse* pEllipse);
  SolverTransfTyper getTransformation(const OdConstrainedBoundedEllipse* pEllipseArc);
  SolverTransfTyper getTransformation(const OdConstrainedSpline* pSpline);

  bool isFitTransformation(const OdConstrainedGeometry* pGeom, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedCurve* pCurve, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedPoint* pPoint, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedLine* pLine, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedBoundedLine* pLine, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedCircle* pCircle, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedArc* pCircleArc, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedEllipse* pEllipse, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedBoundedEllipse* pEllipseArc, SolverTransfTyper& tf);
  bool isFitTransformation(const OdConstrainedSpline* pSpline, SolverTransfTyper& tf);

  SolverTransfTyper getCommonTransformation(const OdConstrainedGeometryPtrArray& aConstrainedGeometry,
                                           const OdArray<SolverTransfTyper>& aTransforTyper);

protected:
  OdCsGeometryPtr findCommonLine(const OdConstrainedPoint* pPointF, const OdConstrainedPoint* pPointS);
  void getStartEndPoints(OdConstrainedCurve* pCurve, OdGePoint3d& start, OdGePoint3d& end, bool& haveStart, bool& haveEnd);
  bool getPoint(OdConstraintGroupNodeId id, OdGePoint3d& pt);

public:
  OdCsConstraintSystem _ctx;
  OdArray<Solver2DRX> _aIds;
  Solver2Constraint _aIdsConstraint;
protected:
  std::map<OdCsGeometry*, OdCsPointPtr> _mapCoincidense;

public:
    /**
      \details Class which helps control auxiliary constrains indices.
               Auxiliary constrains holds in _ctx.constraints() array from firstAuxiliaryConstraintIndex to end of array.
    */
    struct AuxiliaryConstraintsHelper
    {
    public:
        AuxiliaryConstraintsHelper();
        void reset();
        void addAuxiliaryConstraint(const OdCsConstraintPtr newElement);
        void addAuxiliaryBoundedLineFixation(const OdCsFixationPtr newElement, double dist2);
        void addCoincidenceParamLock(OdCsCoincidencePtr coincidence, double param);

        bool addAuxiliaryConstraints(OdCsConstraintSystem& system);
        void reorderAuxiliaryConstraints();
        bool deleteAuxiliaryConstraint(OdConstraints& constraints, bool removeAll); // returns true if all aux constraint are deleted
        bool auxConstraintLeft(const OdConstraints& constraints) const; // is there any work for deleteAuxiliaryConstraint?

        OdConstraintSolver::Result solveWithAuxConstraints(OdCsConstraintSystem& ctx, OdCsMoveUnderConstraintsOptions* options = NULL);

        mutable OdConstraints _constraintsAux;
        mutable std::map<double, OdCsConstraintPtr> _fixationBoundedLine;
        OdArray<std::pair<OdCsCoincidencePtr, double>> _coincidenceParamLock;
        unsigned int _nMainConstraints = 0;
        unsigned int _iParamLock = 0;
        bool _allowOverconstrain = true;
    };

    AuxiliaryConstraintsHelper _auxiliaryConstraintHelper;
};

#include "TD_PackPop.h"

#endif