#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 10
#define MAX_PONTOS 10

typedef struct JOGADOR JOGADOR;
typedef struct CAMPO CAMPO;

struct JOGADOR {
    int num_jogador;
    int pontos;
};

struct CAMPO {
    struct JOGADOR jogadores[MAX];
};

/*novo jogador*/
struct JOGADOR novo_jogador;
/*apontador para  novo jogador*/
struct JOGADOR *ptr_jogador;
/*Array campo jogo e campo prolonagamento*/
struct CAMPO campo[2];
/*apontador para campo jogo e campo prolonagamento */
struct CAMPO *ptr_campo;

/*Prototipos das funções*/
void criar_jogador_no_campo0(void);
void definir_vencedor_ou_empate_jogo(void);
void adicionar_jogadores_empatados_campo1(int, int);
void mostrar_jogadores_no_prolongamento(void);


void criar_jogador_no_campo0(void) {

    int i, j;
    //aponta para campo de jogo
    ptr_campo = &campo[0];

    for (i = 0, j = 0; i < MAX; i++) {
        campo[0] = *(ptr_campo);
        novo_jogador.num_jogador++;
        novo_jogador.pontos = 1 + rand() % MAX_PONTOS;
        ptr_jogador = &novo_jogador;
        campo[0].jogadores[i] = *ptr_jogador;
        *(ptr_campo) = campo[0];
        printf(">> Criando jogador %d com pontos %d no campo[0]...\n",
                ptr_campo->jogadores[i].num_jogador,
                ptr_campo->jogadores[i].pontos);
        j++;
    }

    if (j == MAX) {
        definir_vencedor_ou_empate_jogo();
    }
}


/*Função que determina o vencedor ou prologamento em caso de empate*/
void definir_vencedor_ou_empate_jogo(void) {

    int j, k, m, t;
    int contador = 0;
    int max = 0;

    puts("\n Determinar o jogador vencedor ou em caso empate, irá ao prolongamento...\n");
    //para todos os jogadores
    for (j = 0; j < MAX; j++) {
        //se o jogador listado tiver mais pontos marcados do que max
        if (ptr_campo->jogadores[j].pontos > max) {
            //max = pontos do jogador
            max = ptr_campo->jogadores[j].pontos;
            //contador será igual a um
            contador = 1;
            //se tiver os mesmo pontos que max
        } else if (ptr_campo->jogadores[j].pontos == max) {
            //incrementa o contador
            contador++;
        }
    }//se contador for igual a um
    if (contador == 1) {
        //para todos os jogadores
        for (k = 0; k < MAX; k++) {
            //se o jogador listado tiver mais do que max pontos
            if (ptr_campo->jogadores[k].pontos == max) {
                //o jogador iterado é o vencedor
                printf(">> Jogador %d é o VENCEDOR marcando %d golo(s)...\n\n",
                        ptr_campo->jogadores[k].num_jogador,
                        ptr_campo->jogadores[k].pontos);
            }
        }//caso contrário (contador diferente de um)
    } else {
        //iterar todos os jogadores
        for (m = 0; m < MAX; m++) {
            //se os pontos do jogador listado for igual a max
            if (ptr_campo->jogadores[m].pontos == max) {
                //o jogador iterado faz parte do prolongamento
                printf(">> Jogador %d marcou %d golo(s) e vai para PROLONGAMENTO...\n", 
                        ptr_campo->jogadores[m].num_jogador,
                        ptr_campo->jogadores[m].pontos);
            }
        }
        puts("\n\t\t--- Lista de Jogadores para Prolongamento em situação de empate ---");
        //iterar todos os jogadores
        for (t = 0; t < MAX; t++) {
            //se os pontos do jogador listado for igual a max
            if (ptr_campo->jogadores[t].pontos == max) {
                //o jogador iterado faz parte da lista de jogadores para prolongamento
                adicionar_jogadores_empatados_campo1
                       (ptr_campo->jogadores[t].num_jogador, contador);
            }
        }
    }
}



void adicionar_jogadores_empatados_campo1(int num_jogador, int quant_jogador) {

    int j = 0;
    //aponta para campo de prolongamento
    //*(ptr_campo + 1) = &campo[1]; //-> dá erro

    for (int i = 0; i < MAX; i++) {
        if (num_jogador == ptr_campo->jogadores[i].num_jogador) {
            campo[1] = *(ptr_campo + i);
            campo[1].jogadores[i / 2] = ptr_campo->jogadores[i];
            *(ptr_campo + i) = campo[1];
            printf("\t\t\t Jogador %d: %d golo(s)\n",
                    (ptr_campo+i)->jogadores[i].num_jogador,
                    (ptr_campo+i)->jogadores[i].pontos);
            j++;
        }
    }

    if (j == quant_jogador) {
        //mostra os jogadores no prolongamento
        mostrar_jogadores_no_prolongamento();


    }
}

void mostrar_jogadores_no_prolongamento(void) {
    printf("\n\n--- Ponteiro para Campo 1 ---");
    for (int i = 0; i < MAX / 2; i++) {
        //mostra os valores do novo ponteiro
        printf("\nAponta para ->Jogador %d com pontos %d no campo[1]",
                (ptr_campo + i)->jogadores[i].num_jogador,
                (ptr_campo + i)->jogadores[i].pontos);
    }
}

int main(void) {

    criar_jogador_no_campo0();

    return 0;
}