#pragma once

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <vector>

#define _USE_MATH_DEFINES

#include <math.h>
#include <random>
#include <string>
#include <sstream>

#include "Particle.h"
#include "rnd.h"

using namespace std;


class DLASystem {
public:
    // list of particles
    vector<Particle *> particleList;
    int numParticles;

    // delete particles and clear the particle list
    void clearParticles();

    // size of cluster
    double clusterRadius;
    // these are related to the DLA algorithm
    double addCircle;
    double killCircle;

    ofstream csv_out;

    // size of grid
    static const int gridSize = 1600;
    int **grid;  // this will be a 2d array that stores whether each site is occupied

    // the window draws only part of the grid, viewSize controls how much...
    double viewSize;
    double drawScale;

    // random number generator, class name is rnd, instance is rgen
    rnd rgen;

    // output file (not used at the moment)
    ofstream logfile;

    // number of particles at which the simulation will stop
    // (the value is set in constructor)
    int endNum;

    // the values of these variables are set in the constructor
    double addRatio;    // how much bigger the addCircle should be, compared to cluster radius
    double killRatio;   // how much bigger is the killCircle, compared to the addCircle


public:
    // these are public variables and functions

    // update the system: if there is an active particle then move it,
    // else create a new particle (on the adding circle)
    bool Update();

    // draw particles as squares
    void DrawSquares();

    // is the simulation running (1) or paused (0) ?
    int running;

    // slowNotFast is +1 for slow running, 0 for fast
    int slowNotFast;

    // lastParticleIsActive is +1 if there is an active particle in the system, otherwise 0
    int lastParticleIsActive;

    // constructor
    DLASystem(ofstream output);

    // destructor
    ~DLASystem();

    // delete all particles and reset
    void Reset();

    // this sets the seed for the random numbers
    void setSeed(int s) { rgen.setSeed(s); }

    // check whether we should stop (eg the cluster has reached the edge of the grid)
    int checkStop();

    // stop/start the algorithm
    void setRunning() { if (checkStop() == 0) running = 1; }

    void pauseRunning() { running = 0; }

    // set whether it runs fast or slow
    void setSlow() { slowNotFast = 1; }

    void setFast() { slowNotFast = 0; }

    void setSuperFast() { slowNotFast = -1; }

    // set which part of the grid is visible on the screen
    // basically the screen shows co-ordinates -vv < x < vv
    // where vv is the input value
    void setViewSize(double vv) {
        viewSize = vv;
        drawScale = 2.0 / viewSize;
    }

    // if the killcircle is almost as big as the view then increase the view
    void updateViewSize();

    // set the view to be the approx size of the addCircle
    void viewAddCircle();

    // if pos is outside the cluster radius then set clusterRadius to be the distance to pos.
    void updateClusterRadius(double pos[]);

    // set and read grid entries associated with a given position
    void setGrid(double pos[], int val);

    int readGrid(double pos[]);

    // return the distance of a given point from the origin
    double distanceFromOrigin(double pos[]) {
        return sqrt(pos[0] * pos[0] + pos[1] * pos[1]);
    }

    // set whether there is an active particle in the system or not
    void setParticleActive() { lastParticleIsActive = 1; }

    void setParticleInactive() { lastParticleIsActive = 0; }

    // add a particle at pos
    void addParticle(double pos[]);

    // add a particle at a random point on the addCircle
    void addParticleOnAddCircle();

    // assign setpos to the position of a neighbour of pos
    // which neighbour we look at is determined by val (=0,1,2,3)
    void setPosNeighbour(double setpos[], double pos[], int val);

    // this attempts to move the last particle in the List to a random neighbour
    // if the neighbour is occupied then nothing happens
    // the function also checks if the moving particle should stick.
    void moveLastParticle();

    // check whether the last particle should stick
    // currently it sticks whenever it touches another particle
    int checkStick();
};