#ifndef __ATMOSPHERE_H__
#define __ATMOSPHERE_H__

#ifndef __UTILITIES_H__
#include "utilities.h"
#endif

#ifndef __SOURCE_H__
#include "source.h"
#endif

#ifndef __CENTROIDING_H__
#include "centroiding.h"
#endif

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define handle_error(msg)                               \
  do { perror(msg); exit(EXIT_FAILURE); } while (0)

struct layer {

  float altitude;
  float xi0;
  float wind_speed, wind_direction, vx, vy;
  float WIDTH_LAYER, LENGTH_LAYER;
  int N_WIDTH_LAYER, N_LENGTH_LAYER;

  int setup(float _altitude, float _xi0,
            float _wind_speed_, float _wind_direction,
            float W, int N_W,
            float field_size,
            int OSF, float duration);

};

struct profile {

  float  L0;
  float l0, L, f, delta, N_k, N_a, kmin;
  float *altitude, *xi0, *wind_speed, *wind_direction;

  void setup(float *altitude, float *xi0,
             float *wind_speed, float *wind_direction,
             int N_LAYER);
  void cleanup();

};

struct atmosphere {

  char *photometric_band;
  float wavelength, r0, wavenumber;
  int N_LAYER;
  float field_size;
  int layers_OSF;
  float layers_duration, layers_tau0;
  float W;
  int N_W;
  float *phase_screen_LAYER;
  int N_DURATION;
  int LOCAL_RAND_SEED;
  int ID;
  float EPH;
  float *d__phase_screen_LAYER;
  unsigned long N_PHASE_LAYER;
    //FILE *layers_fid;
  size_t mmap_size;
  float *zeta1, *eta1, *zeta2, *eta2;
  curandState *devStates;
  profile turbulence, *d__turbulence;
  layer *layers, *d__layers;

  void setup(float r0_, float L0, int N_LAYER,
             float *altitude, float *xi0,
             float *wind_speed, float *wind_direction);
  void setup(float r0_, float L0, int N_LAYER,
             float *altitude, float *xi0,
             float *wind_speed, float *wind_direction,
             float _L_, int _NXY_PUPIL_,
             float field_size,
             float duration);
  void setup(float r0_, float L0, int _NLAYER,
             float *altitude, float *xi0,
             float *wind_speed, float *wind_direction,
             float _L_, int _NXY_PUPIL_,
             float field_size,
             float duration,
             const char *fullpath_to_phasescreens,
             int _N_DURATION);
  void gmt_setup();
  void gmt_setup(float r0_, float L0);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration,
                 const char *fullpath_to_phasescreens,
                 int _N_DURATION);
  void gmt_setup(float r0_, float L0,
                 int _RAND_SEED_);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration,
                 int _RAND_SEED_);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration,
                 const char *fullpath_to_phasescreens,
                 int _N_DURATION,
                 int _RAND_SEED_);
  void gmt_set_id(int _ID_);
  void gmt_set_eph(float _EPH_);

  void cleanup(void);

  void info(void);

  void reset(void);

  void save_layer_phasescreens(const char* fullpath_to_phasescreens, int _N_DURATION);

  void get_phase_screen(float *phase_screen,
                        float const *x, float const *y, int N_xy,
                        source *src, float time);

  void get_phase_screen(float const *x, float const *y, int N_xy,
                        source *src, float time);

  void get_phase_screen(float const delta_x, int N_x, float const delta_y, int N_y,
                        source *src, float time);

  void get_phase_screen(float *phase_screen,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        source *src, float time);
  void get_phase_screen(source *src,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        float time);
  void get_phase_screen(source *src,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        float time, float exponent);
  void get_phase_screen(source *src, int N_SRC,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        float time);
  void get_phase_screen(source *src, float time);

  void get_phase_screen_gradient(float *sx, float *sy, float *x, float *y, int Nxy, source *src, float time);
  void get_phase_screen_gradient(float *sx, float *sy, int NL,
                                 float const d, source *src, float time);
  void get_phase_screen_gradient(float *sx, float *sy, int NL,
                                 char *valid_lenslet, float const d, source *src, float time);
  void get_phase_screen_gradient(centroiding *cog, int NL,
                                 float const d, source *src, float time);
  void get_phase_screen_gradient_rolling_shutter(centroiding *cog, int NL,
                                                 float const d, source *src, float time, float delay);
  void get_phase_screen_gradient(centroiding *cog, int NL,
                                 float const d, source *src, int N_SRC, float time);
  void get_phase_screen_gradient(centroiding *cog, int NL, char *valid_lenslet,
                                 float const d, source *src, int N_SRC, float time);
  void get_phase_screen_circ_centroids(centroiding *cog, const float R,
                                       source *src, int N_SRC, float time);
  void get_phase_screen_circ_uplink_centroids(centroiding *cog, const float R,
                                              source *src, int N_SRC, float time,
                                              char focused);

  void rayTracing(const float* x_PUPIL,const float* y_PUPIL,
                  float* phase_screen_PUPIL, const int NXY_PUPIL,
                  const source* src, const float tau);
  void rayTracing(source *src,
                  const float delta_x, const int N_X,
                  const float delta_y, const int N_Y,
                  const float tau);
};

#endif // __ATMOSPHERE_H__