/* Ejercicio rectangulo dinámico
-------------
Crea una clase Rectangulo que modele rectángulos por medio de cuatro
puntos (los vértices). Cada vértice es un puntero a un objeto de tipo Punto.
Para ello crea la clase Punto.
· Dispondrá de dos constructores:
   - uno que cree un rectángulo partiendo de sus cuatro vértices
   - otro que cree un rectángulo partiendo de la base y la altura, de
     forma que su vértice inferior izquierdo esté en (0,0).
· La clase también incluirá un método para calcular la superficie.
· Otro para desplazar el rectángulo en el plano.

*/

#include <iostream.h>
#include <conio.h>
#include <math.h>
// INTERFAZ DE LA CLASE Punto //
// --------------------------- //
class Punto
 {
public:
  Punto(int = 0, int = 0);     // constructor
  int coordenadax();           // método accedente
  int coordenaday();           // método accedente
  void coordenadax(int t);     // método mutador
  void coordenaday(int t);     // método mutador
private:
  int x;
  int y;
};

// Implementación de los métodos -----
Punto::Punto (int a, int b)
 {
    x=a;
    y=b;
 }

void Punto::coordenadax(int t)
{ x = t;}
void Punto::coordenaday(int t)
{ y = t;}
int Punto::coordenadax()
{ return x; }
int Punto::coordenaday()
{ return y; }


//Clase RECTANGULO -------------
// modela la clase rectángulo con 4 puntos
//     |
//     |    .p4           .p3
//     |
//     |    .p1           .p2
//     |
//  ---|------------------------------
//     |

class Rectangulo
{
  private:
     Punto *p1;
     Punto *p2;
     Punto *p3;
     Punto *p4;
  public:

    Rectangulo ();
    // constructor cuyos parámetros son los 4 puntos
    Rectangulo (Punto, Punto, Punto, Punto);
   // Constructor a partir de la base y la altura. (El punto inferior
   //  izquierdo es el (0,0)
   Rectangulo (float, float);

   // Destructor ----------------
     ~Rectangulo();

   // métodos accedentes ------
     Punto pp1();
     Punto pp2();
     Punto pp3();
     Punto pp4();

   // métodos mutadores ----------
     void pp1(Punto a);
     void pp2(Punto a);
     void pp3(Punto a);
     void pp4(Punto a);

   // operador de asignación ------------
     Rectangulo& operator= (Rectangulo r);

   // método para calcular el area -------
      float area();
};

//    ESTAMOS FUERA DE LA CLASE
Rectangulo::Rectangulo(){
   p1 = new Punto(0,0);
   p2 = new Punto (1,0);
   p3 = new Punto (1,1);
   p4 = new Punto (0,1);
}

Rectangulo::Rectangulo (Punto a, Punto b, Punto c, Punto d){
  p1 = new Punto (a);
  p2 = new Punto (b);
  p3 = new Punto (c);
  p4 = new Punto (d);
}

Rectangulo::Rectangulo (float b, float a){
 p1 = new Punto(0,0);
 p2 = new Punto (b,0);
 p3 = new Punto (b,a);
 p4 = new Punto (0,a);
}

Rectangulo::~Rectangulo(){
  delete p1;
  p1=NULL;
  delete p2;
  p2=NULL;
  delete p3;
  p3=NULL;
  delete p4;
  p4=NULL;
}
Punto Rectangulo::pp1(){
  return *p1;
}
Punto Rectangulo::pp2(){
 return *p2;
}
Punto Rectangulo::pp3(){
 return *p3;
}
Punto Rectangulo::pp4(){
  return *p4;
}

void Rectangulo::pp1(Punto a){
  *p1=a;
}
void Rectangulo::pp2(Punto a){
  *p2=a;
}

void Rectangulo::pp3(Punto a){
  *p3=a;
}

void Rectangulo::pp4(Punto a){
  *p4=a;
}

Rectangulo&  Rectangulo::operator= (Rectangulo r){
  *p1=Punto(*(r.p1));
  *p2= Punto(*(r.p2));
  *p3= Punto(*(r.p3));
  *p4= Punto(*(r.p4));
  return *this;
}

float Rectangulo::area(){
  return abs((*p1).coordenadax() - (*p2).coordenadax())
  *abs((*p1).coordenaday() - (*p4).coordenaday());
}

void  F (Rectangulo c){}
/*
// --------------------------------------------------
// Función que calcula el triángulo simétrico
// a uno dado respecto al eje Y
// La función devuelve un rectángulo
// --------------------------------------------------
*/
//Rectangulo  simetrico (Rectangulo r);


// --------------------------------------------------
// Función que calcula el triángulo simétrico
// a uno dado respecto al eje Y
// La función devuelve un puntero a un rectángulo
// --------------------------------------------------

/*
Rectangulo* simetrico2 (Rectangulo r)
{

}
*/

void main()
{
   Rectangulo r(Punto(0,0), Punto(2,0), Punto(2,3), Punto(0,3));
   Rectangulo t(2, 3);
   // ambos rectángulos son iguales.

   //t.desplazar(2,2);

   float superficie;
   superficie = r.area();       // cálculo del area del rectángulo r
   cout << "El area del rectángulo r es : " << superficie << endl;
   superficie = t.area();       // cálculo del area del rectángulo t
   cout << "El area del rectángulo t es : " << superficie;


   F(t);
   // ahora guardo en t el simétrico de r


  //t=(simetrico(r));

   /*
   Rectangulo *m;
   m = (simetrico2(r));
   getch();
   */
}

Rectangulo simetrico (Rectangulo r)
{
  Rectangulo aux (2,3);

 /*//Necesito Constructor sin argumentos
  //Coordenada x  del primer punto del simétrico
  int x1=-(r.pp1()).coordenadax();
  (r.pp1()).coordenadax(x1);
  //Coordenada x  del segundo punto del simétrico
  int x2=-(r.pp2()).coordenadax();
  (r.pp2()).coordenadax(x2);
  //Coordenada x  del tercer punto del simétrico
  int x3=-(r.pp3()).coordenadax();
  (r.pp3()).coordenadax(x3);
  //Coordenada x  del cuarto punto del simétrico
  int x4=-(r.pp4()).coordenadax();
  (r.pp4()).coordenadax(x4); */
}