/******************************************************************************
**  libDXFrw - Library to read/write DXF files (ascii & binary)              **
**                                                                           **
**  Copyright (C) 2011-2015 José F. Soriano, rallazz@gmail.com               **
**                                                                           **
**  This library is free software, licensed under the terms of the GNU       **
**  General Public License as published by the Free Software Foundation,     **
**  either version 2 of the License, or (at your option) any later version.  **
**  You should have received a copy of the GNU General Public License        **
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.    **
******************************************************************************/

#ifndef DRW_BASE_H
#define DRW_BASE_H

#define DRW_VERSION "0.6.3"

#include <string>
#include <list>
#include <cmath>

#ifdef DRW_ASSERTS
# define drw_assert(a) assert(a)
#else
# define drw_assert(a)
#endif

#define UTF8STRING std::string
#define DRW_UNUSED(x) (void)x

#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
#  define DRW_WIN
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
#    define DRW_WIN
#elif defined(__MWERKS__) && defined(__INTEL__)
#  define DRW_WIN
#else
#  define DRW_POSIX
#endif

#define M_PIx2 6.283185307179586 // 2*PI
#define ARAD 57.29577951308232

typedef signed char dint8;              /* 8 bit signed */
typedef signed short dint16;            /* 16 bit signed */
typedef signed int dint32;              /* 32 bit signed */
typedef long long int dint64;           /* 64 bit signed */

typedef unsigned char duint8;           /* 8 bit unsigned */
typedef unsigned short duint16;         /* 16 bit unsigned */
typedef unsigned int duint32;           /* 32 bit unsigned */
typedef unsigned long long int duint64; /* 64 bit unsigned */

typedef float dfloat32;                 /* 32 bit floating point */
typedef double ddouble64;               /* 64 bit floating point */
typedef long double ddouble80;          /* 80 bit floating point */


namespace DRW
{

//! Version numbers for the DXF Format.
  enum Version
  {
    UNKNOWNV,     //!< UNKNOWN VERSION.
    AC1006,       //!< R10.
    AC1009,       //!< R11 & R12.
    AC1012,       //!< R13.
    AC1014,       //!< R14.
    AC1015,       //!< ACAD 2000.
    AC1018,       //!< ACAD 2004.
    AC1021,       //!< ACAD 2007.
    AC1024,       //!< ACAD 2010.
    AC1027        //!< ACAD 2013.
  };

  enum error
  {
    BAD_NONE,             //!< No error.
    BAD_UNKNOWN,          //!< UNKNOWN.
    BAD_OPEN,             //!< Error opening file.
    BAD_VERSION,          //!< Unsupported version.
    BAD_READ_METADATA,    //!< Error reading matadata.
    BAD_READ_FILE_HEADER, //!< Error in file header read process.
    BAD_READ_HEADER,      //!< Error in header vars read process.
    BAD_READ_HANDLES,     //!< Error in object map read process.
    BAD_READ_CLASSES,     //!< Error in classes read process.
    BAD_READ_TABLES,      //!< Error in tables read process.
    BAD_READ_BLOCKS,      //!< Error in block read process.
    BAD_READ_ENTITIES,    //!< Error in entities read process.
    BAD_READ_OBJECTS      //!< Error in objects read process.
  };

  enum DBG_LEVEL
  {
    none,
    debug
  };

  //! Special codes for colors
  enum ColorCodes
  {
    ColorByLayer = 256,
    ColorByBlock = 0
  };

  //! Spaces
  enum Space
  {
    ModelSpace = 0,
    PaperSpace = 1
  };

  //! Special kinds of handles
  enum HandleCodes
  {
    NoHandle = 0
  };

  //! Shadow mode
  enum ShadowMode
  {
    CastAndReceiveShadows = 0,
    CastShadows = 1,
    ReceiveShadows = 2,
    IgnoreShadows = 3
  };

  //! Special kinds of materials
  enum MaterialCodes
  {
    MaterialByLayer = 0
  };

  //! Special kinds of plot styles
  enum PlotStyleCodes
  {
    DefaultPlotStyle = 0
  };

  //! Special kinds of transparencies
  enum TransparencyCodes
  {
    Opaque = 0,
    Transparent = -1
  };

} // namespace DRW

//! Class to handle 3D coordinate point
/*!
*  Class to handle 3D coordinate point
*  @author Rallaz
*/
class DRW_Coord
{
  public:
    DRW_Coord(): x( 0 ), y( 0 ), z( 0 ) {}
    DRW_Coord( double ix, double iy, double iz ): x( ix ), y( iy ), z( iz ) {}

    //! < convert to unitary vector
    void unitize()
    {
      double dist;
      dist = std::sqrt( x * x + y * y + z * z );
      if ( dist > 0.0 )
      {
        x = x / dist;
        y = y / dist;
        z = z / dist;
      }
    }

  public:
    double x;
    double y;
    double z;
};


//! Class to handle vertex
/*!
*  Class to handle vertex for lwpolyline entity
*  @author Rallaz
*/
class DRW_Vertex2D
{
  public:
    DRW_Vertex2D(): x( 0 ), y( 0 ), stawidth( 0 ), endwidth( 0 ), bulge( 0 ) {}

    DRW_Vertex2D( double sx, double sy, double b ): x( sx ), y( sy ), stawidth( 0 ), endwidth( 0 ), bulge( b ) {}

  public:
    double x;         //!< X coordinate, code 10
    double y;         //!< Y coordinate, code 20
    double stawidth;  //!< Start width, code 40
    double endwidth;  //!< End width, code 41
    double bulge;     //!< Bulge, code 42
};


//! Class to handle header vars
/*!
*  Class to handle header vars
*  @author Rallaz
*/
class DRW_Variant
{
  public:
    enum TYPE
    {
      STRING,
      INTEGER,
      DOUBLE,
      COORD,
      INVALID
    };
//TODO: add INT64 support
    DRW_Variant(): sdata( std::string() ), vdata(), content( 0 ), vType( INVALID ), vCode( 0 ) {}

    DRW_Variant( int c, dint32 i ): sdata( std::string() ), vdata(), content( i ), vType( INTEGER ), vCode( c ) {}

    DRW_Variant( int c, duint32 i ): sdata( std::string() ), vdata(), content( static_cast<dint32>( i ) ), vType( INTEGER ), vCode( c ) {}

    DRW_Variant( int c, double d ): sdata( std::string() ), vdata(), content( d ), vType( DOUBLE ), vCode( c ) {}

    DRW_Variant( int c, UTF8STRING s ): sdata( s ), vdata(), content( &sdata ), vType( STRING ), vCode( c ) {}

    DRW_Variant( int c, DRW_Coord crd ): sdata( std::string() ), vdata( crd ), content( &vdata ), vType( COORD ), vCode( c ) {}

    DRW_Variant( const DRW_Variant &d ): sdata( d.sdata ), vdata( d.vdata ), content( d.content ), vType( d.vType ), vCode( d.vCode )
    {
      if ( d.vType == COORD )
        content.v = &vdata;
      if ( d.vType == STRING )
        content.s = &sdata;
    }

    ~DRW_Variant()
    {
    }

    void addString( int c, UTF8STRING s ) {vType = STRING; sdata = s; content.s = &sdata; vCode = c;}
    void addInt( int c, int i ) {vType = INTEGER; content.i = i; vCode = c;}
    void addDouble( int c, double d ) {vType = DOUBLE; content.d = d; vCode = c;}
    void addCoord( int c, DRW_Coord v ) {vType = COORD; vdata = v; content.v = &vdata; vCode = c;}
    void setCoordX( double d ) { if ( vType == COORD ) vdata.x = d;}
    void setCoordY( double d ) { if ( vType == COORD ) vdata.y = d;}
    void setCoordZ( double d ) { if ( vType == COORD ) vdata.z = d;}
    enum TYPE type() { return vType;}
    int code() { return vCode;}            //!< Returns dxf code of this value

  private:
    std::string sdata;
    DRW_Coord vdata;

  private:
    union DRW_VarContent
    {
      UTF8STRING *s; //skip-init-check
      dint32 i;
      double d;
      DRW_Coord *v; //skip-init-check

      DRW_VarContent( UTF8STRING *sd ): s( sd ) {}
      DRW_VarContent( dint32 id ): i( id ) {}
      DRW_VarContent( double dd ): d( dd ) {}
      DRW_VarContent( DRW_Coord *vd ): v( vd ) {}
    };

  public:
    DRW_VarContent content;
  private:
    enum TYPE vType;
    int vCode;            //!< Dxf code of this value

};

//! Class to handle dwg handles
/*!
*  Class to handle dwg handles
*  @author Rallaz
*/
class dwgHandle
{
  public:
    dwgHandle(): code( 0 ), size( 0 ), ref( 0 ) {}

    ~dwgHandle() {}
    duint8 code;
    duint8 size;
    duint32 ref;
};

//! Class to convert between line width and integer
/*!
*  Class to convert between line width and integer
*  verifing valid values, if value is not valid
*  returns widthDefault.
*  @author Rallaz
*/
class DRW_LW_Conv
{
  public:
    enum lineWidth
    {
      width00 = 0,       //!< 0.00mm (dxf 0)
      width01 = 1,       //!< 0.05mm (dxf 5)
      width02 = 2,       //!< 0.09mm (dxf 9)
      width03 = 3,       //!< 0.13mm (dxf 13)
      width04 = 4,       //!< 0.15mm (dxf 15)
      width05 = 5,       //!< 0.18mm (dxf 18)
      width06 = 6,       //!< 0.20mm (dxf 20)
      width07 = 7,       //!< 0.25mm (dxf 25)
      width08 = 8,       //!< 0.30mm (dxf 30)
      width09 = 9,       //!< 0.35mm (dxf 35)
      width10 = 10,      //!< 0.40mm (dxf 40)
      width11 = 11,      //!< 0.50mm (dxf 50)
      width12 = 12,      //!< 0.53mm (dxf 53)
      width13 = 13,      //!< 0.60mm (dxf 60)
      width14 = 14,      //!< 0.70mm (dxf 70)
      width15 = 15,      //!< 0.80mm (dxf 80)
      width16 = 16,      //!< 0.90mm (dxf 90)
      width17 = 17,      //!< 1.00mm (dxf 100)
      width18 = 18,      //!< 1.06mm (dxf 106)
      width19 = 19,      //!< 1.20mm (dxf 120)
      width20 = 20,      //!< 1.40mm (dxf 140)
      width21 = 21,      //!< 1.58mm (dxf 158)
      width22 = 22,      //!< 2.00mm (dxf 200)
      width23 = 23,      //!< 2.11mm (dxf 211)
      widthByLayer = 29, //!< By layer (dxf -1)
      widthByBlock = 30, //!< By block (dxf -2)
      widthDefault = 31  //!< By default (dxf -3)
    };

    static int lineWidth2dxfInt( enum lineWidth lw )
    {
      switch ( lw )
      {
        case widthByLayer:
          return -1;
        case widthByBlock:
          return -2;
        case widthDefault:
          return -3;
        case width00:
          return 0;
        case width01:
          return 5;
        case width02:
          return 9;
        case width03:
          return 13;
        case width04:
          return 15;
        case width05:
          return 18;
        case width06:
          return 20;
        case width07:
          return 25;
        case width08:
          return 30;
        case width09:
          return 35;
        case width10:
          return 40;
        case width11:
          return 50;
        case width12:
          return 53;
        case width13:
          return 60;
        case width14:
          return 70;
        case width15:
          return 80;
        case width16:
          return 90;
        case width17:
          return 100;
        case width18:
          return 106;
        case width19:
          return 120;
        case width20:
          return 140;
        case width21:
          return 158;
        case width22:
          return 200;
        case width23:
          return 211;
        default:
          break;
      }
      return -3;
    }

    static int lineWidth2dwgInt( enum lineWidth lw )
    {
      return static_cast<int>( lw );
    }

    static enum lineWidth dxfInt2lineWidth( int i )
    {
      if ( i < 0 )
      {
        if ( i == -1 )
          return widthByLayer;
        else if ( i == -2 )
          return widthByBlock;
        else if ( i == -3 )
          return widthDefault;
      }
      else if ( i < 3 )
      {
        return width00;
      }
      else if ( i < 7 )
      {
        return width01;
      }
      else if ( i < 11 )
      {
        return width02;
      }
      else if ( i < 14 )
      {
        return width03;
      }
      else if ( i < 16 )
      {
        return width04;
      }
      else if ( i < 19 )
      {
        return width05;
      }
      else if ( i < 22 )
      {
        return width06;
      }
      else if ( i < 27 )
      {
        return width07;
      }
      else if ( i < 32 )
      {
        return width08;
      }
      else if ( i < 37 )
      {
        return width09;
      }
      else if ( i < 45 )
      {
        return width10;
      }
      else if ( i < 52 )
      {
        return width11;
      }
      else if ( i < 57 )
      {
        return width12;
      }
      else if ( i < 65 )
      {
        return width13;
      }
      else if ( i < 75 )
      {
        return width14;
      }
      else if ( i < 85 )
      {
        return width15;
      }
      else if ( i < 95 )
      {
        return width16;
      }
      else if ( i < 103 )
      {
        return width17;
      }
      else if ( i < 112 )
      {
        return width18;
      }
      else if ( i < 130 )
      {
        return width19;
      }
      else if ( i < 149 )
      {
        return width20;
      }
      else if ( i < 180 )
      {
        return width21;
      }
      else if ( i < 205 )
      {
        return width22;
      }
      else
      {
        return width23;
      }
      //default by default
      return widthDefault;
    }

    static enum lineWidth dwgInt2lineWidth( int i )
    {
      if ( ( i > -1 && i < 24 ) || ( i > 28 && i < 32 ) )
      {
        return static_cast<lineWidth>( i );
      }
      //default by default
      return widthDefault;
    }
};

#endif

// EOF
