#include "AtomicAccumulate.h"

#include <vector>
#include <thread>
#include <iostream>
#include <string>
#include <assert.h>


/* Test code for AtomicAccumulate.h.  Don't include this file in production
 * software.
 * g++ -Wall -O4 -lpthread -ggdb AtomicAccumulate.C
 */


void theadTestHelper(AtomicAccumulate< int > *aa, int count)
{
  for (int i = 0; i < count; i++)
    aa->emplace(i);
}

void threadTest(int count)
{
  AtomicAccumulate< int > aa;
  new std::thread(theadTestHelper, &aa, count);
  int next = 0;
  std::vector< int > counts;
  while (next < count)
  {
    int subCount = 0;
    aa.takeFIFO([&next, &subCount](int remote) {
	subCount++;
	assert(remote == next);
	next++;
      });
    counts.push_back(subCount);
  }
  std::cout<<"threadTest("<<count<<"): ";
  for (int subCount : counts)
    std::cout<<' '<<subCount;
  std::cout<<std::endl;
}

// A simple callback.  You can only consume the data via callbacks.
void dump(std::string &&s)
{
  std::cout<<s;
  s += " :(";
}

int main(int, char**)
{
  threadTest(10000);
  
  AtomicAccumulate< std::string > strings;
  std::string a1 = "Abc";
  std::string a2 = "def";
  std::string a3 = "ghi";
  std::string a4 = "jk!";

  // They should come out in the same order you put them in.
  strings.emplace(a1);
  strings.emplace(a2);
  strings.emplace(a3);
  strings.emplace(a4);
  std::cout<<"FIFO:  ";
  strings.takeFIFO(dump);
  std::cout<<std::endl;

  // As valid as anything.
  std::cout<<"Empty:  ";
  strings.takeFIFO(dump);
  std::cout<<std::endl;

  // They should come out in the reverse order as they went in.  I suspect
  // FIFO will be much more popular.  But LIFO is easy to implement.
  strings.emplace(a4);
  strings.emplace(a3);
  strings.emplace(a2);
  strings.emplace(a1);
  std::cout<<"LIFO:  ";
  strings.takeLIFO(dump);
  std::cout<<std::endl;

  std::cout<<"Empty:  ";
  strings.takeLIFO(dump);
  std::cout<<std::endl;

  // We are calling a constructor with N arguments.
  strings.emplace("Yes or no", 3);
  std::cout<<"YES:  ";
  strings.takeLIFO(dump);
  std::cout<<std::endl;

  // We are calling the move constructor, when appropriate.  This is normally
  // just an optimization.
  strings.emplace(a1);
  strings.emplace(std::move(a2));
  strings.emplace(std::move(a3));
  strings.emplace(a4);
  std::cout<<"Using move constructor:  ";
  strings.takeFIFO(dump);
  std::cout<<std::endl;
  std::cout<<"First and last:  "<<a1<<'.'<<a2<<'.'<<a3<<'.'<<a4<<std::endl;

  // Verify that we are cleaning up.
  class HasDestructor
  {
  private:
    const std::string _value;
    HasDestructor(HasDestructor const &) = delete;
    void operator =(HasDestructor const &) = delete;
  public:
    HasDestructor(std::string const &value) : _value(value) { }
    ~HasDestructor() { std::cout<<"~HasDestructor("<<_value<<")"<<std::endl; }
    std::string const &getValue() const { return _value; }
  };

  AtomicAccumulate< HasDestructor > as;
  as.emplace("1a");
  as.emplace("1b");
  as.emplace("1c");
  as.takeFIFO([](HasDestructor const &hd) {
      std::cout<<"as.takeFIFO() ➡ "<<hd.getValue()<<std::endl;
    });
  as.takeFIFO([](HasDestructor const &hd) { assert(false); });
  as.takeLIFO([](HasDestructor const &hd) { assert(false); });
  as.emplace("2a");
  as.emplace("2b");
  as.emplace("2c");
  as.takeLIFO([](HasDestructor const &hd) {
      std::cout<<"as.takeLIFO() ➡ "<<hd.getValue()<<std::endl;
    });
  as.emplace("3a");
  as.emplace("3b");
  as.emplace("3c");
  
  return 0;
}

/* Expected results:
FIFO:  Abcdefghijk!
Empty:  
LIFO:  Abcdefghijk!
Empty:  
YES:  Yes
Using move constructor:  Abcdefghijk!
First and last:  Abc...jk!
as.takeFIFO() ➡ 1a
as.takeFIFO() ➡ 1b
as.takeFIFO() ➡ 1c
~HasDestructor(1a)
~HasDestructor(1b)
~HasDestructor(1c)
as.takeLIFO() ➡ 2c
as.takeLIFO() ➡ 2b
as.takeLIFO() ➡ 2a
~HasDestructor(2a)
~HasDestructor(2b)
~HasDestructor(2c)
~HasDestructor(3a)
~HasDestructor(3b)
~HasDestructor(3c)
*/