/** representation based on the halfplane model; assumes Dim=3 */

namespace reps {

template<class F> struct sl2 : public array<F, 4> {

  sl2(F a, F b, F c, F d) { self[0] = a; self[1] = b; self[2] = c; self[3] = d; }
  
  sl2 operator * (const sl2& sec) const {
    return sl2(
      self[0] * sec[0] + self[1] * sec[2], 
      self[0] * sec[1] + self[1] * sec[3], 
      self[2] * sec[0] + self[3] * sec[2], 
      self[2] * sec[1] + self[3] * sec[3]
      );
    }

  std::string print() {
    return hr::lalign(0, "[", self[0], ",", self[1], ";", self[2], ",", self[3], "]");
    }

  };

TD sl2<typename D::Number> split_quaternion_to_sl2(const multivector<D>& h) {
  auto h3 = h[0], h2 = h[1 | 2], h1 = h[1 | 4], h0 = h[2 | 4];
  return sl2(h3 - h1, h2 + h0, -h2 + h0, h3 + h1);
  }

TD multivector<D> sl2_to_split_quaternion(const sl2<typename D::Number>& e) {
  auto h0 = (e[1] + e[2]) / 2;
  auto h3 = (e[0] + e[3]) / 2;
  auto h1 = (e[3] - e[0]) / 2;
  auto h2 = (e[1] - e[2]) / 2;
  auto res = zero_vector<multivector_data<D>>();
  res[0] = h3; res[1 | 2] = h2; res[1 | 4] = h1; res[2 | 4] = h0;
  return res;
  }

template<class N> using sl2c = sl2<std::complex<N>>;

TD sl2c<typename D::Number> split_biquaternion_to_sl2c(const multivector<D>& h) {
  using cn = std::complex<typename D::Number>;
  return sl2(cn(h[0]-h[9], h[15]-h[6]), cn(h[3]+h[10], -h[5]-h[12]), cn(h[10]-h[3], h[12]-h[5]), cn(h[0]+h[9], h[6]+h[15]));
  }

TD multivector<D> sl2c_to_split_biquaternion(const sl2c<typename D::Number>& e) {
  auto res = zero_vector<multivector_data<D>>();
  res[0]  = +(real(e[0]) + real(e[3])) / 2;
  res[3]  = +(real(e[1]) - real(e[2])) / 2;
  res[5]  = -(imag(e[1]) + imag(e[2])) / 2;
  res[6]  = +(imag(e[3]) - imag(e[0])) / 2;
  res[9]  = +(real(e[3]) - real(e[0])) / 2;
  res[10] = +(real(e[1]) + real(e[2])) / 2;
  res[12] = +(imag(e[2]) - imag(e[1])) / 2;
  res[15] = +(imag(e[0]) + imag(e[3])) / 2;
  return res;
  }

TD struct rep_halfplane {

  using data = D;
  using N = typename D::Number;
  using point = std::complex<N>;
  using isometry = sl2<N>;

  static isometry cspin(int i, int j, N alpha) {
    // return split_quaternion_to_sl2( rep_clifford<D>::cspin(i, j, alpha) );
    if(i>j) std::swap(i, j), alpha = -alpha; alpha /= 2;
    auto ca = cos(alpha), sa = sin(alpha);
    return isometry(ca, -sa, sa, ca);
    }
  static isometry cspin90(int i, int j, N alpha) {
    // return split_quaternion_to_sl2( rep_clifford<D>::cspin(i, j, alpha) );
    auto ca = sqrt(N(2)), sa = sqrt(N(2));
    if(i>j) std::swap(i, j), sa = -sa;
    return isometry(ca, -sa, sa, ca);
    }
  static isometry lorentz(int i, int j, N alpha) {
    // return split_quaternion_to_sl2( rep_clifford<D>::lorentz(i, j, alpha) );
    if(i>j) std::swap(i, j); alpha /= 2;
    if(i == 0) return isometry(exp(-alpha), N(0), N(0), exp(alpha));
    if(i == 1) {
      auto ca = cosh(alpha), sa = sinh(alpha);
      return isometry(ca, sa, sa, ca);
      }
    throw hr::hr_exception("bad lorentz");
    }
  static isometry id() { return isometry(N(1),N(0),N(0),N(1)); };
  static point center() { return point(N(0), N(1)); };
  static point apply(const isometry& T, const point& x) { 
    return (T[0] * x + T[1] * 1) / (T[2] * x + T[3] * 1);
    };
  static isometry apply(const isometry& T, const isometry& U) { return T * U; };

  static typename rep_clifford<D>::point to_poincare(const point& x) {
    auto a = real(x), b = imag(x);

    auto tmp = isometry(sqrt(b), a/sqrt(b), N(0), N(1)/sqrt(b));
    auto sq = sl2_to_split_quaternion<D>(tmp);

    // sq[0] = (sqrt(b) + 1/sqrt(b)) / 2;; sq[1 | 2] = a/sqrt(b)/2; sq[1 | 4] = (1/sqrt(b) - sqrt(b)) / 2; sq[2 | 4] = a/sqrt(b)/2;
   
    sq = despin(sq);
    return typename rep_clifford<D>::point({{sq}});
    }

  static isometry inverse(isometry T) { return isometry(T[3], -T[1], -T[2], T[0]); }
  static isometry push(const point& p) { return split_quaternion_to_sl2<D>(to_poincare(p)[0]); }

  static N dist0(const point& x) { return rep_clifford<D>::dist0(to_poincare(x)); } 
  static N angle(const point& x) { return rep_clifford<D>::angle(to_poincare(x)); }
  static N get_coord(const point& x, int i) { return rep_clifford<D>::get_coord(to_poincare(x), i); }

  // imag may be very small and still important, so do not use the default complex print
  static std::string print(const point& x) { return hr::lalign(0, "{real:", real(x), " imag:", imag(x), "}"); }
  static std::string print(const isometry& x) { return x.print(); }
  };

TD struct rep_halfspace {

  using data = D;
  using N = typename D::Number;
  struct point { std::complex<N> xy; N z; };
  using isometry = sl2c<N>;

  static isometry cspin(int i, int j, N alpha) {
    return split_biquaternion_to_sl2c( rep_clifford<D>::cspin(i, j, alpha) );
    }
  static isometry cspin90(int i, int j) {
    return split_biquaternion_to_sl2c( rep_clifford<D>::cspin90(i, j) );
    }
  static isometry lorentz(int i, int j, N alpha) {
    return split_biquaternion_to_sl2c( rep_clifford<D>::lorentz(i, j, alpha) );
    }
  static isometry id() { return isometry(N(1),N(0),N(0),N(1)); }
  static point center() { return point{ .xy = N(0), .z = N(1) }; }
  static point apply(const isometry& T, const point& x) { 
    auto nom = T[0] * x.xy + T[1] * N(1);
    auto nomz= T[0] * x.z;
    auto den = T[2] * x.xy + T[3] * N(1);
    auto denz= T[2] * x.z;
    // D = den + denz * j
    auto dnorm = std::norm(den) + std::norm(denz);
    using std::conj;
    // conj(D) = conj(den) - denz * j
    // N / D = (nom + nomz * j) / (den + denz * j) = 
    // = (nom + nomz * j) * (conj(den) - denz * j) / dnorm
    
    // auto rxy  = (nom * conj(den) - nomz * j * denz * j);
    // auto rz*j = (-nom * denz * j + nomz * j * conj(den))

    // apply the formula: j * a = conj(a) * j

    auto rxy = (nom * conj(den) + nomz * conj(denz));
    auto rz  = (nomz * den - nom * denz); // todo only real part
    // println(hlog, "imag of rz = ", imag(rz));
    return point { .xy = rxy / dnorm, .z = real(rz) / dnorm };
    };
  static isometry apply(const isometry& T, const isometry& U) { return T * U; };

  static typename rep_clifford<D>::point to_poincare(const point& x) {
    auto tmp = isometry(sqrt(x.z), x.xy/sqrt(x.z), N(0), N(1)/sqrt(x.z));
    auto sq = sl2c_to_split_biquaternion<D>(tmp);
    sq = despin(sq);
    return typename rep_clifford<D>::point({{sq}});
    }

  static isometry inverse(isometry T) { return isometry(T[3], -T[1], -T[2], T[0]); }
  static isometry push(const point& p) { return split_biquaternion_to_sl2c<D>(to_poincare(p)[0]); }

  static N dist0(const point& x) { return rep_clifford<D>::dist0(to_poincare(x)); } 
  static N angle(const point& x) { return rep_clifford<D>::angle(to_poincare(x)); }
  static N get_coord(const point& x, int i) { return rep_clifford<D>::get_coord(to_poincare(x), i); }

  // imag may be very small and still important, so do not use the default complex print
  static std::string print(const point& x) { return hr::lalign(0, "{x:", real(x.xy), " y:", imag(x.xy), " z:", x.z, "}"); }
  static std::string print(const isometry& x) { return x.print(); }
  };

template<class D> using rep_half = typename std::conditional<D::Dim==3, rep_halfplane<D>, rep_halfspace<D>>::type;

}