#include "space_wolff.hpp"

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;

  int opt;

  while ((opt = getopt(argc, argv, "n:N:L:T:H:")) != -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;
      default:
        exit(1);
    }
  }

  std::function<double(spin<double, D, double>, spin<double, D, double>, spin<double, D, double>)> Z =
    [L] (spin<double, D, double> s1, spin<double, D, double> s2, spin<double, D, double> s1_new) -> double {
      vector<double, D> diff_old = diff(L, s1.x, s2.x);
      vector<double, D> diff_new = diff(L, s1_new.x, s2.x);

      double rad_sum = pow(s1.s + s2.s, 2);

      bool old_overlap = diff_old.transpose() * diff_old < rad_sum;
      bool new_overlap = diff_new.transpose() * diff_new < rad_sum;

      if (new_overlap) {
        return 1.0;
      } else {
        return 0.0;
      }
    };

  std::function<double(spin<double, D, double>)> B =
    [L, H] (spin<double, D, double> s) -> double {
      return H * sin(2 * M_PI * 3 * s.x(0) / L);
    };

  std::function<std::set<unsigned>(model<double, D, double>&, unsigned, spin<double, D, double>)> neighbors =
    [] (model<double, D, double>& m, unsigned i0, spin<double, D, double> s1) -> std::set<unsigned> {
      std::set<unsigned> nn;
      if (i0 < m.s.size()) {
        std::set<unsigned> n_old = m.dict.neighbors(m.s[i0].x, 1);
        std::set<unsigned> n_new = m.dict.neighbors(s1.x, 1);;
        nn.insert(n_old.begin(), n_old.end());
        nn.insert(n_new.begin(), n_new.end());
        nn.insert(m.s.size());
      } else {
        for (unsigned i = 0; i < m.s.size(); i++) {
          nn.insert(i);
        }
      }
      return nn;
    };

  model<double, D, double> sphere(L, Z, B, neighbors);

  randutils::auto_seed_128 seeds;
  std::mt19937 rng{seeds};

  std::uniform_real_distribution<double> dist(0.0, L);

  for (unsigned i = 0; i < n; i++) {
    vector<double, D> pos = {dist(rng), dist(rng)};
    sphere.s.push_back({pos, 0.5});
    sphere.dict.record<double>(pos, i);
  }

  sphere.wolff(T, N, rng);

  std::ofstream snapfile;
  snapfile.open("sphere_snap.dat");

  for (spin<double, D, double> s : sphere.s) {
    spin<double, D, double> rs = sphere.s0.inverse().act(s);
    snapfile << rs.x.transpose() << "\n";
  }

  snapfile.close();

  return 0;
}