/*
 * Geometric_Object.h    2014-12-04
 */
#ifndef GEOMETRICOBJECT_H
#define GEOMETRICOBJECT_H
#include "Cloneable.h"
#include "Serializeable.h"
#include <cmath>
#include <string>

/*
 * Geometric_Object, abstract, polymorphic base for all geometric objects.
 *
 * Both Cloneable and Serializeable have virtual destructor, so proper
 * destruction is guaranteed (twice:). The destructors in Geometric_Object
 * classes will be virtual.
 *
 * Special member functions which are desired ans can be generated are
 * defaulted. Special member functions which are not desired but would be
 * generated are deleted. Special member functions which are not desired
 * and will not be generated are not declared.
 *
 * Public clone(), derived from Cloneable, is to be overridden by every 
 * concrete Geometric_Object class.
 *
 * Public std::string str() const; is inherited from Serializeable, private
 * to_str() is to be overridden by every concrete class. This implements the
 * NVI pattern.
 *
 * Virtual member function get_profile() is final in Circle, Rectangle, and
 * Triangle, because there is no expected further meaningfull overriding.
 *
 * The solids classes could possibly be final (subclassing seems not to be
 * meaningful?).
 */

class Geometric_Object : public Cloneable, public Serializeable
{
public:
   ~Geometric_Object() = default;
protected:
   Geometric_Object() = default;
   Geometric_Object(const Geometric_Object&) = default;
   Geometric_Object(Geometric_Object&&) = default;

private:
   Geometric_Object& operator=(const Geometric_Object&) = delete;
};

/*
 * Plane, abstract interface for plane objects.
 */

struct Plane 
{
   Plane() = default;
   Plane(const Plane&) = default;
   Plane(Plane&&) = default;
   ~Plane() = default;
   Plane& operator=(const Plane&) = default;
   Plane& operator=(Plane&&) = default;

   virtual double get_area() const = 0;
   virtual double get_profile() const = 0;
};

/*
 * Solid, abstract interface for solids.
 */

struct Solid 
{
   Solid() = default;
   Solid(const Solid&) = default;
   Solid(Solid&&) = default;
   ~Solid() = default;
   Solid& operator=(const Solid&) = default;
   Solid& operator=(Solid&&) = default;

   virtual double get_area() const = 0;
   virtual double get_volume() const = 0;
};

/*
 * Point
 */

class Point final : public Geometric_Object
{
public:
   Point() = default;
   Point(double x, double y) : x{ x }, y{ y } {}
   ~Point() = default;

   double x{ 0 };
   double y{ 0 };

   Point* clone() const override;
   
protected:
   Point(const Point&) = default;
   Point(Point&&) = default;

private:
   Point& operator=(const Point&) = delete;

   std::string to_str() const override;
};

/*
 * Line
 */

class Line final : public Geometric_Object
{
public:
   Line() = default;

   Line(double x1, double y1, double x2, double y2) 
      : x1_{ x1 }, y1_{ y1 }, x2_{ x2 }, y2_{ y2 } 
   {}

   ~Line() = default;

   double x1_{ 0.0 };
   double y1_{ 0.0 };
   double x2_{ 0.0 };
   double y2_{ 0.0 };

   double get_length() const;

   Line* clone() const override;

protected:
   Line(const Line&) = default;
   Line(Line&&) = default;

private:
   Line& operator=(const Line&) = delete;

   std::string to_str() const override;
};

/*
 * Circle
 */

class Circle : public Geometric_Object, public Plane
{
public:
   Circle() = default;
   Circle(double r) : r_{ r } {}

   ~Circle() = default;

   double get_area() const override;
   double get_profile() const override final;
   double get_radius() const;

   Circle* clone() const override;

protected:
   Circle(const Circle&) = default;
   Circle(Circle&&) = default;

   std::string to_str() const override;

   double  r_{ 1.0 };

private:
   Circle& operator=(const Circle&) = delete;
};

/*
 * Circular_Cylinder
 */

class Circular_Cylinder : public Circle, public Solid
{
public:
   Circular_Cylinder() = default;
   Circular_Cylinder(double r, double h) : Circle{ r }, h_{ h } {}

   ~Circular_Cylinder() = default;

   double get_area() const override;
   double get_volume() const override;
   double get_height() const;

   Circular_Cylinder* clone() const override;

protected:
   Circular_Cylinder(const Circular_Cylinder&) = default;
   Circular_Cylinder(Circular_Cylinder&&) = default;

   double h_{ 1.0 };

private:
   Circular_Cylinder& operator=(const Circular_Cylinder&) = delete;

   std::string to_str() const override;
};

/*
 * Rectangle
 */

class Rectangle : public Geometric_Object, public Plane
{
public:
   Rectangle() = default;
   Rectangle(double a, double b) :a_{ a }, b_{ b } {}

   ~Rectangle() = default;

   double get_area() const override;
   double get_profile() const override final;

   double get_a() const;
   double get_b() const;

   Rectangle* clone() const override;

protected:
   Rectangle(const Rectangle&) = default;
   Rectangle(Rectangle&&) = default;

private:
   Rectangle& operator=(const Rectangle&) = delete;

   std::string to_str() const override;

   double a_{ 1.0 };
   double b_{ 1.0 };
};

/*
 * Rectangular_Parallelepiped
 */

class Rectangular_Parallelepiped : public Rectangle, public Solid
{
public:
   Rectangular_Parallelepiped() = default;

   Rectangular_Parallelepiped(double a, double b, double c) 
      : Rectangle{ a, b }, c_{ c } 
   {}

   ~Rectangular_Parallelepiped() = default;

   double get_area() const override;
   double get_volume() const override;

   double get_c() const;

   Rectangular_Parallelepiped* clone() const override;

protected:
   Rectangular_Parallelepiped(const Rectangular_Parallelepiped&) = default;
   Rectangular_Parallelepiped(Rectangular_Parallelepiped&&) = default;

   std::string to_str() const override;

private:
   Rectangular_Parallelepiped& operator=(const Rectangular_Parallelepiped&) = delete;

   double c_{ 1.0 };
};

/*
 * Triangle
 */

class Triangle : public Geometric_Object, public Plane
{
public:
   Triangle() = default;
   Triangle(double a, double b, double c) : a_{ a }, b_{ b }, c_{ c } {}

   ~Triangle() = default;
      
   double get_area() const override;
   double get_profile() const override final;

   double get_a() const;
   double get_b() const;
   double get_c() const;

   Triangle* clone() const override;

protected:
   Triangle(const Triangle&) = default;
   Triangle(Triangle&&) = default;

   double a_{ 1.0 };
   double b_{ 1.0 };
   double c_{ 1.0 };

private:
   Triangle& operator=(const Triangle&) = delete;

   std::string to_str() const override;
};

/*
 * Triangular_Prism
 */

class Triangular_Prism : public Triangle, public Solid
{
public:
   Triangular_Prism() = default;
   Triangular_Prism(double a, double b, double c, double h) 
      : Triangle{ a, b, c }, h_{ h } 
   {}

   ~Triangular_Prism() = default;

   double get_area() const override;
   double get_volume() const override;
   double get_height() const;

   Triangular_Prism* clone() const override;

protected:
   Triangular_Prism(const Triangular_Prism&) = default;
   Triangular_Prism(Triangular_Prism&&) = default;

   std::string to_str() const override;

   double h_{ 1.0 };

private:
   Triangular_Prism& operator=(const Triangular_Prism&) = delete;
};

#endif