#include "values/DnaManager.hpp"
#include "values/mrand.hpp"

void DnaManager::init()
{
  randSeed.a = mrand::getInt();
  randSeed.b = mrand::getInt();
  randSeed.c = mrand::getInt();
  randSeed.d = mrand::getInt();

  vector.resize(NUM_PER_GEN);
  for (std::size_t i = 0; i < NUM_PER_GEN; i++)
  {
    newDna(&vector[i], &randSeed);
    queued.push_back(&vector[i]);
  }
}

void DnaManager::deinit()
{
}

Unit DnaManager::next()
{
  if (queued.empty())
  {
    return {nullptr, Liked::tbd};
  }

  Dna *ret = queued.front();
  queued.pop_front();
  showed.push_back(ret);
  return {ret, Liked::tbd};
}

void DnaManager::like(Unit unit)
{
  Dna *found = nullptr;
  for (auto &&i : showed)
  {
    if (i == unit.dna)
      found = unit.dna;
  }

  if (found == nullptr)
  {
    TraceLog(LOG_ERROR, "NOT FOUND UNIT");
    return;
  }
  if (unit.liked == Liked::yes)
  {
    liked.push_back(found);
  }
  else if (unit.liked == Liked::no)
  {
    disliked.push_back(found);
  }
  else
  {
    TraceLog(LOG_ERROR, "LIKED WITH NO VAULE");
    return;
  }

  showed.remove(found);

  if (showed.size() == 0 && queued.size() == 0)
  {
    newGen();
  }
}

void DnaManager::newGen()
{
  if (liked.size() == 0)
  {
    for (std::size_t i = 0; i < NUM_PER_GEN; i++)
    {
      newDna(&vector[i], &randSeed);
      queued.push_back(&vector[i]);
    }
    disliked.clear();
    return;
  }

  for (auto &&i : liked)
  {
    queued.push_back(i);
  }

  if (liked.size() == 1)
  {
    Dna *front = liked.front();

    for (auto &&i : disliked)
    {
      clone(front, i, &randSeed);
      queued.push_back(i);
    }

    disliked.clear();
    liked.clear();
    return;
  }

  if (liked.size() >= 2)
  {
    for (auto &&i : disliked)
    {
      size_t p1 = mrand::getValue(0, liked.size() - 1, &randSeed);
      size_t p2 = mrand::getValue(0, liked.size() - 1, &randSeed);
      while (p1 == p2)
      {
        p2 = mrand::getValue(0, liked.size(), &randSeed);
      }

      Dna *p1p = liked[p1];
      Dna *p2p = liked[p2];
      makeChild(p1p, p2p, i, &randSeed);
      queued.push_back(i);
    }
  }

  if (queued.size() == NUM_PER_GEN)
  {
    for (auto &&i : queued)
    {
      mutate(i, NUM_OF_MUT, &randSeed);
    }
    return;
  }
}