#include "dusunce.h"

#include "kagit.h"
#include "gerec.h"
#include "sabit.h"
#include "davranis.h"
#include <iostream>
#include <iterator>
#include <sstream>
#include <algorithm>

using namespace std;

int const insanSecimiAgirligi             = 1000;
int const tutanKagitAgirligi              =  100;
int const valeAgirligi                    =   50;
int const degerliKagitAgirligi            =    2;
int const degerliKagitEsiAgirligi         =    1;
int const cikanKagitAgirligi              =    5;
int const soldakininAlmadigiKagitAgirligi =   16;

Deger degerYap(char karakter)
{
    Deger deger;

    for (Deger i = Deger_ilk; i != Deger_son; ++i)
    {
        if (toupper(karakter) == Deger_goruntu[i])
        {
            deger = i;
            break;
        }
    }

    return deger;
}

void Dusunce_Rastgeleci::fikirBildir_ozel(Fikir & /* fikir */,
                                          Deste const & /* el */,
                                          Deste const & /* yer */)
{}

void Dusunce_TutanKagitci::fikirBildir_ozel(Fikir & fikir,
                                            Deste const & el,
                                            Deste const & yer)
{
    if (!yer.empty())
    {
        Deger const deger = yer.back().deger();
            
        for (size_t i = 0; i != el.size(); ++i)
        {
            Kagit const & kagit = el[i];
                
            if (kagit.deger() == deger)
            {
                fikir[i] += tutanKagitAgirligi;
            }
        }
    }
}

void Dusunce_Valeci::fikirBildir_ozel(Fikir & fikir,
                                      Deste const & el,
                                      Deste const & yer)
{
    for (size_t i = 0; i != el.size(); ++i)
    {
        Kagit const & kagit = el[i];

        if (kagit.deger() == Deger_vale)
        {
            fikir[i] += (yer.empty()
                         ? -valeAgirligi
                         : +valeAgirligi);
        }
    }
}

bool degerliKagit(Kagit const & kagit)
{
    return (guzelKagit(kagit)
            ||
            (kagit.deger() == Deger_as)
            ||
            (kagit.deger() == Deger_vale));
}

void Dusunce_DegerliKagitci::fikirBildir_ozel(Fikir & fikir,
                                              Deste const & el,
                                              Deste const & yer)
{
    for (size_t i = 0; i != el.size(); ++i)
    {
        Kagit const & kagit = el[i];
            
        if (degerliKagit(kagit))
        {
            fikir[i] += ((!yer.empty()
                          &&
                          (kagit.deger() == yer.back().deger()))

                         ? +degerliKagitAgirligi
                         : -degerliKagitAgirligi);
        }
    }
}

bool degerliKagitEsi(Kagit const & kagit)
{
    Deger const deger = kagit.deger();

    return (!guzelKagit(kagit)
            &&
            ((deger == Deger_on)
             ||
             (deger == Deger_iki)));
}

void Dusunce_DegerliKagitEsci::fikirBildir_ozel(Fikir & fikir,
                                                Deste const & el,
                                                Deste const & yer)
{
    for (size_t i = 0; i != el.size(); ++i)
    {
        Kagit const & kagit = el[i];
            
        if (degerliKagitEsi(kagit))
        {
            fikir[i] += ((!yer.empty()
                          &&
                          (kagit.deger() == yer.back().deger()))

                         ? +degerliKagitEsiAgirligi
                         : -degerliKagitEsiAgirligi);
        }
    }
}

void Dusunce_KagitSayici::saydiklariniGoster()
{
    for (CikanKagitlar::iterator it = cikanKagitlar_.begin();
         it != cikanKagitlar_.end();
         ++it)
    {
        cout << "  " << it->first
             << ',' << it->second;
    }
}
    
void Dusunce_KagitSayici::fikirBildir_ozel(Fikir & fikir,
                                           Deste const & el,
                                           Deste const & /* yer */)
{
    for (size_t i = 0; i != el.size(); ++i)
    {
        Deger const deger = el[i].deger();

        fikir[i] += cikanKagitlar_[deger] * cikanKagitAgirligi;
    }
}

void Dusunce_KagitSayici::yeniDeste()
{
    gorulenler_.clear();
        
    for (Deger deger = Deger_ilk; deger != Deger_son; ++deger)
    {
        cikanKagitlar_[deger] = 0;
    }
}

void Dusunce_KagitSayici::gor(Kagit const & kagit)
{
    if (gorulenler_.find(kagit) == gorulenler_.end())
    {
        gorulenler_.insert(kagit);
        ++cikanKagitlar_[kagit.deger()];
    }
        
    if (kagitSaymayiGoster)
    {
        saydiklariniGoster();
    }
}

void Dusunce_SoldakineDikkatEden::fikirBildir_ozel(Fikir & fikir,
                                                   Deste const & el,
                                                   Deste const & /* yer */)
{
    for (size_t i = 0; i != el.size(); ++i)
    {
        if (find(almadiklari_.begin(),
                 almadiklari_.end(),
                 el[i].deger()) != almadiklari_.end())
        {
            fikir[i] += soldakininAlmadigiKagitAgirligi;
        }
    }
}

void Dusunce_SoldakineDikkatEden::yeniEl()
{
    almadiklari_.clear();
}

void Dusunce_SoldakineDikkatEden::solundakiAlmadi(Kagit const & kagit)
{
    almadiklari_.push_back(kagit.deger());
}

size_t Dusunce_insanaSoran::karariGiristenOku(Fikir const & fikir,
                                              Deste const & el) const
{
    size_t karar = el.size();
        
    while (karar == el.size())
    {
        char karakter;
        cin >> karakter;

        if (karakter == '?')
        {
            cout << "Bence " << *enIyiKagit(fikir, el).first << " ? ";
        }
        else
        {
            Deger const deger(degerYap(karakter));

            boslukBirak(cout,
                        satirBasiParcasi(el).size()
                        + gorunenAdUzunlugu);
            
            for (size_t i = 0; i != el.size(); ++i)
            {
                Kagit const & kagit = el[i];
                
                if (kagit.deger() == deger)
                {
                    karar = i;

                    /*
                      Belki vardir diye, ikili veya onlunun degersiz
                      olanini bulmak icin devam edecegiz
                    */
                    if (!guzelKagit(kagit))
                    {
                        break;
                    }
                }
            }
        }
    }

    return karar;
}
    
void Dusunce_insanaSoran::fikirBildir_ozel(Fikir & fikir,
                                           Deste const & el,
                                           Deste const & /* yer */)
{
    size_t const karar = ((tekKagidiHemenOyna
                           &&
                           (el.size() == 1))
                          ? 0
                          : karariGiristenOku(fikir, el));

    fikir[karar] += insanSecimiAgirligi;
}
    
string Dusunce_insanaSoran::satirBasiParcasi(Deste const & el) const
{
    ostringstream cikis;
    cikis << " [";
    toplulukYazdir(el, cikis, " ");
    cikis << "] ";

    cikis << ((tekKagidiHemenOyna && (el.size() == 1))
              ? "(tek)"
              : "? ");
        
    return cikis.str();
}

void Dusunce_insanaSoran::gor(Kagit const & kagit)
{
    if (kagit.durum() == Kagit::kapali)
    {
        cout << ' ' << kagit << '=';
        Kagit acilan = kagit;
        acilan.durumDegistir(Kagit::acik);
        cout << acilan;
    }
}