/**
  * @RDE_HEADER@
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "primitive.h"

#include <cmath>
#include <cstdlib>
#include "symbol_reader.h"
#include <NGLLogger/NGLLoggerBootstrap.h>


namespace SymbologyXML
{

unsigned int Primitive::_idCount = 0;


Primitive::Primitive(t_primitive type)
  : logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("AdvSymbologyXML.Primitive"))
  , _id(++_idCount)
  , _type(type)
{
  TRACE_LOG(logger) << LOGFUNCTION ;
  TRACE_LOG(logger) << "END " << LOGFUNCTION ;
} // Primitive::Primitive(t_primitive type)


Primitive::Primitive(const Primitive& other)
  : logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("AdvSymbologyXML.Primitive"))
{
  TRACE_LOG(logger) << LOGFUNCTION ;

  ++_idCount;
  _id = _idCount;          // _id is NOT copied ( see operator= )
  *this = other;    // _id is NOT copied ( see operator= )

  TRACE_LOG(logger) << "END " << LOGFUNCTION ;
} // Primitive::Primitive(const Primitive& other)


Primitive& Primitive::operator=(const Primitive& other)
{
  DEBUG_LOG(logger) << LOGFUNCTION ;

  ////  _id = other._id; Do NOT have identical _id
  _type       = other._type;
  _valid      = other._valid;
  _points     = other._points;
  _fill       = other._fill;
  _lineWidth  = other._lineWidth;
  _lineStyle  = other._lineStyle;
  _closed     = other._closed;
  _startAngle = other._startAngle;
  _extent     = other._extent;
  _rotation   = other._rotation;
  _transform  = other._transform;
  _color      = other._color;
  _iconId     = other._iconId;
  _iconType   = other._iconType;
  _text       = other._text;
  _position   = other._position;
  _rectpos    = other._rectpos;
  _scalemode  = other._scalemode;
  _font       = other._font;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return *this;
} // Primitive& Primitive::operator=(const Primitive& other)


Primitive::~Primitive() {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // Primitive::~Primitive()


bool Primitive::operator==(const Primitive& other) const {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if ( _id == other._id ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return true;
  }
  bool result = true;
  result &= _type == other._type;
  result &= _valid == other._valid;
  result &= _points == other._points;
  result &= _fill == other._fill;
  result &= _lineWidth == other._lineWidth;
  result &= _lineStyle == other._lineStyle;
  result &= _closed == other._closed;
  result &= _startAngle == other._startAngle;
  result &= _extent == other._extent;
  result &= _rotation == other._rotation;
  result &= _transform == other._transform;
  result &= _color == other._color;
  result &= _iconId == other._iconId;
  result &= _iconType == other._iconType;
  result &= _position == other._position;
  result &= _rectpos == other._rectpos;
  result &= _scalemode == other._scalemode;
  result &= _text == other._text;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return result;
} // bool Primitive::operator==(const Primitive& other)


bool Primitive::operator!=(const Primitive& other) const {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return !(*this == other);
} // bool Primitive::operator!=(const Primitive& other)


void Primitive::setFill(bool flag) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  _fill = flag & (_type != LINE);

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::setFill(bool flag)


void Primitive::setClosed(bool flag) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  _closed = flag;
  if ( (_type == ELLIPSE) && _closed ) {
    _extent = 360.0;
  }

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::setClosed(bool flag)


bool Primitive::setPoints(const QPolygonF &pointList) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  bool ok = true;
  switch (_type) {
    case ELLIPSE:
    case LINE:
    case RECT:
    case ICON:
    case TEXT:
      if ( pointList.size() != 2 ) {
        ok = false;
      }
      break;
    case POLYGON:
      if ( pointList.size() < 3 ) {
        ok = false;
      }
      break;
    default: _valid = false;
  }

  _points.clear();
  _points = pointList;
  _valid = ok;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return _valid;
} // bool Primitive::setPoints(QList<Point> pointList)



void Primitive::setLineWidth(double width) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  _lineWidth = width;
  _valid = (width > 0.0);

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::setLineWidth(double width)


void Primitive::setLineStyle(t_linestyle style) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  _lineStyle = style;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::setLineStyle(t_linestyle style)


void Primitive::setStartAngle(double start) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if (_type == ELLIPSE) {
    _startAngle = fmod(start, 360.0);
  }

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::setStartAngle(double start)


void Primitive::setExtent(double extent) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if (_type == ELLIPSE) {
    if ( extent < -360.0 ) {
      _extent = -360.0;
    } else if ( extent > 360.0 ) {
      _extent = 360.0;
    } else {
      _extent = extent;
    }
  }

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::setExtent(double extent)


bool Primitive::getBoundingBox(double &x0, double &y0, double &x1, double &y1, bool ignoreEllipseType) const
{
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if ( !isValid() ) {
    WARNING_LOG(logger) << "Primitive::getBoundingBox - primitive not valid";
    return false;
  }

  const QRectF br = _points.boundingRect();

  // Check for open Ellipse
  if ( (_type == ELLIPSE) && !_closed && !ignoreEllipseType) {
    return getBoundingBoxEllipse(x0, y0,
                                 x1, y1,
                                 br.x(), br.y(),
                                 br.x() + br.width(), br.y() + br.height());
  }
  x0 = br.x();
  y0 = br.y();
  x1 = br.x() + br.width();
  y1 = br.y() + br.height();

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
  return true;
} // void Primitive::getBoundingBox(double* x0, ...) const


void Primitive::getCenter(double &x, double &y) const {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  double x0, y0, x1, y1;
  if (getBoundingBox(x0, y0, x1, y1, true))
  {
    x = (x0+x1)/2.0;
    y = (y0+y1)/2.0;
  }
  else
  {
    x = y = 0;
  }

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::getCenter(double* x, double* y) const


void Primitive::move(const QPointF &diff) {
    _points.translate(diff);
}

void Primitive::scale(double factorX, double factorY) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if ( (factorX <= 0.0) || (factorY <= 0.0) ) {
    // Factor too small, ignore
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return;
  }

  // Get bounding box center
  double x0, x1, y0, y1;
  if (!getBoundingBox(x0, y0, x1, y1))
    return;
  double cx = (x0+x1)/2.0;
  double cy = (y0+y1)/2.0;

  // Transform all points to origin and multiply with factor
  for (int i = 0; i < _points.size(); ++i) {
    double tmpx = (_points.at(i)).x() - cx;
    double tmpy = (_points.at(i)).y() - cy;
    tmpx = (tmpx*factorX)+cx;
    tmpy = (tmpy*factorY)+cy;
    _points[i].setX(tmpx);
    _points[i].setY(tmpy);
  }

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::scale(double factorX, double factorY)

void Primitive::setText(const QString &text) {
    _text = text;
}

QString Primitive::text() const {
    return _text;
}

void Primitive::setIcon(int id) {
    _iconId = id;
}

int Primitive::icon() const {
    return _iconId;
}

void Primitive::setIconType(SymbolTypes::t_icon_type iconType) {
    _iconType = iconType;
}

SymbolTypes::t_icon_type Primitive::iconType() const {
    return _iconType;
}

void Primitive::setPosition(SymbolTypes::t_sector_position position) {
  _position = position;
}

SymbolTypes::t_sector_position Primitive::position() const {
  return _position;
}

void Primitive::setRectpos(SymbolTypes::t_sector_rectpos rectpos) {
  _rectpos = rectpos;
}

SymbolTypes::t_sector_rectpos Primitive::rectpos() const {
  return _rectpos;
}

void Primitive::setScalemode(Primitive::t_scalemode scalemode)
{
  _scalemode = scalemode;
}

Primitive::t_scalemode Primitive::scalemode() const
{
  return _scalemode;
}

QString Primitive::scalemode(Primitive::t_scalemode scalemode)
{
  QString ret;
  switch(scalemode) {
  case Scalemode_Undefined: ret = QStringLiteral("undefined"); break;
  case Scalemode_Proport:   ret = QStringLiteral("proport");   break;
  case Scalemode_Unproport: ret = QStringLiteral("unproport"); break;
  default:                  ret = QStringLiteral("undefined"); break;
  }
  return ret;
}

Primitive::t_scalemode Primitive::scalemode(const QString &scalemode)
{
  Primitive::t_scalemode ret = Scalemode_Undefined;
  if(scalemode == QStringLiteral("proport")) {
    ret = Scalemode_Proport;
  } else if(scalemode == QStringLiteral("unproport")) {
    ret = Scalemode_Unproport;
  }
  return ret;
}

void Primitive::setRotation(double angle) {
  DEBUG_LOG(logger) << LOGFUNCTION ;
  _rotation = fmod(angle, 360.0);
  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::setRotation(double angle)


bool Primitive::getBoundingBoxEllipse(double &x0, double &y0, double &x1, double &y1,
                                      double tx0, double ty0, double tx1, double ty1) const
{
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if ( !isValid() || (_type != ELLIPSE) ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return false;
  }

  double extent = closed()?360.0:_extent;

  QList<double> pointsX;
  QList<double> pointsY;
  double end = _startAngle+extent;

  // Add start/end-point
  double centerX = (tx0+tx1)/2.0;
  double centerY = (ty0+ty1)/2.0;

  double startX = cos(-_startAngle*2*M_PI/360.0);
  startX = centerX+(startX*(tx1-tx0)/2.0);

  double startY = sin(_startAngle*2*M_PI/360.0);
  startY = centerY+(startY*(ty1-ty0)/2.0);

  double endX = cos(-end*2*M_PI/360.0);
  endX = centerX+(endX*(tx1-tx0)/2.0);

  double endY = sin(end*2*M_PI/360.0);
  endY = centerY+(endY*(ty1-ty0)/2.0);

  pointsX.append(startX);
  pointsX.append(endX);
  pointsY.append(startY);
  pointsY.append(endY);

  // Check 0°, 90°, 180°, 270°
  if ( extent >= 0.0 ) {
    //  Counter-clockwise
    if ( ((_startAngle <=    0.0) && (end >=    0.0)) ||
         ((_startAngle <= -360.0) && (end >= -360.0)) ||
         ((_startAngle <=  360.0) && (end >=  360.0)) ||
         ((_startAngle <= -720.0) && (end >= -720.0)) ) {
      //  0°/-360°/360° is in
      pointsX.append(tx1);
    }
    //  Counter-clockwise
    if ( ((_startAngle <=   90.0) && (end >=   90.0)) ||
         ((_startAngle <= -270.0) && (end >= -270.0)) ||
         ((_startAngle <=  450.0) && (end >=  450.0)) ||
         ((_startAngle <= -630.0) && (end >= -630.0)) ) {
      //  90°/-270°/450° is in
      pointsY.append(ty1);
    }
    if ( ((_startAngle <=  180.0) && (end >=  180.0)) ||
         ((_startAngle <= -180.0) && (end >= -180.0)) ||
         ((_startAngle <=  540.0) && (end >=  540.0)) ||
         ((_startAngle <= -540.0) && (end >= -540.0)) ) {
      //  180°/-180°/540° is in
      pointsX.append(tx0);
    }
    if ( ((_startAngle <=  270.0) && (end >=  270.0)) ||
         ((_startAngle <=  -90.0) && (end >=  -90.0)) ||
         ((_startAngle <=  630.0) && (end >=  630.0)) ||
         ((_startAngle <= -450.0) && (end >= -450.0)) ) {
      //  270°/-90°/630° is in
      pointsY.append(ty0);
    }
  } else {
    //  Clockwise
    if ( ((_startAngle >=    0.0) && (end <=    0.0)) ||
         ((_startAngle >= -360.0) && (end <= -360.0)) ||
         ((_startAngle >=  360.0) && (end <=  360.0)) ||
         ((_startAngle >= -720.0) && (end <= -720.0)) ) {
      //  0°/-360°/360° is in
      pointsX.append(tx1);
    }
    if ( ((_startAngle >=   90.0) && (end <=   90.0)) ||
         ((_startAngle >= -270.0) && (end <= -270.0)) ||
         ((_startAngle >=  450.0) && (end <=  450.0)) ||
         ((_startAngle >= -630.0) && (end <= -630.0)) ) {
      //  90°/-270°/450° is in
      pointsY.append(ty1);
    }
    if ( ((_startAngle >=  180.0) && (end <=  180.0)) ||
         ((_startAngle >= -180.0) && (end <= -180.0)) ||
         ((_startAngle >=  540.0) && (end <=  540.0)) ||
         ((_startAngle >= -540.0) && (end <= -540.0)) ) {
      //  180°/-180°/540° is in
      pointsX.append(tx0);
   }
    if ( ((_startAngle >=  270.0) && (end <=  270.0)) ||
         ((_startAngle >=  -90.0) && (end <=  -90.0)) ||
         ((_startAngle >=  630.0) && (end <=  630.0)) ||
         ((_startAngle >= -450.0) && (end <= -450.0)) ) {
      //  270°/-90°/630° is in
      pointsY.append(ty0);
    }
  }

  double lx0 = pointsX.at(0);
  double ly0 = pointsY.at(0);
  double lx1 = lx0;
  double ly1 = ly0;
  // Find min/max for X/Y
  for (int i = 1; i < pointsX.size(); ++i) {
    if ( pointsX.at(i) < lx0 ) {
      lx0 = pointsX.at(i);
    } else if ( pointsX.at(i) > lx1 ) {
      lx1 = pointsX.at(i);
    }
  }
  for (int i = 1; i < pointsY.size(); ++i) {
    if ( pointsY.at(i) < ly0 ) {
      ly0 = pointsY.at(i);
    } else if ( pointsY.at(i) > ly1 ) {
      ly1 = pointsY.at(i);
    }
  }

  x0 = lx0;
  y0 = ly0;
  x1 = lx1;
  y1 = ly1;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;

  return true;
} // void Primitive::getBoundingBoxEllipse(double* x0, ...) const


void Primitive::rotate() {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  // Ellipse needs special handling and temporary hiding of its type
  bool isEllipseType = (_type == ELLIPSE);

  // Get center of bounding box
  double x0, y0, x1, y1, cx, cy;
  if ( isEllipseType ) { _type = LINE; }
  if (!getBoundingBox(x0, y0, x1, y1))
    return;
  if ( isEllipseType ) { _type = ELLIPSE; }
  cx = (x0+x1)/2.0;
  cy = (y0+y1)/2.0;

  if ( (_type == RECT) && ( fmod(_rotation, 90.0) != 0.0 ) ) {
    // Convert Rectangle to Polygon, because we need to rotate all four points
    // This does not change the bbox, so its okay, to do this here
    rectToPolygon();
  } else if ( _type == ELLIPSE ) {
    if ( fmod(_rotation, 90.0) == 0.0 ) {
      // Rotate ELLIPSE in multiple of 90°: Set the _startAngle to rotated
      // value and then rotate the defining points.
      // This does not change the bbox, so its okay, to do this here
      _startAngle = _startAngle+(fmod(_rotation, 360.0));
    } else {

      const double temp = std::abs(_extent);
      ellipseToPolygon(lrint(temp/2));
    }
  }

  // Rotate all points
  for (int i = 0; i < _points.size(); ++i) {
    double px = _points.at(i).x();
    double py = _points.at(i).y();
    rotatePoint(px, py, cx, cy, &px, &py, _rotation);
    _points[i] = QPointF(px, py);
  }

  // Reset the rotation-property
  _rotation = 0.0;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::rotate()


void Primitive::ellipseToPolygon(unsigned int approxSteps) {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if ( _type != ELLIPSE ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return;
  }

  // Get the full Bounding Box
  _type = POLYGON;
  double x0, y0, x1, y1;
  if (!getBoundingBox(x0, y0, x1,y1))
    return;
  // Get center for translation of points
  double cx = (x0+x1)/2.0;
  double cy = (y0+y1)/2.0;
  // Get Bounding Box size for scaling
  double sx = (x1-x0)/2.0;
  double sy = (y1-y0)/2.0;

  _points.clear();
  unsigned int steps = (approxSteps>10)?approxSteps:10;
  if (steps > 20)
    steps = 20;
  double stepSize = _extent/(double)steps;
  for (unsigned int i = 0; i <= steps; ++i) {
    double stepAngle = _startAngle+(double)i*stepSize;
    double px, py;
    rotatePoint(1.0, 0.0, 0.0, 0.0, &px, &py, stepAngle);
    _points.append(QPointF(px*sx+cx, py*sy+cy));
  }

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::ellipseToPolygon(unsigned int approxSteps)


void Primitive::rectToPolygon() {
  DEBUG_LOG(logger) << LOGFUNCTION ;

  if ( _type != RECT ) {
    DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
    return;
  }

  QPolygonF points;
  points.append(_points.at(0));
  points.append(QPointF(_points.at(0).x(), _points.at(1).y()));
  points.append(_points.at(1));
  points.append(QPointF(_points.at(1).x(), _points.at(0).y()));
  _points = points;
  _type = POLYGON;
  _closed = true;

  DEBUG_LOG(logger) << "END " << LOGFUNCTION ;
} // void Primitive::rectToPolygon()


void Primitive::rotatePoint(double  px, double  py,
                            double  cx, double  cy,
                            double *rx, double *ry,
                            double angle) {
  // This is a static method, so no logging is used here

  // angle to rad
  double radAngle = ((2*M_PI)/360.0)*angle;

  // Translate
  double tx = px-cx;
  double ty = py-cy;
  // Rotate
  double nx = tx*cos(radAngle)-ty*sin(radAngle);
  double ny = tx*sin(radAngle)+ty*cos(radAngle);
  // Translate back and write result
  *rx = nx+cx;
  *ry = ny+cy;
} // void Primitive::rotatePoint(double px...)

}; // namespace SymbologyXML