// Copyright Sebastian Jeckel 2014.

// Distributed under the Boost Software License, Version 1.0.

// (See accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

#pragma once

#include <iostream>

#include <fstream>

#include <memory>

#include <random>

#include <type_traits>

#include "BenchmarkBase.h"

#include "react/ReactiveObject.h"

#include "react/logging/EventLog.h"

using namespace react;

using std::vector;

using std::atomic;

using std::tuple;

using std::unique_ptr;

using std::move;

using std::make_tuple;

using std::cout;

using std::string;

using std::pair;

using std::make_pair;

using std::get;

enum class Seasons { summer, winter };

enum class Migration { enter, leave };

typedef pair<int,int> PositionT;

template <typename D>

class Time : public ReactiveObject<D>

{

public:

EventSourceT<bool> NewDay = MakeEventSource<bool>();

SignalT<int> TotalDays = Iterate(0, NewDay, Incrementer<int>());

SignalT<int> DayOfYear = TotalDays % 365;

SignalT<Seasons> Season = DayOfYear ->* [] (int day) {

return day < 180 ? Seasons::winter : Seasons::summer;

};

};

template <typename D>

class Region : public ReactiveObject<D>

{

Time<D>& theTime;

public:

using BoundsT = tuple<int,int,int,int>;

BoundsT Bounds;

EventSourceT<Migration> EnterOrLeave = MakeEventSource<Migration>();

SignalT<int> AnimalCount = Fold(0, EnterOrLeave, [] (int count, Migration m) {

return m == Migration::enter ? count + 1 : count - 1;

});

SignalT<int> FoodPerDay = theTime.Season ->* [] (Seasons season) {

return season == Seasons::summer ? 20 : 10;

};

SignalT<int> FoodOutputPerDay =

(FoodPerDay, AnimalCount) ->* [] (int food, int count) {

return count > 0 ? food/count : 0;

};

EventsT<int> FoodOutput = Pulse(FoodOutputPerDay, theTime.NewDay);

Region(Time<D>& time, int x, int y):

theTime { time },

Bounds { make_tuple(x*10, x*10+9, y*10, y*10+9) }

{

}

PositionT Center()

{

return make_pair(get<0>(Bounds) + 5, get<2>(Bounds) + 5);

}

PositionT Clamp(PositionT pos)

{

pos.first = get<0>(Bounds) + (abs(pos.first) % 10);

pos.second = get<2>(Bounds) + (abs(pos.second) % 10);

return pos;

}

bool IsInRegion(PositionT pos)

{

return get<0>(Bounds) <= pos.first && pos.first <= get<1>(Bounds) &&

get<2>(Bounds) <= pos.second && pos.second <= get<3>(Bounds);

}

};

template <typename D>

class World : public ReactiveObject<D>

{

int w_;

public:

vector<unique_ptr<Region<D>>> Regions;

World(Time<D>& time, int w) :

w_( w )

{

for (int x=0; x<w; x++)

for (int y=0; y<w; y++)

Regions.push_back(unique_ptr<Region<D>>(new Region<D>(time, x, y)));

}

Region<D>* GetRegion(PositionT pos)

{

for (auto& r : Regions)

{

if (r->IsInRegion(pos))

return r.get();

}

printf("FATAL ERROR %d %d\n", pos.first, pos.second);

return nullptr;

}

PositionT Clamp(PositionT pos)

{

pos.first = abs(pos.first) % 10*w_;

pos.second = abs(pos.second) % 10*w_;

return pos;

}

};

template <typename D>

class Animal : public ReactiveObject<D>

{

Time<D>& theTime;

World<D>& theWorld;

std::mt19937 generator;

public:

SignalT<PositionT> Position;

VarSignalT<Region<D>*> CurrentRegion;

SignalT<Region<D>*> NewRegion;

Animal(Time<D>& time, World<D>& world, Region<D>* initRegion, unsigned seed) :

theTime( time ),

theWorld( world ),

CurrentRegion( MakeVar(initRegion) ),

generator( seed )

{

Position = Fold(initRegion->Center(), Moving, [this] (PositionT position, bool shouldMigrate) {

std::uniform_int_distribution<int> dist(-1,1);

// Wander randomly

for (int i=0; i<100; i++)

{

position.first += dist(generator);

position.second += dist(generator);

}

if (shouldMigrate)

return theWorld.Clamp(position);

else

return CurrentRegion.Value()->Clamp(position);

});

NewRegion = (Position) ->* [this] (PositionT pos)

{

return theWorld.GetRegion(pos);

};

initRegion->EnterOrLeave << Migration::enter;

Observe(NewRegion, [this] (Region<D>* newRegion) {

CurrentRegion.Value()->EnterOrLeave << Migration::leave;

newRegion->EnterOrLeave << Migration::enter;

CurrentRegion <<= newRegion;

//Migrating << true;

});

}

EventsT<int> FoodReceived = REACTIVE_PTR(CurrentRegion, FoodOutput);

SignalT<int> Age = Iterate(0, theTime.NewDay, Incrementer<int>());

SignalT<int> Health = Fold(100, FoodReceived, [] (int health, int food) {

auto newHealth = health + food - 10;

return newHealth < 0 ? 0 : newHealth > 10000 ? 10000 : newHealth;

});

//Signal<bool> YoungAndHealthy = Age < 1000 && Health > 0;

//Event<bool> Migrating = EventSource<bool>();

SignalT<bool> ShouldMigrate = Hold(0, FoodReceived) < 10;

EventsT<bool> Moving = Pulse(ShouldMigrate, theTime.NewDay);

};

///////////////////////////////////////////////////////////////////////////////////////////////////

/// Run simulation

///////////////////////////////////////////////////////////////////////////////////////////////////

struct BenchmarkParams_LifeSim

{

BenchmarkParams_LifeSim(int n, int w, int k) :

N( n ),

W( w ),

K( k )

{

}

const int N;

const int W;

const int K;

void Print(std::ostream& out) const

{

out << "N = " << N

<< ", K = " << K

<< ", W = " << W;

}

};

template <typename D>

struct Benchmark_LifeSim : public BenchmarkBase<D>

{

double Run(const BenchmarkParams_LifeSim& params)

{

auto theTime = Time<D>();

auto theWorld = World<D>(theTime, params.W);

auto animals = vector<unique_ptr<Animal<D>>>();

std::mt19937 gen(2015);

std::uniform_int_distribution<int> dist(0,theWorld.Regions.size()-1);

for (int i=0; i<params.N; i++)

{

auto r = theWorld.Regions[dist(gen)].get();

animals.push_back(unique_ptr<Animal<D>>(new Animal<D>(theTime, theWorld, r, i+1)));

}

atomic<int> c(0);

int s = 0;

//for (const auto& e : animals)

//{

// Observe(e->Migrating, [&c] (bool _) {

// c++;

// });

//}

//Observe(theEnvironment.SummerIsComing, [] (int v) {

// printf("=== SUMMER ===\n");

//});

//Observe(theEnvironment.WinterIsComing, [] (int v) {

// printf("=== WINTER ===\n");

//});

// WHEEL IN THE SKY KEEPS ON TURNING

auto t0 = tbb::tick_count::now();

for (int i=0; i<params.K; i++)

{

theTime.NewDay << true;

//s = s + c;

//printf("c %d\n", c);

//c = 0;

}

auto t1 = tbb::tick_count::now();

double d = (t1 - t0).seconds();

//s = s / params.K;

//printf("s %d\n", s);

s = s / params.K;

printf("s/k %d\n", s);

/* std::ofstream logfile;

logfile.open("log.txt");

D::Log().Write(logfile);

logfile.close()*/;

return d;

}

};