/* This Class Header */
#include "Complex7.h"

/* Collaborating Class Header */

/* Base Class Headers */

/* C++ Headers */
#include <cmath>

/* ====================================================================== */

/* Constructor */ 
template<typename T>
Complex<T>::Complex(const T& re, const T& im) {
  theReal = re;
  theImag = im;
}

/* Operations */ 
template<typename T>
T Complex<T>::re() const {
  return theReal;
}

template<typename T>
T Complex<T>::im() const {
  return theImag;
}

template<typename T>
Complex<T> Complex<T>::coniugate() const {
  return Complex(re(),-im());
}

template<typename T>
Complex<T> Complex<T>::inverse() const {
  return 1./mod2()*coniugate();
}

template<typename T>
T Complex<T>::mod2() const {
  return re()*re()+im()*im();
}

template<typename T>
T Complex<T>::mod() const {
  return sqrt(mod2());
}

template<typename T>
Complex<T> operator+(const Complex<T>& lhs, const Complex<T>& rhs) {
  return Complex<T>(lhs.re()+rhs.re(), lhs.im()+rhs.im());
}

template<typename T>
Complex<T> operator*(const Complex<T>& lhs, const Complex<T>& rhs) {
  return Complex<T>(lhs.re()*rhs.re()-lhs.im()*rhs.im(), 
                    lhs.re()*rhs.im()+lhs.im()*rhs.re());
}

template<typename T>
Complex<T> operator-(const Complex<T>& lhs) {
  return Complex<T>(-lhs.re(), -lhs.im());
}

template<typename T>
Complex<T> operator-(const Complex<T>& lhs, const Complex<T>& rhs) {
  // lo implemento in termini di "opposto" e somma
  return (lhs+(-rhs));
}

template<typename T>
Complex<T> operator/(const Complex<T>& lhs, const Complex<T>& rhs){
  // lo implemento con prodotto e inverso
  return lhs*rhs.inverse();
}

template<typename T>
ostream& operator<<(ostream& out, const Complex<T>& c) {
  out << "(" << c.re() << ( c.im()<0 ? " - i " : " + i ") << fabs(c.im()) << ")" ;
  return out;
}

template<typename T>
istream& operator>>(istream& in, Complex<T>& o) {
  cout << "Syntax: a+ib eg 4+i1" << endl;
  T re, im;
  // controllo primo carattere
  char c = in.peek();
  // se e' un "invio" allora crea Complex default
  if (c == '\n' ) { 
    o=Complex<T>(); // questo e' il mio complesso
    in.ignore(); // dico di ignorare (saltare) l'ultimo carattere dell'ifstream
    return in; // devi sempre ritornare l'ifstream!
  }
  in >> re;
  c = in.peek();
  if (c == '\n' ) {
    o=Complex<T>(re);
    in.ignore();
    return in;
  }
  // controllo che il prox carattere sia un + come previsto
  c = in.peek();
  if (c=='+') in.ignore();
  else { // che faccio??? 
    // Io non lo so proprio, devo notificare a chi sta inserendo
    // il mio complesso che ha sbagliato
    cout << "Sintassi non valida! " << endl;
    // sollevo un'eccezione
    throw exception();
  }

  // Come sopra, il prox deve essere una "i"
  c = in.peek();
  if (c=='i') in.ignore();
  else { 
    cout << "Sintassi non valida! " << endl;
    throw exception();
  }

  // prendo la parte immaginaria
  in >> im;
  o=Complex<T>(re,im);
  return in;
}