/////////////////////////////////////////////////////////////////////////////// 
// 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_GIFILL_H_
#define _OD_GIFILL_H_

#include "RxObject.h"
#include "HatchPattern.h"
#include "UInt8Array.h"

#include "TD_PackPush.h"

/** \details
    This class is a base class for boundary filling definitions.

    <group OdGi_Classes>
*/
class FIRSTDLL_EXPORT OdGiFill : public OdRxObject
{
  protected:
    double m_dDeviation;
  public:
    ODRX_DECLARE_MEMBERS(OdGiFill);
    OdGiFill();

    double deviation() const;
    void setDeviation(double dDeviation);

    virtual void copyFrom(const OdRxObject* pSource);

    virtual bool operator ==(const OdGiFill& fill) const;
    virtual bool operator !=(const OdGiFill& fill) const;

    virtual void saveBytes(OdUInt8Array &bytes) const;
    virtual void loadBytes(const OdUInt8 *pBytes);

    static OdSmartPtr<OdGiFill> loadFill(const OdUInt8 *pBytes);
  protected:
    void pushDbl(OdUInt8Array &bytes, double dDbl) const;
    void pushInt(OdUInt8Array &bytes, OdUInt32 nInt) const;
    void popDbl(const OdUInt8 *&pBytes, double &dDbl) const;
    void popInt(const OdUInt8 *&pBytes, OdUInt32 &nInt) const;
};

/** \details
    This template class is a specialization of the OdSmartPtr class for OdGiFill object pointers.
*/
typedef OdSmartPtr<OdGiFill> OdGiFillPtr;

inline
OdGiFill::OdGiFill()
  : m_dDeviation(0.0)
{ }

inline
double OdGiFill::deviation() const
{
  return m_dDeviation;
}

inline
void OdGiFill::setDeviation(double dDeviation)
{
  m_dDeviation = dDeviation;
}

inline
void OdGiFill::copyFrom(const OdRxObject* pSource)
{
  OdGiFillPtr pSrcFill = OdGiFill::cast(pSource);
  if (!pSrcFill.isNull())
    setDeviation(pSrcFill->deviation());
  else
    throw OdError(eNotApplicable);
}

inline
bool OdGiFill::operator ==(const OdGiFill& fill) const
{
  return (isA() == fill.isA()) && OdEqual(deviation(), fill.deviation());
}

inline
bool OdGiFill::operator !=(const OdGiFill& fill) const
{
  return (isA() != fill.isA()) || !OdEqual(deviation(), fill.deviation());
}

inline
void OdGiFill::saveBytes(OdUInt8Array &bytes) const
{
  bytes.push_back(0);
  pushDbl(bytes, m_dDeviation);
}

inline
void OdGiFill::loadBytes(const OdUInt8 *pBytes)
{
  if (*pBytes++ != 0)
    throw OdError(eInvalidInput);
  popDbl(pBytes, m_dDeviation);
}

inline
void OdGiFill::pushDbl(OdUInt8Array &bytes, double dDbl) const
{
  OdUInt8 nBytes[sizeof(double)];
  ::memcpy(nBytes, &dDbl, sizeof(double));
  bytes.insert(bytes.end(), nBytes, nBytes + sizeof(double));
}

inline
void OdGiFill::pushInt(OdUInt8Array &bytes, OdUInt32 nInt) const
{
  OdUInt8 nBytes[sizeof(OdUInt32)];
  ::memcpy(nBytes, &nInt, sizeof(OdUInt32));
  bytes.insert(bytes.end(), nBytes, nBytes + sizeof(OdUInt32));
}

inline
void OdGiFill::popDbl(const OdUInt8 *&pBytes, double &dDbl) const
{
  ::memcpy(&dDbl, pBytes, sizeof(double));
  pBytes += sizeof(double);
}

inline
void OdGiFill::popInt(const OdUInt8 *&pBytes, OdUInt32 &nInt) const
{
  ::memcpy(&nInt, pBytes, sizeof(OdUInt32));
  pBytes += sizeof(OdUInt32);
}

/** \details
    This class is a specialtion of OdGiFill for hatch pattern type of filling.

    <group OdGi_Classes>
*/
class FIRSTDLL_EXPORT OdGiHatchPattern : public OdGiFill
{
  protected:
    OdHatchPattern m_aHatchPattern;
  public:
    ODRX_DECLARE_MEMBERS(OdGiHatchPattern);
    OdGiHatchPattern();

    const OdHatchPattern &patternLines() const;
    OdHatchPattern &patternLines();
    void setPatternLines(const OdHatchPattern &aHatchPattern);

    virtual void copyFrom(const OdRxObject* pSource);

    virtual bool operator ==(const OdGiFill& fill) const;
    virtual bool operator !=(const OdGiFill& fill) const;

    virtual void saveBytes(OdUInt8Array &bytes) const;
    virtual void loadBytes(const OdUInt8 *pBytes);
};

/** \details
    This template class is a specialization of the OdSmartPtr class for OdGiHatchPattern object pointers.
*/
typedef OdSmartPtr<OdGiHatchPattern> OdGiHatchPatternPtr;

inline
OdGiHatchPattern::OdGiHatchPattern()
  : OdGiFill()
{ }

inline
const OdHatchPattern &OdGiHatchPattern::patternLines() const
{
  return m_aHatchPattern;
}

inline
OdHatchPattern &OdGiHatchPattern::patternLines()
{
  return m_aHatchPattern;
}

inline
void OdGiHatchPattern::setPatternLines(const OdHatchPattern &aHatchPattern)
{
  m_aHatchPattern = aHatchPattern;
}

inline
void OdGiHatchPattern::copyFrom(const OdRxObject* pSource)
{
  OdGiHatchPatternPtr pSrcFill = OdGiHatchPattern::cast(pSource);
  if (!pSrcFill.isNull())
  {
    setPatternLines(pSrcFill->patternLines());
    OdGiFill::copyFrom(pSource);
  }
  else
    throw OdError(eNotApplicable);
}

inline
bool OdGiHatchPattern::operator ==(const OdGiFill& fill) const
{
  if (isA() == fill.isA())
  {
    if (OdEqual(deviation(), fill.deviation()))
    {
      const OdGiHatchPattern *pSecond = static_cast<const OdGiHatchPattern*>(&fill);
      if (patternLines().size() == pSecond->patternLines().size())
      {
        for (OdUInt32 nPat = 0; nPat < patternLines().size(); nPat++)
        {
          const OdHatchPatternLine &pl1 = patternLines().getPtr()[nPat];
          const OdHatchPatternLine &pl2 = pSecond->patternLines().getPtr()[nPat];
          if (!OdEqual(pl1.m_dLineAngle, pl2.m_dLineAngle) ||
              !OdEqual(pl1.m_basePoint.x, pl2.m_basePoint.x) || !OdEqual(pl1.m_basePoint.y, pl2.m_basePoint.y) ||
              !OdEqual(pl1.m_patternOffset.x, pl2.m_patternOffset.x) || !OdEqual(pl1.m_patternOffset.y, pl2.m_patternOffset.y) ||
              pl1.m_dashes.size() != pl2.m_dashes.size())
            return false;
          for (OdUInt32 nDash = 0; nDash < pl1.m_dashes.size(); nDash++)
          {
            if (!OdEqual(pl1.m_dashes.getPtr()[nDash], pl2.m_dashes.getPtr()[nDash]))
              return false;
          }
        }
        return true;
      }
    }
  }
  return false;
}

inline
bool OdGiHatchPattern::operator !=(const OdGiFill& fill) const
{
  return !operator ==(fill);
}

inline
void OdGiHatchPattern::saveBytes(OdUInt8Array &bytes) const
{
  bytes.push_back(1);
  pushInt(bytes, m_aHatchPattern.size());
  for (OdUInt32 nPat = 0; nPat < m_aHatchPattern.size(); nPat++)
  {
    const OdHatchPatternLine &pl = m_aHatchPattern.getPtr()[nPat];
    pushDbl(bytes, pl.m_dLineAngle);
    pushDbl(bytes, pl.m_basePoint.x); pushDbl(bytes, pl.m_basePoint.y);
    pushDbl(bytes, pl.m_patternOffset.x); pushDbl(bytes, pl.m_patternOffset.y);
    pushInt(bytes, pl.m_dashes.size());
    for (OdUInt32 nDash = 0; nDash < pl.m_dashes.size(); nDash++)
      pushDbl(bytes, pl.m_dashes.getPtr()[nDash]);
  }
  OdGiFill::saveBytes(bytes);
}

inline
void OdGiHatchPattern::loadBytes(const OdUInt8 *pBytes)
{
  if (*pBytes++ != 1)
    throw OdError(eInvalidInput);
  OdUInt32 nPats = 0; popInt(pBytes, nPats);
  m_aHatchPattern.resize(nPats);
  for (OdUInt32 nPat = 0; nPat < nPats; nPat++)
  {
    OdHatchPatternLine &pl = m_aHatchPattern[nPat];
    popDbl(pBytes, pl.m_dLineAngle);
    popDbl(pBytes, pl.m_basePoint.x); popDbl(pBytes, pl.m_basePoint.y);
    popDbl(pBytes, pl.m_patternOffset.x); popDbl(pBytes, pl.m_patternOffset.y);
    OdUInt32 nDashes = 0; popInt(pBytes, nDashes);
    pl.m_dashes.resize(nDashes);
    for (OdUInt32 nDash = 0; nDash < nDashes; nDash++)
      popDbl(pBytes, pl.m_dashes[nDash]);
  }
  OdGiFill::loadBytes(pBytes);
}

inline
OdSmartPtr<OdGiFill> OdGiFill::loadFill(const OdUInt8 *pBytes)
{
  OdGiFillPtr pObj;
  switch (*pBytes)
  {
    case 0: pObj = OdGiFill::createObject(); break;
    case 1: pObj = OdGiHatchPattern::createObject(); break;
  }
  if (!pObj.isNull())
    pObj->loadBytes(pBytes);
  return pObj;
}

#include "TD_PackPop.h"

#endif //_OD_GIFILL_H_