#include <GL/glut.h>
#include <fstream>
#include <iostream>

#include "title.hpp"
#include "space_wolff.hpp"
#include "torus_symmetries.hpp"
#include "animation.hpp"

const unsigned D = 2;
typedef Model<double, D, TorusGroup<double, D>, Radius> model;

std::function<double(const Spin<double, D, double>&)> sphereTitle(double L, double H) {
  return [L, H](const Spin<double, D, double>& s) -> double {
    return 1e8 * critical[(320+(511 - unsigned(s.x(1) * 512 / L))) % 512][unsigned(s.x(0) * 512 / L)] + H * s.x(1);
  };
}

int main(int argc, char* argv[]) {
  const unsigned D = 2;

  double L = 32;
  unsigned N = 1000;
  double T = 2.0 / log(1.0 + sqrt(2.0));
  double H = 1.0;
  unsigned n = 25;
  double ε = 0.1;

  double k = 1e8;
  double a = 0.0;

  int opt;

  while ((opt = getopt(argc, argv, "n:N:L:T:H:e:k:a:")) != -1) {
    switch (opt) {
    case 'n':
      n = (unsigned)atof(optarg);
      break;
    case 'N':
      N = (unsigned)atof(optarg);
      break;
    case 'L':
      L = atof(optarg);
      break;
    case 'T':
      T = atof(optarg);
      break;
    case 'H':
      H = atof(optarg);
      break;
    case 'e':
      ε = atof(optarg);
      break;
    case 'k':
      k = atof(optarg);
      break;
    case 'a':
      a = atof(optarg);
      break;
    default:
      exit(1);
    }
  }

  std::function<double(const Spin<double, D, double>&, const Spin<double, D, double>&)> Z =
      [L, a, k](const Spin<double, D, double>& s1, const Spin<double, D, double>& s2) -> double {
    Vector<double, D> d = diff(L, s1.x, s2.x);

    double σ = s1.s + s2.s;
    double δ = σ - sqrt(d.transpose() * d);

    if (δ > -a * σ) {
      return 0.5 * k * (2 * pow(a * σ, 2) - pow(δ, 2));
    } else if (δ > -2 * a * σ) {
      return 0.5 * k * pow(δ + 2 * a * σ, 2);
    } else {
      return 0;
    }
  };

  /*
  std::function<double(Spin<double, D, double>)> B = [L, H](Spin<double, D, double> s) -> double {
    return H * s.x(1);
  };
  */

  auto g1 = rotateSwapTorus<D, Radius>(L, ε);
  auto g2 = nudgeGenTorus<D, Radius>(L, ε);
  auto g3 = uniformGenTorus<D, Radius>(L);
  Animation<double, D, TorusGroup<double, D>, Radius> A(L, 750, argc, argv, 1e7, true);
  model sphere(L, Z, sphereTitle(L, H));

  randutils::mt19937_rng rng;

  sphere.s.resize(n);

  unsigned nx = ceil(sqrt(n));
  for (unsigned i = 0; i < sphere.s.size(); i++) {
    Spin<double, 2, double>* ss = new Spin<double, 2, double>();
    ss->x = {(i / nx) * L / nx, (i % nx) * L / nx};
    ss->s = rng.pick({0.45, 0.45});
    sphere.s[i] = ss;
    sphere.dict.insert(ss);
  }

  sphere.wolff(T, {g1, g2, g3}, A, N);

  std::ofstream ofile("sphere_snap.dat");
  
  for (const Spin<double, 2, double>* ss : sphere.s) {
    Vector<double, 2> sx = sphere.s0.inverse().act(ss->x);
    ofile << ss->s << " " << sx(0) << " " << sx(1) << "\n";
  }

  ofile.close();

  return 0;
}