/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, 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 Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 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 __OD_GS_BLOCKREFERENCE_NODE__
#define __OD_GS_BLOCKREFERENCE_NODE__

#include "TD_PackPush.h"

#include "GsEntityNode.h"
#include "OdVector.h"

class OdGsSpQueryContext;

/** \details
        
    Library: TD_SpatialIndex

    <group OdSi_Classes> 
*/
class GS_TOOLKIT_EXPORT OdSiRecursiveVisitor : public OdSiVisitor
{
public:
  OdSiRecursiveVisitor(): m_pQuery(NULL), m_worldToNode(NULL), m_nodeToWorld(NULL),
      m_worldToModel(NULL), m_modelToWorld(NULL){}

  const OdSiShape* query() const { return m_pQuery; }
  void resetQuery(const OdSiShape* pQuery) { m_pQuery = pQuery; }

  const OdGeMatrix3d* worldToNode() const { return m_worldToNode; }
  void setWorldToNode(const OdGeMatrix3d* tf) { m_worldToNode = tf; }
  const OdGeMatrix3d* nodeToWorld() const { return m_nodeToWorld; }
  void setNodeToWorld(const OdGeMatrix3d* tf) { m_nodeToWorld = tf; }
  const OdGeMatrix3d* worldToModel() const { return m_worldToModel; }
  void setWorldToModel(const OdGeMatrix3d* tf) { m_worldToModel = tf; }
  const OdGeMatrix3d* modelToWorld() const { return m_modelToWorld; }
  void setModelToWorld(const OdGeMatrix3d* tf) { m_modelToWorld = tf; }

protected:
  const OdSiShape* m_pQuery;
  const OdGeMatrix3d* m_worldToNode;
  const OdGeMatrix3d* m_nodeToWorld;
  const OdGeMatrix3d* m_worldToModel;
  const OdGeMatrix3d* m_modelToWorld;
};

typedef OdSiRecursiveVisitor OdSiSelBaseVisitor;

/** \details
        
    Library: TD_SpatialIndex

    <group OdSi_Classes> 
*/
class OdSiRecursiveVisitorTf
{
public:
  OdSiRecursiveVisitorTf(OdSiRecursiveVisitor& v, const OdGeMatrix3d& mat);
  ~OdSiRecursiveVisitorTf();
  operator OdSiRecursiveVisitor*() { return &m_visitor; }

protected:
  OdSiRecursiveVisitor& m_visitor;
private:
  const OdSiShape* m_prevQuery;
  std::auto_ptr<OdSiShape> m_transformedQuery;
};
typedef OdSiRecursiveVisitorTf OdSiSelectVisitorTf;

/** \details
        
  Library: TD_SpatialIndex

  <group OdSi_Classes> 
*/
class OdGsSpQueryContextTf: public OdSiRecursiveVisitorTf
{
public:
  OdGsSpQueryContextTf(OdSiRecursiveVisitor& v, const OdGeMatrix3d& objectTf, const OdGeMatrix3d& objectTfInv,
      const OdGeScale3d& scale);
  ~OdGsSpQueryContextTf();

protected:
  OdGeMatrix3d m_nodeToWorld;
  OdGeMatrix3d m_worldToNode;
  const OdGeMatrix3d* m_prevNodeToWorld;
  const OdGeMatrix3d* m_prevWorldToNode;
  OdGeMatrix3d m_modelToWorld;
  OdGeMatrix3d m_worldToModel;
  const OdGeMatrix3d* m_prevModelToWorld;
  const OdGeMatrix3d* m_prevWorldToModel;
};

// forward declarations
class OdGsBlockReferenceNodeImpl;
class OdGsBlockNode;
class WorldDrawBlockRef;
class OdGsUpdateState;

/** \details
    This class is a service class for handling of viewport aware flags array.
    
    Library: TD_Gs

    <group OdGs_Classes> 
*/
class GS_TOOLKIT_EXPORT OdGsAwareFlagsArray
{
public:
  OdGsAwareFlagsArray(){}
  enum
  {
    kChildrenNotUpToDate = 0x80000000
  };
  void setChildrenUpToDate(bool childrenUpToDate, const OdUInt32 nVpID);
  bool childrenUpToDate(OdUInt32 nVpID) const;
  OdUInt32 get(OdUInt32 nVpID) const;
  void set(OdUInt32 nVpID, OdUInt32 flags);
  void clear() { m_vpAwareFlags.clear(); }
  bool isEmpty() const { return m_vpAwareFlags.isEmpty(); }
  OdUInt32 numAwareFlags() const { return m_vpAwareFlags.size(); }
  bool areInvalid(OdUInt32 nVpID) const;

protected:
  bool findFlag(OdUInt32 nVpID) const
  { return nVpID < m_vpAwareFlags.size(); }

private:
  // viewport aware flags
  OdUInt32Vector m_vpAwareFlags;
};

/** \details
    This class is the base class for implementation of GS reference nodes.
    Derivatives of this class implement different model of storing referenced objects.

    Library: Gs
    <group OdGs_Classes> 
*/
class GS_TOOLKIT_EXPORT OdGsBlockReferenceNodeImpl
{
public:
  OdGsBlockReferenceNodeImpl();
  void* operator new(size_t);
  void  operator delete(void*);

  void addRef()
  {
    ++m_nRefCounter;
  }
  void release()
  {
	ODA_ASSERT((m_nRefCounter > 0));
	if (!(--m_nRefCounter))
      delete this;
  }
  long numRefs() const { return m_nRefCounter; }

  // Main methods, used for OdGsNode interface implementation

  //pBlock can be NULL.
  //If is not NULL only when it is passed directly from the function where the drawable is open.
  //If it is NULL and it is required then use blockNode.underlyingDrawable() 
  virtual void updateSubitems(OdGsUpdateContext& ctx,
      OdGsBlockNode& blockNode, const OdGiDrawable* pBlock) = 0;
  virtual void display(OdGsDisplayContext& ctx, bool isHighlightedAll) = 0;

  //NS: following methods return true if operation succeded (invalidation
  //or destroying leave the object valid). If they return false, it means that
  //OdGsNode should release the instance and recreate m_pImpl.
  virtual bool invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView,
	  OdUInt32 mask) = 0;
  virtual bool destroy() = 0;
  virtual bool destroySubitems() = 0;

  virtual bool select(OdGsBaseVectorizer& view, OdSiSelBaseVisitor* pVisitor,
	  bool bHasExtents, OdGsView::SelectionMode mode) = 0;
  virtual void highlight(bool bDoIt, bool bWholeBranch) = 0;
  // Methods for traversing internal subitems
  virtual OdGsEntityNode* firstEntity() = 0;
  virtual void playAsGeometry(OdGsBaseVectorizer& view, EMetafilePlayMode eMode) = 0;
  virtual bool isSharedReference() const { return false; }
  virtual bool isSharedDefinition() const { return false; }
  virtual bool layersChanged(OdGsViewImpl& view) const;

  virtual void makeStock() = 0;
  virtual void releaseStock() = 0;
  virtual void propagateLayerChangesStock() = 0;
  virtual void doSpatialQuery(OdGsSpQueryContext& ctx) = 0;

  virtual bool saveNodeImplState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer) const = 0;
  virtual bool loadNodeImplState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer, OdGsBaseModel *pModel) = 0;
  virtual void postprocessNodeImplLoading(OdGsFiler * /*pFiler*/) { }
protected:
  virtual ~OdGsBlockReferenceNodeImpl();

protected:
  OdRefCounter m_nRefCounter;
};

/** \details
        
    Library: TD_Gs

    <group OdGs_Classes> 
*/
class GS_TOOLKIT_EXPORT OdGsBlockReferenceNode: public OdGsEntityNode,
	protected OdGsAwareFlagsArray
{
public:
  ODRX_DECLARE_MEMBERS(OdGsBlockReferenceNode);
  
  OdGsBlockReferenceNode(OdGsBaseModel* pModel, const OdGiDrawable* pDrawable, bool bSetGsNode = false);
public:
  ~OdGsBlockReferenceNode();
  
  // additional flags for processing of inserts
  enum
  {
    kValid                = OdGsEntityNode::kLastFlag << 1,
    kBrExcludeFromViewExt = OdGsEntityNode::kLastFlag << 2,
    kBrClipped            = OdGsEntityNode::kLastFlag << 3,
    kLastFlag             = kBrClipped
  };
  
  bool isValid() const { return GETBIT(m_flags, kValid); }
  void setValid(bool bSet) { SETBIT(m_flags, kValid, bSet); }
  bool excludeFromViewExt() const { return GETBIT(m_flags, kBrExcludeFromViewExt); }
  void setExcludeFromViewExt(bool bSet) { SETBIT(m_flags, kBrExcludeFromViewExt, bSet); }

  virtual bool isReference() const { return true; }
  virtual bool layersChanged(OdGsViewImpl& view) const;
  // implementation of OdGsEntityNode interface:
  virtual void update(OdGsUpdateContext& ctx, OdGsContainerNode* pParent,
      OdSiSpatialIndex* pParentIndex);
  virtual void propagateLayerChanges(OdGsViewImpl& view);

  virtual void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView, OdUInt32 mask);
  virtual void destroy();
  virtual void destroySubitems();

  virtual bool select(OdGsBaseVectorizer& view, OdSiSelBaseVisitor*,
    OdGsView::SelectionMode mode);

  /** \details
  Add/release counter of highlighted children of the node, and set kHLT/kHLT_All flags if necessary
  \param nSubnodes [in]  number of subnodes
  \param bHighlight [in]  if true then highlight else unhighlight
  \param bAll [in]  if true then consider kHLT_All flag
  Returns true if and only if highlighting of the child caused changing of kHLT flag on the container.
  */
  bool highlightSubnodes(OdUInt32 nSubnodes, bool bHighlight, bool bAll);
  
  /** \details
      Returns the Aware flags for the specified Viewport for object.
      \param viewportId [in]  Viewport ID. 
  */
   virtual OdUInt32 awareFlags(OdUInt32 viewportId) const;

  /** \details
  Check Aware flags for the specified Viewport and return true if flags are invalid,
  i.e. cannot be used for determining awareness of the node about view properties.
  \param viewportId [in]  Viewport ID. 
  */
   virtual bool awareFlagsAreInvalid(OdUInt32 viewportId) const;
  
  /** \details
      Returns true if the node has no graphical content.
  */
  virtual bool isEmpty();

  virtual OdGsEntityNode* firstEntity();
  virtual OdGsEntityNode* firstAttrib() { return m_pFirstAttrib; }
  void updateImpl(OdGsUpdateContext& ctx, const OdGiDrawable* pInsert,
      OdSiSpatialIndex* pParentIndex);
  
  OdGsBlockNode* blockNode() const { return m_pBlockNode; }
  void clearBlockNode();

  virtual void makeStock();
  virtual void releaseStock();
  virtual void propagateLayerChangesStock();
  void updateBlockNode(const OdGiDrawable* pBlockTableRecord);
  //For testing purposes
  void* sharedDefinition();
  virtual bool isMInsert() const { return false; }
  static OdGsBlockReferenceNode* create(OdGsBaseModel* pModel, const OdGiDrawable* pDrawable);
  virtual void doDisplay(OdGsDisplayContext& ctx);
  virtual bool doSelect(OdGsBaseVectorizer& vect, OdGiDrawable* pDrw,
      OdSiSelBaseVisitor* pVisitor, OdGsView::SelectionMode mode);

  virtual void spatialQuery(const OdGsView& view, OdSiRecursiveVisitor* pVisitor);

protected:
  virtual void setChildrenUpToDate(bool childrenUpToDate, const OdUInt32 nVpID);
  virtual bool childrenUpToDate(OdUInt32 nVpID) const;
  virtual bool childrenRegenDraw(OdUInt32 nVpID) const;
  void updateAttribute(OdGsUpdateContext& ctx, OdGsEntityNode* pNode,
      const OdGiDrawable* pInsert, OdGsMarker marker);
  // Tool methods
  void setAwareFlags(OdUInt32 viewportId, OdUInt32 nAwareFlags);
  virtual void playAsGeometry(OdGsBaseVectorizer& view, EMetafilePlayMode eMode);
  void initBlockNode(const OdGiDrawable* pBlock);
  void setMetafile(OdGsUpdateContext& ctx, OdGsEntityNode::Metafile* pMf,
      OdUInt32 awareFlags, const OdGeExtents3d& ext);
  bool needRegen(OdUInt32 nVpID) const
  {
    if(!childrenUpToDate(nVpID))
        return true;
    OdUInt32 nAF = awareFlags(nVpID);
    if( nAF == 0xFFFFFFFF || (baseModel()->viewChanges(nVpID) & nAF) != 0 )
    {
      const_cast<OdGsBlockReferenceNode*>(this)->setChildrenUpToDate(false, nVpID);
      return true;
    }
    return false;
  }
  virtual void doUpdateImpl(OdGsUpdateContext& ctx, const OdGiDrawable* pBlockTableRecord, unsigned iInstance);
  void drawBlock(OdGsUpdateContext& ctx, const OdGiDrawable* pBlockTableRecord,
      OdGsBlockReferenceNodeImpl* pContainer,
      bool bEnableSharedGraphics);
  void postUpdateStep(OdGsUpdateState& state);
  void addEntPropsFromState(const OdGsUpdateState& state);
  void checkCancelledSharedRef(OdGsUpdateState& state);
  static void actionPostUpdateStep(void* pObj, OdGsUpdateState& state);
  static void actionAddEntPropsFromState(void* pObj, OdGsUpdateState& state);
  static void actionCheckCancelledSharedRef(void* pObj, OdGsUpdateState& state);
  static void actionRestartLocked(void* pObj, OdGsUpdateContext& ctx);
  virtual void doSpatialQuery(OdGsSpQueryContext& ctx);

  bool saveClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer) const;
  bool loadClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer);
  bool postprocessNodeLoading(OdGsFiler *pFiler);
private:
  void createImpl(const OdGsUpdateContext& ctx, bool bTryShared);
  void drawBlockImpl(OdGsUpdateContext& ctx, const OdGiDrawable* pBlockTableRecord,
      OdGsBlockReferenceNodeImpl* pContainer,
      bool bEnableSharedGraphics);

  bool isAProxy(OdGiDrawable *pDrw, const OdGiContext *pCtx = NULL) const;
protected:
  // Pointer to implementation object
  TPtr<OdGsBlockReferenceNodeImpl> m_pImpl;
  // Pointer to the node, corresponding to the block table record  
  OdGsBlockNode* m_pBlockNode;
  // list of attributes
  OdGsEntityNode* m_pFirstAttrib;

  friend class WorldDrawBlockRef;
  friend class GsDrawableNested;
  friend class OdGsSpQueryContext;
};

/** \details
            
    Library: TD_Gs

    <group OdGs_Classes> 
*/
class GS_TOOLKIT_EXPORT OdGsMInsertBlockNode: public OdGsBlockReferenceNode
{
public:
  ODRX_DECLARE_MEMBERS(OdGsMInsertBlockNode);
  OdGsMInsertBlockNode(OdGsBaseModel* pModel, const OdGiDrawable* pInsert, bool bSetGsNode = false);
public:
  ~OdGsMInsertBlockNode();

  virtual void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView, OdUInt32 mask);
  virtual void destroy();
  virtual void destroySubitems();

  virtual void highlight(bool bDoIt, bool bWholeBranch);

  virtual OdGsEntityNode* firstEntity();
  virtual OdGsEntityNode* firstAttrib();
  virtual bool layersChanged(OdGsViewImpl& view) const;
  virtual void playAsGeometry(OdGsBaseVectorizer& view, EMetafilePlayMode eMode);

  virtual void makeStock();
  virtual void releaseStock();
  virtual void propagateLayerChangesStock();
  virtual bool isMInsert() const { return true; }
  virtual void doUpdateImpl(OdGsUpdateContext& ctx,
    const OdGiDrawable* pBlockTableRecord, unsigned iInstance);
  OdGsEntityNode*& firstAttrib(unsigned iInstance) { return item(iInstance)->m_pFirstAttrib; }
  void stretchExtents();
  void setParams(const OdGeMatrix3d& blockTf, int nCols, int nRows, double sx, double sy)
  {
    m_blockTf = blockTf;
    m_nCols = nCols;
    m_nRows = nRows;
    m_sx = sx;
    m_sy = sy;
  }
  static void actionStretchExtents(void* pObj, OdGsUpdateState& state);
  virtual void doDisplay(OdGsDisplayContext& ctx);
  virtual bool doSelect(OdGsBaseVectorizer& vect, OdGiDrawable* pDrw,
      OdSiSelBaseVisitor* pVisitor, OdGsView::SelectionMode mode);

protected:
  void destroyCollection();

  bool selectSubitems(OdGsBaseVectorizer& view,
	  OdSiSelBaseVisitor* pVisitor, OdGsView::SelectionMode mode);
  bool selectAttributes(OdGsBaseVectorizer& view);

protected:
  class GS_TOOLKIT_EXPORT CollectionItem
  {
  public:
    CollectionItem() : m_nodeImp(0), m_pFirstAttrib(0) { }
    CollectionItem(const CollectionItem& c):
    m_nodeImp(c.m_nodeImp), m_pFirstAttrib(c.m_pFirstAttrib){}
    void copyFrom(const CollectionItem& c);

    OdGsBlockReferenceNodeImpl* imp() { return m_nodeImp; }
    const OdGsBlockReferenceNodeImpl* imp() const { return m_nodeImp; }
    OdGsEntityNode* firstAttrib() { return m_pFirstAttrib; }
    const OdGsEntityNode* firstAttrib() const { return m_pFirstAttrib; }

  public:
    TPtr<OdGsBlockReferenceNodeImpl> m_nodeImp;
    OdGsEntityNode* m_pFirstAttrib;

    bool operator ==(const CollectionItem &it2) const
    {
      return (m_nodeImp == it2.m_nodeImp) && (m_pFirstAttrib == it2.m_pFirstAttrib);
    }
    bool operator !=(const CollectionItem &it2) const
    {
      return (m_nodeImp != it2.m_nodeImp) || (m_pFirstAttrib != it2.m_pFirstAttrib);
    }
  };
  class GS_TOOLKIT_EXPORT Collection: public OdArray<CollectionItem>
  {
  public:
    Collection(): OdArray<CollectionItem>(){}
    Collection(const Collection& c);
    ~Collection();
  };
protected:
  OdGsBlockReferenceNodeImpl* getImpl(unsigned iInstance) { return item(iInstance)->m_nodeImp; }
  CollectionItem* item(unsigned iInstance);
  void clearParams() {m_nCols = m_nRows = 0; m_sx = m_sy = 0.; m_blockTf.setToIdentity(); }

  bool saveClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer) const;
  bool loadClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer);
  bool postprocessNodeLoading(OdGsFiler *pFiler);
protected:
  // Collection of implementation objects, representing clipped MINSERT.
  // (If MINSERT is not clipped, it's represented by only implementation 
  // object OdGsBlockReferenceNode::m_pImpl)
  Collection* m_pCollectionImpl;
  OdGeMatrix3d m_xModelToWorld;
  OdGeMatrix3d m_blockTf;
  int m_nCols;
  int m_nRows;
  double m_sx;
  double m_sy;
};

inline void OdGsBlockReferenceNode::clearBlockNode()
{
  m_pBlockNode = 0;
}

#include "TD_PackPop.h"

#endif // __OD_GS_REFERENCE_NODE__