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

#define ROWS 2
#define COLUMNS 6
#define NUM_OF_CARDS 12
#define CARD_BACK_SYMBOL 88
#define GAMEBOARD_WALLS 124
#define GAMEBOARD_FLOOR_ROOF 45

typedef char symbol, number;
typedef unsigned short unShort;

typedef struct card
{
    number idNumber;
    number cardFacedUp;
    symbol cardBackSymbol;
    symbol cardFaceSymbol;
}memory;

typedef struct player
{
    symbol name[20];
    number points;
    number myTurn;
    number cpu;
}memoryPlayer;

void title(void);
unShort meny(void);
void humanVsCpu(void);
void decideWhoWillStart(memoryPlayer *player1, memoryPlayer *player2);
void defineCards(memory cards[]);
void shuffleCards(memory cards[]);
void defineGameBoard(memory gameBoard[][COLUMNS], memory cards[]);
void printGameBoard(memory gameBoard[][COLUMNS]);
void play(memory gameBoard[][COLUMNS], memoryPlayer *player1, memoryPlayer *player2, number *pairs);
void errorMSG(void);

number quit;

int main(void)
{
    enum {HumVsCpu=1, HumVsHum, Rules, Quit};
    quit=0;

    while(!quit)
    {
        title();
        switch(meny())
        {
            case HumVsCpu:
            {
                printf("You picked Human VS CPU!\n");
                humanVsCpu();

            }
            break;

            case HumVsHum:
            {

            }
            break;

            case Rules:
            {

            }
            break;

            case Quit:
            {
                quit=1;
            }
            break;
        }
    }
    return 0;
}
void title(void)
{
    printf("\t-=The awesome Memory game=-\n"
           "\t---------------------------\n\n");
}
unShort meny(void)
{
    unShort choice;

    do
    {
        printf("[1] - Human VS CPU\n"
               "[2] - Human VS Human\n"
               "[3] - Rules\n"
               "[4] - Quit\n"
               ": ");
        scanf("%hu", &choice);
        getchar();
        fflush(stdin);
        if(choice<1 || choice>4)
        {
            errorMSG();
        }
    }while(choice<1 || choice>4);

    return choice;
}
void humanVsCpu(void)
{
    memory cards[NUM_OF_CARDS];
    memory gameBoard[ROWS][COLUMNS];
    number pairs=NUM_OF_CARDS/2;
    memoryPlayer p1, cpu;


//    p1.name;
    p1.points=0;
    p1.myTurn=0;
    p1.cpu=0;

  //  cpu.name;
    cpu.points=0;
    cpu.myTurn=0;
    cpu.cpu=1;

    defineCards(cards);
    shuffleCards(cards);
    defineGameBoard(gameBoard,cards);
    decideWhoWillStart(&p1, &cpu);
    printGameBoard(gameBoard);
    play(gameBoard, &p1, &cpu, &pairs);

}
void defineCards(memory cards[])
{
    srand(time(NULL));

    unShort numberOfPairs=NUM_OF_CARDS/2;
    symbol pairFaceSymbol[numberOfPairs];
    unShort stepThrou_pairFaceSymbol;
    unShort indexCard;
    symbol setPairSymbol;
    unShort approvedSymbol;

    /* setting random symbols to pairFaceSymbol */
    stepThrou_pairFaceSymbol=0;
    while(stepThrou_pairFaceSymbol<numberOfPairs)
    {
        approvedSymbol=1;
        indexCard=0;
        /* Random symbol between 33-126 */
        setPairSymbol=33+rand()%96;
        /* Se if setPairSymbol contains an approved symbol */
        while(indexCard<numberOfPairs)
        {
            if((setPairSymbol==pairFaceSymbol[indexCard])
               ||(setPairSymbol==GAMEBOARD_FLOOR_ROOF)
               ||(setPairSymbol==GAMEBOARD_WALLS)
               ||(setPairSymbol==CARD_BACK_SYMBOL))
            {
                approvedSymbol=0;
                indexCard=numberOfPairs;
            }
            indexCard++;
        }
        if(approvedSymbol)
        {
            /* Set setPairSymbol to pairFaceSymbol */
            pairFaceSymbol[stepThrou_pairFaceSymbol]=setPairSymbol;
            stepThrou_pairFaceSymbol++;
        }
    }/* END - setting random symbols to pairFaceSymbol */

    /* define cards with symbols back/front and giving
       every card a unique number */
    for(indexCard=0;indexCard<NUM_OF_CARDS;indexCard++)
    {
        cards[indexCard].idNumber=indexCard;
        cards[indexCard].cardFacedUp=0;
        cards[indexCard].cardBackSymbol=CARD_BACK_SYMBOL;
        cards[indexCard].cardFaceSymbol=pairFaceSymbol[indexCard%numberOfPairs];
    }
}

void shuffleCards(memory cards[])
{
    /* Shuffle Cards */
    struct card temp[NUM_OF_CARDS];
    unShort randomNumber=0;
    unShort verifyNumber=0;
    unShort index=0;
    unShort counter=0;
    srand(time(NULL));

    while(counter<NUM_OF_CARDS)
    {
        verifyNumber=1;
        index=0;
        randomNumber=rand()%NUM_OF_CARDS;

        while(index<NUM_OF_CARDS)
        {
            if(randomNumber==temp[index].idNumber)
            {
                verifyNumber=0;
                index=NUM_OF_CARDS;
            }
            index++;
        }
        if(verifyNumber)
        {
            /* Set in the card in temp */
            temp[counter]=cards[randomNumber];
            counter++;
        }
    }
    /* Copy back temp to cards */
    index=0;
    for(index=0;index<NUM_OF_CARDS;index++)
    {
        cards[index]=temp[index];
    }
}
void defineGameBoard(memory gameBoard[][COLUMNS], memory cards[])
{
    unShort gameBoardX, gameBoardY, indexCard;
    indexCard=0;
    for(gameBoardY=0;gameBoardY<ROWS;gameBoardY++)
    {
        for(gameBoardX=0;gameBoardX<COLUMNS;gameBoardX++)
        {
            gameBoard[gameBoardY][gameBoardX]=cards[indexCard];
            indexCard++;
        }
    }

}
void decideWhoWillStart(memoryPlayer *player1, memoryPlayer *player2)
{
    number choicePlayer;
    srand(time(NULL));
    choicePlayer=1+rand()%2; /* choice 1 or 2 */
    if(choicePlayer==1)
    {
        player1->myTurn=1;
    }
    else
    {
        player2->myTurn=1;
    }
}
void printGameBoard(memory gameBoard[][COLUMNS])
{
    unShort gameBoardX, gameBoardY;
    symbol xSymbol, ySymbol;
    ySymbol=49; /* ASCII-code for 1 */
    xSymbol=65; /* ASCII-code for A */
    printf("   ");
    for(xSymbol=65;xSymbol<COLUMNS;xSymbol++)
    {
        printf("%c ", xSymbol);
    }
    printf("\n");
    for(gameBoardY=0, ySymbol=49;gameBoardY<ROWS;gameBoardY++, ySymbol++)
    {
        printf("%c:", ySymbol);
        for(gameBoardX=0;gameBoardX<COLUMNS;gameBoardX++)
        {
            printf(" ");
            if(gameBoard[gameBoardY][gameBoardX].cardFacedUp)
            {
                printf("%c", gameBoard[gameBoardY][gameBoardX].cardFaceSymbol);
            }
            else
            {
                printf("%c", gameBoard[gameBoardY][gameBoardX].cardBackSymbol);
            }
        }
        printf("\n");
    }
}
void play(memory gameBoard[][COLUMNS], memoryPlayer *player1, memoryPlayer *player2, number *pairs)
{
    if(player1->myTurn)
    {
        if(player1->cpu)
        {
            printf("It's CPU's turn\n");
        }
        else
        {
            printf("It's Player1's turn\n");
        }
    }
    else if(player2->myTurn)
    {
        if(player2->cpu)
        {
            printf("It's CPU's turn\n");
        }
        else
        {
            printf("It's Player's turn\n");
        }
    }

}
void errorMSG(void)
{
    printf("Invalid input! Please try again.\n");
}