#ifndef _NBODY_H
#define _NBODY_H

/**
 * @file nbody.h
 * @author Sam Moore (205030628)
 * @purpose N-Body simulator: declarations of simulation related parameters
 */

#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include <time.h>
#include <sys/time.h> //POSIX time

          

#define SINGLE_THREADED

// --- The below macros will be undefined by the multithreaded versions, and replaced with functions --- //

//Sets up the simulation; in multithreaded versions, will spawn threads
#define Simulation_Run(argc, argv) \
if (options.draw_graphics) \
	Graphics_Run(argc, argv); \
else \
{ \
	while (ExitCondition() == false) \
	{ BeforeDraw(); AfterDraw(); } \
}

#define QuitProgram(error) (runstate = (error == true) ? QUIT : QUIT_ERROR) //Prepares to exit program, is thread safe in multithreaded versions

//Macro to be overwritten in multithreaded versions, called before the graphics is allowed to draw anything
#define BeforeDraw() \
System_Compute(&universe); \
universe.steps += 1; \
if (options.verbosity != 0 && universe.steps % options.verbosity == 0) \
	DisplayStatistics(); \




//Macro to be overwritten in multithreaded versions, called after the graphics has finished drawing.
#define AfterDraw()	

// --- Constants and other Macros --- //	

#define M_PI        3.14159265358979323846264338327950288   /* pi */
#define G 6.67428E-11
#define DELTA_T 0.05
#define DIMENSIONS 3
#define LINE_SIZE 1000
#define square(x) ((x)*(x))


/**
 * Structure to represent a single Body
 * @param mass - Mass of the body
 * @param x - Position vector (array)
 * @param v - Velocity vector (array)
 * @param F - Net force vector (array)
 */
typedef struct 
{

	double mass;
	double x[DIMENSIONS];
	double v[DIMENSIONS];
	double F[DIMENSIONS];

} Body;

/**
 * Structure to store an array of bodies, along with the size of the array.
 * The universe is represented by a single System. 
 * In the multithreaded program, the universe is subdivided into one system for each working thread to use.
 * @param N - Size of the array
 * @param body - The array of bodies
 */
typedef struct
{
	unsigned N; // Number of bodies in the System
	Body * body; // Array of bodies

	unsigned steps; //Number of steps simulated

} System;

/**
 * Structure to represent options passed to the program. 
 */
typedef struct
{
	const char * input; // initial body field
	const char * output; // file to write final positions / velocities of bodies to
	const char * program; // program name
	int num_threads; // number of worker threads to spawn (must be greater than 1 for any to be spawned)
	int nested_threads; // number of threads to nest computations with (must be greater than 1 for any to be spawned)
	int num_steps; // number of steps to run before stopping (run indefinately if less than zero)
	int timeout; // number of seconds to run before stopping (run indefinately if less than zero)
	bool draw_graphics; // whether or not to actually draw graphics
	bool pedantic_graphics; // whether the graphics thread will synchronise with the computation thread (true) or just draw as fast as possible (false)
	bool print_positions; // print positions of bodies to stdout on every step
	int verbosity; // print statistics every number of steps indicated by this variable
	clock_t start_clock;  // clock cycles done when simulation starts
	struct timeval start_time; // time at which simulation starts
} Options;

void Body_Print(Body * a, FILE * out); //Print body a
void Body_Force(Body * a, System * s); //Compute force on body a due to system of bodies s
void Body_Force(Body * a, Body * b); // Compute force on body a due to body b
void Body_Velocity(Body * a); //Compute velocity of body a
void Body_Position(Body * a); //Compute position of body a

void System_Init(System * s, const char * fileName); //Initialise System (array of bodies) from a text file
void System_Compute(System * s);
void System_Forces(System * s1, System * s2); //Compute forces for bodies in s1 due to bodies in s2 (also updates velocities)
void System_Positions(System * s); //Update positions for bodies in s1
System * Split_System(System * s, unsigned n); // Splits one system into a number of other systems, returns an array of size n

void Universe_Cleanup(); //Cleanup universe and write bodies to file

void DisplayStatistics(); // Print information about steps computed, total (real) runtime, and CPU cycles


bool ExitCondition(void); //Checks whether the program is supposed to exit automatically yet (ie: other than the user pressing "quit")


typedef enum {RUN, QUIT, QUIT_ERROR} RUNSTATE;
extern RUNSTATE runstate; // Set runstate to QUIT or QUIT_ERROR and the simulation will stop on the next step.
// This is fairly redundant in the single threaded version, but useful for making sure *all* threads know to exit in the multi-threaded version


extern System universe; // The main array of bodies; global variable.
extern Options options; // Parameters passed to program



#endif //_NBODY_H