#include "guloso.h"

Guloso::Guloso() {
}

void Guloso::start(vector<Atividade> atv){
    a = atv;

    sort(a.begin(), a.end(), comp);

    s.push_back(a.at(0));

    resolveAtividades(1);

}

void Guloso::set(vector<Atividade> a, vector<Atividade> s){
    this->a = a;
    this->s = s;
}

int Guloso::resolveAtividades(int atual){
    //cout << "AQUI" << endl;
    int i = 0;
    cout << "atual: " << atual << endl;
    cout << "a.size: " << a.size() << endl;

    // condicao de parada da recursao, chegou na ultima atividade
    if (atual == a.size()){
        return 0;
    }

    /*Localiza a atividade com menor hora de inicio em relação a hora de termino
      da atividade anterior
    */

    i = pSequencial(atual+1, a.at(atual).fim);

    /*Insere a atividade na lista de soluções, caso ela seja encontrada no vetor de
      atividades
      ERRO - Insere a ultima ativiade de qualquer jeito. Consertado_OK
    */

    /*Caso a variável <i> seja igual ou maior que o tamanho do vetor de atividades, significa
       que a última posição não faz parte da solução e o <i> retorna assim: i = s.size(),
       do contrário o valor retornado seria i = s.size()-1 */
    if(i < s.size()){
        s.push_back(a.at(i));
    }

    /*Chama a resolução para uma instância menor. A variável i indica o início da próximam
      pSequencial
    */
    resolveAtividades(i);
    return 1;
}

int Guloso::pSequencial(int atual, int hFimAtual){
    //cout << "AQUI2" << endl;

    /*
      Procura atividade com tempo de inicio maior que o tempo de termino da atividade
      anterior
    */
    cout << atual << endl;
    while(atual < a.size()){
        if(hFimAtual <= a.at(atual).inicio){
            return atual;
        }
        atual++;
    }
    /*
      Retorna a posição da atividade com hora de inicio maior ou igual a hora de termino
      da atividade anterior
    */
    return atual;
}

void Guloso::imprime(){
    this->imprimeSolucao();
}

Guloso::~Guloso() {
}