#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

const int TAM=10;

using namespace std;

                        //VALIDA VETOR PARA CRIAR AS CARTAS EMBARALHADAS >>
                        int valid_vetor(int vet[20] , int rando){
                            int k=0, valid=0;

                        for(k=0;k<20;k++){
                            if(vet[k]==rando || vet[k]==rando+10){
                                valid++;
                        }
                        }
                        if(valid==1){
                            return 3;
                        }
                        else if(valid==2){
                        return 0;
                        }
                        else {
                            return 1;
                        }

                         }
                         //VALIDA VETOR PARA CRIAR AS CARTAS EMBARALHADAS >>



//STRUCT PARA DEFINIR COR PARA CADA CARTA
typedef struct card{
int num[20];
char cor[20];
}card;
//STRUCT PARA DEFINIR COR PARA CADA CARTA



                                //DEFINIMOS O MONTE DE CARTAS
                                typedef struct {
                                    int monte[TAM];
                                    char cor[TAM];
                                    int topo;
                                } TMonte;
                                //DEFINIMOS O MONTE DE CARTAS



                                //INICIAMOS O MONTE EM -1;
                                void TMonte_inicia (TMonte *p){
                                     p->topo = 0;
                                }
                                //INICIAMOS O MONTE EM -1;



                                //VERIFICA SE O MONTE ESTÁ VAZIO
                                int TMonte_vazio(TMonte *p){   //Definimos uma função que recebera a pilha
                                    if(p->topo == 0){      //Verifica se o topo está vazio "-1"
                                        return 1;         // Sim = Retorna 1
                                    }
                                    else {
                                        return 0;         //Não = Retorna 2
                                    }
                                }
                                //VERIFICA SE O MONTE ESTÁ VAZIO



                                //VERIFICA SE O MONTE ESTÁ CHEIO
                                int TMonte_cheio(TMonte *p){   // Criamos uma função que recebe a pilha como parametro em ponteiro
                                    if(p->topo == TAM){    // Verificamos se o topo estiver cheio "tamanho max - 1" ;
                                        return 1;    // Sim = Retorna 1
                                    }
                                    else{
                                        return 0;    // Não = Retorna 2
                                    }
                                }
                                //VERIFICA SE O MONTE ESTÁ CHEIO



                                //INSERIR CARTA AO MONTE
                                void TMonte_inserir(TMonte *p , card *c){  //Passamos a pilha como referencia e um valor
                                    if(TMonte_cheio(p)==0){
                                        p->monte[p->topo]= c->num[p->topo];
                                        p->cor[p->topo]= c->cor[p->topo];
                                        p->topo++;
                                    }
                                }
                                //INSERIR CARTA AO MONTE


//DEFINIMOS A FILA
typedef struct Fila{
    int Ini;
    int Fim;
    int Dados[TAM];
    char Cor[TAM];
    int nItens;
}fila;
//DEFINIMOS A FILA




//INICIA FILA
void cria_fila(fila *f){  //Cria fila iniciando inicio, fim e numero de itens como 0
    f->Ini=0;
    f->Fim=0;
    f->nItens=0;
}
//INICIA FILA


//VERIFICA SE A FILA ESTÁ CHEIA
bool fila_cheia(fila *f){  //Se o numero de itens for igual ao tamanho da fila retorna verdade ou falso
    if(f->nItens==TAM){
        return true;
    }
    else{
        return false;
    }
}
//VERIFICA SE A FILA ESTÁ CHEIA



//VERIFICA SE A FILA ESTA VAZIA
bool fila_vazia(fila *f){  // Verifica se o numero de itens é zero e retorna verdadeiro ou falso
    if(f->nItens==0){
        return true;
    }
    else{
        return false;
    }
}
//VERIFICA SE A FILA ESTA VAZIA

//INSERE NA FILA
void insere(card *c , fila *f, int pos){
    if(!fila_cheia(f)){
        f->Dados[f->Fim] = c->num[pos];
        f->Cor[f->Fim] = c->cor[pos];
    f->Fim++;
    if(f->Fim==TAM){
        f->Fim=0;
    }
    f->nItens++;
    }
    }
//INSERE NA FILA


//REMOVE DA FILA
struct card retira(fila *f){
    card ca;
    ca.cor[1]=f->Cor[f->Ini];
    ca.num[1]=f->Dados[f->Ini];
    f->Ini++;
    if(f->Ini==TAM){
        f->Ini=0;
    }
    f->nItens--;
    return ca;
}

//REMOVE DA FILA


void mostra(fila *f1, fila *f2, TMonte *p, card cm){
    int i=0;
    cout<<" Monte"<<endl;
    for(i=0;i<p->topo;i++){
        printf(" |%d - %c| ", p->monte[i], p->cor[i]);
    }

    int a=f1->nItens;
    int b=f1->Ini;
    cout<<"\n\n Jogador 1"<<endl;
    for(i=0;i<a;i++){
        printf(" |%d - %c| ", f1->Dados[f1->Ini], f1->Cor[f1->Ini]);
        f1->Ini++;
        f1->nItens--;
            if(f1->Ini==TAM){
              f1->Ini=0;
            }
    }
    f1->nItens=a;
    f1->Ini=b;

    int a2=f2->nItens;
    int b2=f2->Ini;
    cout<<"\n\n Jogador 2"<<endl;
    for(i=0;i<a2;i++){
        printf(" |%d - %c| ", f2->Dados[f2->Ini], f2->Cor[f2->Ini]);
        f2->Ini++;
        f2->nItens--;
            if(f2->Ini==TAM){
              f2->Ini=0;
            }
    }
    f2->nItens=a2;
    f2->Ini=b2;

    cout<<"\n\nMesa "<<endl;
    printf(" |%d - %c| ", cm.num[1],cm.cor[1]);
    cout<<endl;
}



//REMOVE CARTA DO MONTE
void TMonte_remove(TMonte *p, card cc, fila *f){          //Definimos função que remove valor
    if(TMonte_vazio(p)==0){  //Verifica se o monte nao estiver vazio
        p->topo--;
        cc.num[1]=p->monte[p->topo];
        cc.cor[1]=p->cor[p->topo];
        insere(&cc,f,1);

    }
}
//REMOVE CARTA DO MONTE

//MAIN
int main(int argc, char const *argv[])
{

int r, controller=0, y=-1;

int vetor[20];

card cc, cm;
bool start=true;
TMonte monte;
TMonte_inicia(&monte);
fila f1, f2;
cria_fila(&f1);
cria_fila(&f2);



srand(time (NULL));

                    //ADICIONAR VALORES AO VETOR
                    while(1){
                    r = (rand() % 10) + 1;
                    controller = valid_vetor(vetor, r);
                    if(controller == 1){
                        vetor[y]=r;
                        y++;
                    }
                    else if(controller == 3 ){
                        vetor[y]=r+10;
                        y++;
                    }

                    if(y==20){
                        break;
                    }
                    }
                    //ADICIONAR VALORES AO VETOR



//CHAMAR FUNÇÃO E ATRIBUIR COR
for(int n=0;n<20;n++){
    if(vetor[n] > 10){
        cc.num[n]=vetor[n];
        cc.num[n]=cc.num[n]-10;
        cc.cor[n]='V';
    }
    else if (vetor[n] <= 10) {
        cc.num[n]=vetor[n];
        cc.cor[n]='A';
    }
}
//CHAMAR FUNÇÃO E ATRIBUIR COR

  for (int im=0; im<=19 ; im++){

    if(im<10){
    TMonte_inserir(&monte, &cc);
    }
    else if(im>=10 && im <= 14){
        insere(&cc, &f1 , im);

    }
    else{
        insere(&cc, &f2 , im);
    }

 }
cm.num[1]=0;
cm.cor[1]='-';
while(1){
mostra(&f1, &f2, &monte, cm);
cout<<"Digite 1 para inciar o jogo:"<<endl;
cout<<"Digite 2 para sair do jogo:"<<endl;
int action=0;
cin>>action;


if(action==2){
    break;
}
if(action==1){

    int t=10;
    while(!TMonte_vazio(&monte)&&!fila_vazia(&f1)&&!fila_vazia(&f2)){

        if(start){
            cm = retira(&f1);
            start=false;
            mostra(&f1, &f2, &monte, cm);
            system("pause");
        }

        if(f2.Cor[f2.Ini]== cm.cor[1] || f2.Dados[f2.Ini] == cm.num[1]){   //FAZ A VERIFICAÇÃO COM A CARTA JA EXISTENTE NA MESA, CASO FOR IGUAL A CARTA DA MESA ASSUME A CARTA DO INICIO DA FILA 2
            cm = retira(&f2);  //GUARDA A CARTA REMOVIDA EM UMA VARIAVEL CM= CARTA DA MESA
        }
        else{  //SE NAAOOOOO
            cc = retira(&f2); //RETIRA A CARTA E GUARDA EM CC
            insere(&cc, &f2, 1); //INSERE NO FINAL DA FILA
            TMonte_remove(&monte, cc, &f2);
        }
        mostra(&f1, &f2, &monte, cm);
        system("pause");

        if(f1.Cor[f1.Ini]== cm.cor[1] || f1.Dados[f1.Ini] == cm.num[1]){   //FAZ A VERIFICAÇÃO COM A CARTA JA EXISTENTE NA MESA, CASO FOR IGUAL A CARTA DA MESA ASSUME A CARTA DO INICIO DA FILA 2
            cm = retira(&f1);  //GUARDA A CARTA REMOVIDA EM UMA VARIAVEL CM= CARTA DA MESA
        }
        else{  //SE NAAOOOOO
            cc = retira(&f1); //RETIRA A CARTA E GUARDA EM CC
            insere(&cc, &f1, 1); //INSERE NO FINAL DA FILA
            TMonte_remove(&monte, cc, &f1);
        }
        mostra(&f1, &f2, &monte, cm);
        system("pause");

        t--;
}

}
}

    return 0;
}