//
// Created by trotfunky on 25/04/19.
//

#include "Coinche.h"


std::vector<card> generate_cards()
{
    std::vector<card> deck;
    deck.reserve(32);

    for(int couleur = Couleur::coeur ; couleur != Couleur::last ; couleur++)
    {
        for(int carte = Force::sept ; carte != Force::dernier ; carte++)
        {
            int valeur;
            switch (carte)
            {
                case sept:
                case huit:
                case neuf:
                    valeur = 0;
                    break;
                case dix :
                    valeur = 10;
                    break;
                case valet:
                    valeur = 1;
                    break;
                case dame:
                    valeur = 2;
                    break;
                case roi:
                    valeur = 3;
                    break;
                case as:
                    valeur = 11;
                    break;
                case dernier:
                default:
                    valeur = 0;
            }

            deck.push_back({static_cast<Couleur>(couleur), static_cast<Force>(carte), valeur});
        }
    }

    std::shuffle(deck.begin(),deck.end(),randomDevice);

    return deck;
}

void update_values(Couleur atout, std::vector<card>& deck, std::vector<card>& jeu)
{
    for(card& carte : deck)
    {
        if(carte.couleur == atout)
        {
            if(carte.force == Force::valet)
            {
                carte.value = 20;
            }
            else if(carte.force == Force::neuf)
            {
                carte.value = 14;
            }
        }
    }

    for(card& carte : jeu)
    {
        if(carte.couleur == atout)
        {
            if(carte.force == Force::valet)
            {
                carte.value = 20;
            }
            else if(carte.force == Force::neuf)
            {
                carte.value = 14;
            }
        }
    }
}

card play(card played, std::vector<card>& jeu, Couleur atout)
{
    const card* minGagnant = nullptr;
    const card* minAtout = nullptr;
    const card* minCouleur = nullptr;
    const card* minPerdant = nullptr;

    for(const card& carte : jeu)
    {
        if(carte.couleur == played.couleur)
        {
            if((!minGagnant && carte.value > played.value ) ||
               (minGagnant && carte.value > played.value && carte.value < minGagnant->value))
            {
                minGagnant = &carte;
            }
            else if(!minCouleur || ( carte.value < played.value && carte.value < minCouleur->value) )
            {
                minCouleur = &carte;
            }
        }
        else
        {
            if(carte.couleur == atout)
            {
                if(!minAtout || carte.value < minAtout->value)
                {
                    minAtout = &carte;
                }
            }
            else
            {
                if(!minPerdant || carte.value < minPerdant->value)
                {
                    minPerdant = &carte;
                }
            }
        }
    }

    if(minGagnant)
    {
        return(*minGagnant);
    }
    else if(minCouleur)
    {
        return(*minCouleur);
    }
    else if(minAtout)
    {
        return(*minAtout);
    }
    else
    {
        return(*minPerdant);
    }
}

Couleur pick_atout()
{
    int nbCouleurs;
    for(nbCouleurs = Couleur::coeur; nbCouleurs != Couleur::last ; nbCouleurs++);
    nbCouleurs--;

    std::uniform_int_distribution<int> uniformIntDistribution(0,nbCouleurs);

    return(static_cast<Couleur>(uniformIntDistribution(engine)));
}

bool WonOrLost(card played, card chosen, Couleur atout)
{
    if(played.couleur == chosen.couleur)
    {
        return(chosen.value > played.value);
    }
    else
    {
        return(chosen.couleur == atout);
    }
}



std::ostream& operator<<(std::ostream& ostream, const Couleur& couleur)
{
    std::string str;
    switch (couleur)
    {
        case coeur:
            str = "cœur";
            break;
        case carreau:
            str = "carreau";
            break;
        case pique:
            str = "pique";
            break;
        case trefle:
            str = "trèfle";
            break;
        case last:
        default:
            str = "cassé";
    }
    return ostream << str;
}


std::ostream& operator<<(std::ostream& ostream, const Force& force)
{
    std::string valeur;
    switch (force)
    {
        case sept:
            valeur = "sept";
            break;
        case huit:
            valeur = "huit";
            break;
        case neuf:
            valeur = "neuf";
            break;
        case valet:
            valeur = "valet";
            break;
        case dame:
            valeur = "dame";
            break;
        case roi:
            valeur = "roi";
            break;
        case dix:
            valeur = "dix";
            break;
        case as:
            valeur = "as";
            break;
        case dernier:
        default:
            valeur = "rien";
    }
    return ostream << valeur;
}


std::ostream& operator<<(std::ostream& ostream, const card& card)
{
    std::string prefixe = (card.force == Force::dame ? "une " : "un ");
    return ostream << prefixe << card.force << " de " << card.couleur;
}