/*
 * atom.hpp
 *
 *  Created on: Aug 3, 2009
 *      Author: heber
 */

#ifndef ATOM_HPP_
#define ATOM_HPP_

using namespace std;

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

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

#include <iostream>
#include <list>
#include <vector>

#include "atom_atominfo.hpp"
#include "atom_bondedparticle.hpp"
#include "atom_graphnode.hpp"
#include "atom_particleinfo.hpp"
#include "atom_trajectoryparticle.hpp"
#include "tesselation.hpp"

/****************************************** forward declarations *****************************/

class Vector;
class World;

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

/** Single atom.
 * Class incorporates position, type
 */
class atom : public TesselPoint, public TrajectoryParticle, public GraphNode, public BondedParticle, public virtual ParticleInfo, public virtual AtomInfo {
  friend atom* NewAtom();
  friend void  DeleteAtom(atom*);
  public:
    atom *previous; //!< previous atom in molecule list
    atom *next;     //!< next atom in molecule list
    atom *father;   //!< In many-body bond order fragmentations points to originating atom
    int *sort;      //!< sort criteria

  virtual atom *clone();

  bool OutputIndexed(ofstream * const out, const int ElementNo, const int AtomNo, const char *comment = NULL) const;
  bool OutputArrayIndexed(ofstream * const out, const int *ElementNo, int *AtomNo, const char *comment = NULL) const;
  bool OutputXYZLine(ofstream *out) const;
  bool OutputTrajectory(ofstream * const out, const int *ElementNo, int *AtomNo, const int step) const;
  bool OutputTrajectoryXYZ(ofstream * const out, const int step) const;
  void OutputMPQCLine(ofstream * const out, const Vector *center, int *AtomNo) const;

  void InitComponentNr();

  void EqualsFather ( const atom *ptr, const atom **res ) const;
  void CorrectFather();
  atom *GetTrueFather();
  bool Compare(const atom &ptr) const;

  double DistanceToVector(const Vector &origin) const;
  double DistanceSquaredToVector(const Vector &origin) const;
  bool IsInParallelepiped(const Vector offset, const double *parallelepiped) const;

  // getter and setter

  /**
   * returns the World that contains this atom.
   * Use this if you need to get the world without locking
   * the singleton for example.
   *
   */
  World *getWorld();
  void setWorld(World*);

  virtual int getId();
  virtual void setId(int);
  protected:
    /**
     * Protected constructor to ensure construction of atoms through the world.
     * see World::createAtom()
     */
    atom();

    /**
     * Protected copy-constructor to ensure construction of atoms by cloning.
     * see atom::clone()
     */
    atom(class atom *pointer);

    /**
     * Protected destructor to ensure destruction of atoms through the world.
     * see World::destroyAtom()
     */
    virtual ~atom();
  private:
    World* world;
    int id;
};

/**
 * internal method used by the world. Do not use if you don't know what you are doing.
 * You might get burned...
 * Use World::createAtom() instead.
 */
atom* NewAtom();

/**
* internal method used by the world. Do not use if you don't know what you are doing.
 * You might get burned...
 * Use World::destroyAtom() instead.
 */
void  DeleteAtom(atom*);


#endif /* ATOM_HPP_ */