#include <iostream.h>
#include <math.h>
#include "figure-1.h"

/* attention : ce code tient compte de la seconde partie de
   l'exercice, qui introduit l'heritage multiple. Deux solutions
   sont alors possibles, l'une avec classes de base virtuelles,
   l'autre avec classes de base non virtuelles. Cette correction
   considere qu'il s'agit de classes de base virtuelles.
*/

uneFigure::uneFigure(float X, float Y)
: x(X), y(Y)
{};

void uneFigure::se_decrire() const {
  cout << "Je suis " << intitule_genre() << endl;
  cout << intitule_taille() << " vaut " << taille() << endl;
  cout << intitule_reference() << " est en (" << x << ", " << y << ")" << endl;
};

void uneFigure::deplacer(float dx, float dy) {
  x += dx; y += dy; };

uneFigurePlane::uneFigurePlane(float X, float Y)
: uneFigure(X, Y)
{};

float uneFigurePlane::taille() const { return surface(); };

char* uneFigurePlane::intitule_genre() const { return "une figure plane"; };

char* uneFigurePlane::intitule_taille() const { return "Ma surface"; };

unCercle::unCercle(float X, float Y, float R)
  : uneFigurePlane(X, Y), rayon(R)
, uneFigure(X, Y) /* car uneFigure classe virtuelle */
{};

float unCercle::surface() const { return 3.1415927*rayon*rayon; };

char* unCercle::intitule_genre() const { return "un cercle"; };

char* unCercle::intitule_reference() const { return "Mon centre"; };

void unCercle::se_decrire() const {
  uneFigurePlane::se_decrire();
  cout << "Mon rayon vaut " << rayon << endl;
};

unRectangle::unRectangle(float X, float Y, float L, float H)
: uneFigurePlane(X, Y), longueur(L), hauteur(H)
, uneFigure(X, Y) /* car uneFigure classe virtuelle */
{};

float unRectangle::surface() const { return longueur*hauteur; };

char* unRectangle::intitule_genre() const { return "un rectangle"; };

char* unRectangle::intitule_reference() const {
  return "Mon coin inferieur gauche"; };

void unRectangle::se_decrire() const {
  uneFigurePlane::se_decrire();
  decrire_longueur_hauteur();
};

void unRectangle::decrire_longueur_hauteur() const {
  cout << "Ma longueur vaut " << longueur
       << ", ma hauteur " << hauteur
       << endl;
};

unTriangle::unTriangle(float X, float Y, float B, float H)
: uneFigurePlane(X, Y), base(B), hauteur(H)
, uneFigure(X, Y) /* car uneFigure classe virtuelle */
{};

float unTriangle::surface() const { return base*hauteur/2; };

char* unTriangle::intitule_genre() const { return "un triangle"; };

char* unTriangle::intitule_reference() const {
  return "Mon coin inferieur gauche"; };

void unTriangle::se_decrire() const {
  uneFigurePlane::se_decrire();
  cout << "Ma base vaut " << base
       << ", ma hauteur " << hauteur
       << endl;
};

unCarre::unCarre(float X, float Y, float C)
: unRectangle(X, Y, C, C)
, uneFigure(X, Y) /* car uneFigure classe virtuelle */
{};

char* unCarre::intitule_genre() const { return "un carre"; };

void unCarre::decrire_longueur_hauteur() const {
  cout << "Mon coté vaut " << longueur
       << endl;
};

uneFigureLineique::uneFigureLineique(float X, float Y)
: uneFigure(X, Y)
{};

float uneFigureLineique::taille() const { return longueur(); };

char* uneFigureLineique::intitule_taille() const { return "Ma longueur"; };

char* uneFigureLineique::intitule_genre() const { return "une figure lineique"; };

unSegment::unSegment(float XA, float YA, float XB, float YB)
: uneFigureLineique(XA, YA), xB(XB), yB(YB)
{};

float unSegment::longueur() const {
  return sqrt((x-xB)*(x-xB)+(y-yB)*(y-yB)); };

void unSegment::deplacer(float dx, float dy) {
    deplacer(dx, dy); xB+=dx; yB+=dy; };

char* unSegment::intitule_genre() const { return "un segment"; };

char* unSegment::intitule_reference() const {
  return "Ma premiere extremite"; };

void unSegment::se_decrire() const {
  uneFigureLineique::se_decrire();
  cout << "Ma deuxieme extremite est en ("
       << xB << ", " << yB << ")" << endl;
};

unRecEPCer::unRecEPCer(float X, float Y, float L, float H, float R)
: unRectangle(X, Y, L, H),
  cercle(*(new unCercle(X+L/2, Y+H/2, R))),
  detruire(true)
, uneFigure(X, Y) /* car uneFigure classe virtuelle */
{};

unRecEPCer::unRecEPCer(unCercle& C, float X, float Y, float L, float H)
: unRectangle(X, Y, L, H),
  cercle(C),
  detruire(false)
, uneFigure(X, Y) /* car uneFigure classe virtuelle */
{};

unRecEPCer::~unRecEPCer() { if (detruire) delete &cercle; };

float unRecEPCer::surface() const {
  return unRectangle::surface() - cercle.surface(); };

char* unRecEPCer::intitule_genre() const {
  return "un rectangle evide par un cercle"; };

void unRecEPCer::se_decrire() const {
  unRectangle::se_decrire();
  cout << "Le cercle qui m'evide se decrit maintenant :" << endl;
  cout << "<<<<" << endl;
  cercle.se_decrire();
  cout << ">>>>" << endl;
};

void unRecEPCer::deplacer(float dx, float dy) {
    deplacer(dx, dy); cercle.deplacer(dx, dy); };

uneFigurePlaneEvidee::uneFigurePlaneEvidee(uneFigurePlane& E, uneFigurePlane& I, bool D)
: exterieure(E), interieure(I), detruire(D)
, uneFigure(E) /* car uneFigure classe virtuelle */
{};

uneFigurePlaneEvidee::~uneFigurePlaneEvidee() {
  if (detruire) {
    delete &exterieure;
    delete &interieure; }
};

float uneFigurePlaneEvidee::surface() const {
  return exterieure.surface() - interieure.surface(); };

char* uneFigurePlaneEvidee::intitule_genre() const {
  return "une figure plane evidee par une autre figure plane"; };

void uneFigurePlaneEvidee::se_decrire() const {
  uneFigurePlane::se_decrire();
  cout << "Ma figure exterieure (qui est evidee) se decrit maintenant :" << endl;
  cout << "<<<<" << endl;
  exterieure.se_decrire();
  cout << ">>>>" << endl;
  cout << "Ma figure interieure (qui m'evide) se decrit maintenant :" << endl;
  cout << "<<<<" << endl;
  interieure.se_decrire();
  cout << ">>>>" << endl;
};

void uneFigurePlaneEvidee::deplacer(float dx, float dy) {
    deplacer(dx, dy);
    interieure.deplacer(dx, dy);
    exterieure.deplacer(dx, dy);
};