#ifndef VECTOR_HPP_
#define VECTOR_HPP_

using namespace std;

/*********************************************** includes ***********************************/

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_multimin.h>

#include <memory>

#include "defs.hpp"

/********************************************** declarations *******************************/

/** Single vector.
 * basically, just a x[3] but with helpful functions
 */
class Vector {
protected:
  // this struct is used to indicate calls to the Baseconstructor from inside vectors.
  struct Baseconstructor{};
public:

  Vector();
  Vector(const double x1, const double x2, const double x3);
  Vector(const Vector& src);
  virtual ~Vector();

  // Method implemented by forwarding to the Representation

  virtual double DistanceSquared(const Vector &y) const;
  virtual double DistanceToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const;
  virtual double PeriodicDistance(const Vector &y, const double * const cell_size) const;
  virtual double PeriodicDistanceSquared(const Vector &y, const double * const cell_size) const;
  virtual double ScalarProduct(const Vector &y) const;
  virtual double Angle(const Vector &y) const;
  virtual bool IsZero() const;
  virtual bool IsOne() const;
  virtual bool IsNormalTo(const Vector &normal) const;
  virtual bool IsEqualTo(const Vector &a) const;

  virtual void AddVector(const Vector &y);
  virtual void SubtractVector(const Vector &y);
  virtual void VectorProduct(const Vector &y);
  virtual void ProjectOntoPlane(const Vector &y);
  virtual void ProjectIt(const Vector &y);
  virtual Vector Projection(const Vector &y) const;
  virtual void Mirror(const Vector &x);
  virtual void ScaleAll(const double *factor);
  virtual void Scale(const double factor);
  virtual void MatrixMultiplication(const double * const M);
  virtual bool InverseMatrixMultiplication(const double * const M);
  virtual void KeepPeriodic(const double * const matrix);
  virtual bool GetOneNormalVector(const Vector &x1);
  virtual bool MakeNormalTo(const Vector &y1);
  virtual bool IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const;
  virtual void WrapPeriodically(const double * const M, const double * const Minv);

  // Accessors ussually come in pairs... and sometimes even more than that
  virtual double& operator[](size_t i);
  virtual const double& operator[](size_t i) const;
  double& at(size_t i);
  const double& at(size_t i) const;

  // Assignment operator
  virtual Vector &operator=(const Vector& src);

  // Access to internal structure
  virtual double* get();

  // Methods that are derived directly from other methods
  double Distance(const Vector &y) const;
  double Norm() const;
  double NormSquared() const;
  void Normalize();
  void Zero();
  void One(const double one);
  void LinearCombinationOfVectors(const Vector &x1, const Vector &x2, const Vector &x3, const double * const factors);

  // operators for mathematical operations
  bool operator==(const Vector& b) const;
  const Vector& operator+=(const Vector& b);
  const Vector& operator-=(const Vector& b);
  Vector const operator+(const Vector& b) const;
  Vector const operator-(const Vector& b) const;

protected:
  typedef std::auto_ptr<Vector> rep_ptr;
  Vector(Baseconstructor);
  Vector(Baseconstructor,const Vector*);
  static Vector VecFromRep(const Vector*);

private:
  // method used for protection, i.e. to avoid infinite recursion
  // when our internal rep becomes messed up
  virtual bool isBaseClass() const;
  virtual Vector* clone() const;
  // this is used to represent the vector internally
  rep_ptr rep;

};

ostream & operator << (ostream& ost, const Vector &m);
const Vector& operator*=(Vector& a, const double m);
Vector const operator*(const Vector& a, const double m);
Vector const operator*(const double m, const Vector& a);

#endif /*VECTOR_HPP_*/