#pragma once

#include <assert.h>
#include <cholmod.h>
#include <float.h>
#include <getopt.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_sf_erf.h>
#include <gsl/gsl_sf_exp.h>
#include <gsl/gsl_sf_log.h>
#include <inttypes.h>
#include <math.h>
#include <omp.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

// these defs allow me to switch to long int cholmod in a sitch
#define int_t int
#define uint_t unsigned int
#define CINT_MAX INT_MAX
#define CHOL_F(x) cholmod_##x

#define GSL_RAND_GEN gsl_rng_mt19937

typedef enum lattice_t {
	VORONOI_LATTICE,
	SQUARE_LATTICE
} lattice_t;

typedef enum bound_t {
	FREE_BOUND,
	CYLINDER_BOUND,
	TORUS_BOUND,
	EMBEDDED_BOUND
} bound_t;

typedef struct {
	uint_t ne;
	uint_t nv;
	uint_t dnv;
	uint_t nv_break;
	uint_t num_bounds;
	uint_t *ev; 
	uint_t *ev_break;
	uint_t *vei;
	uint_t *ve;
	uint_t *bound_inds;
	uint_t *bound_verts;
	double *vx;
	double *ex;
	uint_t *dev;
	uint_t *dvei;
	uint_t *dve;
	double *dvx;
	uint_t num_spanning_edges;
	uint_t *spanning_edges;
	uint_t L;
	uint_t break_dim;
	cholmod_sparse *voltcurmat;
	bound_t boundary;
} graph_t;

typedef struct {
	const graph_t *graph;
	bool *fuses;
	double *thres;
	double inf;
	cholmod_dense *boundary_cond;
	cholmod_factor *factor;
	uint_t *marks;
	uint_t *dual_marks;
	bool voltage_bound;
	uint_t num_components;
	cholmod_sparse *adjacency;
	cholmod_sparse *dual_adjacency;
	bool debug_stop;
} net_t;

typedef struct {
	uint_t num_broken;
	uint_t *break_list;
	double *conductivity;
	double *extern_field;
} data_t;

intptr_t *run_voronoi(uint_t num_coords, double *coords, bool periodic, double xmin, double xmax, double ymin, double ymax);

int update_components(const cholmod_sparse *laplacian, uint_t *marks,
											int old_num_components, int v1, int v2, int exclude);

uint_t *find_components(const cholmod_sparse *laplacian, uint_t skip);

cholmod_sparse *gen_adjacency(const net_t *instance, bool dual, bool breakv,
															uint_t pad, cholmod_common *c);

cholmod_sparse *gen_laplacian(const net_t *instance, cholmod_common *c,
															bool symmetric);

int edge_to_verts(uint_t width, bool periodic, uint_t edge,
									bool index);

int dual_edge_to_verts(uint_t width, bool periodic, uint_t edge,
											 bool index);

double dual_vert_to_coord(uint_t width, bool periodic, uint_t vert,
													bool index);

void factor_update(cholmod_factor *factor, uint_t v1, uint_t v2, cholmod_common *c);

void net_notch(net_t *net, double notch_len, cholmod_common *c);
data_t *net_fracture(net_t *net, cholmod_common *c, double cutoff);
double *net_voltages(const net_t *net, cholmod_common *c);
double *net_currents(const net_t *net, const double *voltages, cholmod_common *c);
double net_conductivity(const net_t *net, const double *voltages);

void update_boundary(net_t *instance, const double *avg_field);

FILE *get_file(const char *prefix, uint_t width, uint_t crack,
							 double beta, uint_t iter, uint_t num_iter,
							 uint_t num, bool read);

double update_beta(double beta, uint_t width, const double *stress,
									 const double *damage, double bound_total);

cholmod_sparse *gen_voltcurmat(uint_t num_edges, uint_t num_verts,
															 uint_t *edges_to_verts, cholmod_common *c);

net_t *net_copy(const net_t *net, cholmod_common *c);

graph_t *ini_square_network(uint_t width, bound_t boundary, bool side_bounds,
												 cholmod_common *c);

void graph_free(graph_t *network, cholmod_common *c);
void net_free(net_t *instance, cholmod_common *c);

net_t *net_create(const graph_t *g, double inf, double beta, double notch_len, bool vb, cholmod_common *c);

graph_t *ini_voro_graph(uint_t L, bound_t boundary, bool use_dual,
													double *(*genfunc)(uint_t, bound_t, gsl_rng *, uint_t *),
													cholmod_common *c);

bool break_edge(net_t *instance, uint_t edge, cholmod_common *c);

void finish_instance(net_t *instance, cholmod_common *c);

net_t *coursegrain_square(net_t *instance, graph_t *network_p, cholmod_common *c);

uint_t *get_clusters(net_t *instance, cholmod_common *c);

uint_t *get_cluster_dist(net_t *instance, cholmod_common *c);

double *genfunc_uniform(uint_t L, bound_t boundary, gsl_rng *r, uint_t *num);
double *genfunc_hyperuniform(uint_t L, bound_t boundary, gsl_rng *r, uint_t *num);
void randfunc_flat(gsl_rng *r, double *x, double *y);
void randfunc_gaus(gsl_rng *r, double *x, double *y);

uint_t **get_dists(const graph_t *network);
uint_t *dijkstra(const graph_t *g, uint_t source);
double *get_corr(net_t *instance, uint_t **dists, cholmod_common *c);

double *bin_values(graph_t *network, uint_t width, double *values);

cholmod_dense *bound_set(const graph_t *g, bool vb, double notch_len, cholmod_common *c);

data_t *data_create(uint_t num_edges);
void data_free(data_t *data);
void data_update(data_t *data, uint_t last_broke, double strength, double conductivity);

graph_t *graph_create(lattice_t lattice, bound_t bound, uint_t L, bool dual, cholmod_common *c);

uint_t find_cycles(uint_t num_edges, const bool *fuses, const uint_t *ev, const uint_t *vei, const uint_t *ve, int **cycles);

bool set_connected(const cholmod_sparse *laplacian, uint_t *marks, int vertex, int label, int stop_at, int exclude);

unsigned long int rand_seed();

double rand_dist_pow(const gsl_rng *r, double beta);