#include "dusuncezinciri.h"

#include "duzey.h"
#include "dusunce.h"
#include <assert.h>
#include <sstream>

using namespace std;

// Girilen dusunce secenegi karakterlerinin her birisine
// karsilik bir dusunce nesnesi yapar ve sonucta bir dusunce
// zinciri olusturur
DusunceZinciri::DusunceZinciri(string const & secenekler)
    :
    insanBarindirir_(false)
{
    for (size_t i = 0; i != secenekler.size(); ++i)
    {
        Duzey const duzey = dusunceYap(secenekler[i]);

        switch (duzey)
        {
        case Duzey_rastgeleAtan:
            dusunceler_.push_back(new Dusunce_Rastgeleci());
            break;
        case Duzey_tutanKagitci:
            dusunceler_.push_back(new Dusunce_TutanKagitci());
            break;
        case Duzey_valeci:
            dusunceler_.push_back(new Dusunce_Valeci());
            break;
        case Duzey_degerliKagitci:
            dusunceler_.push_back(new Dusunce_DegerliKagitci());
            break;
        case Duzey_degerliKagitEsci:
            dusunceler_.push_back(new Dusunce_DegerliKagitEsci());
            break;
        case Duzey_kagitSayici:
            dusunceler_.push_back(new Dusunce_KagitSayici());
            break;
        case Duzey_soldakineDikkatEden:
            dusunceler_.push_back(new Dusunce_SoldakineDikkatEden());
            break;
        case Duzey_insanaSoran:
            insanBarindirir_ = true;
            dusunceler_.push_back(new Dusunce_insanaSoran());
            break;
        default:
        {
            assert(0);
            break;
        }
        }
    }
}

DusunceZinciri::DusunceZinciri(DusunceZinciri const & kaynak)
    :
    insanBarindirir_(kaynak.insanBarindirir_)
{
    transform(kaynak.dusunceler_.begin(),
              kaynak.dusunceler_.end(),
              back_inserter<Dusunceler>(dusunceler_),
              mem_fun(&Dusunce::kopyala));
}

DusunceZinciri::~DusunceZinciri()
{
    // TODO: Bu temizlik yerine boost::shared_ptr kullanilmalidir
    for (size_t i = 0; i != dusunceler_.size(); ++i)
    {
        delete dusunceler_[i];
    }
}

bool DusunceZinciri::insanBarindirir() const
{
    return insanBarindirir_;
}

void DusunceZinciri::yeniEl()
{
    for_each(dusunceler_.begin(),
             dusunceler_.end(),
             mem_fun(&Dusunce::yeniEl));    
}

void DusunceZinciri::yeniDeste()
{
    for_each(dusunceler_.begin(),
             dusunceler_.end(),
             mem_fun(&Dusunce::yeniDeste));
}

    
void DusunceZinciri::fikirBildir(Fikir & fikir,
                                 Deste const & el,
                                 Deste const & yer)
{
    for (size_t i = 0; i != dusunceler_.size(); ++i)
    {
        dusunceler_[i]->fikirBildir(fikir, el, yer);
    }
}    
        
void DusunceZinciri::gor(Kagit const & kagit)
{
    for (size_t i = 0; i != dusunceler_.size(); ++i)
    {
        dusunceler_[i]->gor(kagit);
    }
}

void DusunceZinciri::solundakiAlmadi(Kagit const & kagit)
{
    for (size_t i = 0; i != dusunceler_.size(); ++i)
    {
        dusunceler_[i]->solundakiAlmadi(kagit);
    }
}

string DusunceZinciri::satirBasi(Deste const & el) const
{
    ostringstream cikis;
    for (size_t i = 0; i != dusunceler_.size(); ++i)
    {
        cikis << dusunceler_[i]->satirBasiParcasi(el);
    }
    return cikis.str();
}