#include "card_stack.h"
#include "card_handling.h"
#include "client.h"

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

void init_stack(player_cards *deck)
{
    *deck = NULL;
}

void push_stack(player_cards *deck, char *str)
{
    struct card_stack_item *tmp = malloc(sizeof(struct card_stack_item));
    tmp->str = str;
    tmp->tip = ' ';
    tmp->is_usable = 0;
    tmp->next = *deck;
    *deck = tmp;
}

void clear_stack(player_cards *deck)
{
    struct card_stack_item *tmp;

    while(*deck) {
        tmp = *deck;
        *deck = tmp->next;
        if(tmp->str)
            free(tmp->str);
        free(tmp);
    }
}

int is_empty_stack(player_cards deck)
{
    return deck == NULL;
}

#if 0
static int convert_rank_to_int(const char *card)
{
    int length;
    char str_rank[2];

    length = strlen(card);
    /* 10 - the only one of its kind */
    if(length == 3)
        return 10;

    str_rank[0] = card[0];
    str_rank[1] = '\0';

    switch(card[0]) {
    case 'J':
        return 11;
    case 'Q':
        return 12;
    case 'K':
        return 13;
    case 'A':
        return 14;
    default:
        return strtol(str_rank, NULL, 10);
    }
    return 0;
}
#endif

void add_hint_letters_stack(player_cards deck)
{
    unsigned char letter = 'a';

    while(deck) {
        deck->tip = letter;
        ++letter;
        if(letter > 'z')
            letter = 'A';
        deck = deck->next;
    }
}

static int check_no_attackers_cards_marked(player_cards deck)
{
    while(deck) {
        if(deck->is_usable)
            return 0;
        deck = deck->next;
    }
    return 1;
}

static void mark_all_card_stack(player_cards deck)
{
    player_cards tmp_deck = deck;

    while(tmp_deck) {
        tmp_deck->is_usable = 1;
        tmp_deck = tmp_deck->next;
    }
}

void mark_card_for_attackers_stack(player_cards deck)
{
    char *card = NULL, *found_card;
    struct card_stack_item *search_deck = NULL;
    int target_rank, found_rank;
    player_cards tmp_begin_deck = deck;

    while(deck) {
        /* is the card already marked? */
        if(deck->is_usable) {
            deck = deck->next;
            continue;
        }
        card = deck->str;
        target_rank = convert_rank_to_int(card);
        search_deck = deck->next;
        while(search_deck) {
            if(search_deck->is_usable) {
                search_deck = search_deck->next;
                continue;
            }
            found_card = search_deck->str;
            found_rank = convert_rank_to_int(found_card);
            if(found_rank == target_rank) {
                deck->is_usable = 1;
                search_deck->is_usable = 1;
            }
            search_deck = search_deck->next;
        }
        deck = deck->next;
    }
    if(check_no_attackers_cards_marked(tmp_begin_deck))
        mark_all_card_stack(tmp_begin_deck);
}
#if 0
static int is_card_beaten(const char *attack_card, const char *defend_card,
                          const char *trump_suit)
{
    int length, attack_rank, defend_rank;
    const char *attack_suit, *defend_suit;

    length = strlen(attack_card);
    attack_suit= attack_card + length - 1;
    length = strlen(defend_card);
    defend_suit = defend_card + length - 1;

    /* suits matched */
    if(!strcmp(attack_suit, defend_suit)) {
        attack_rank = convert_rank_to_int(attack_card);
        defend_rank = convert_rank_to_int(defend_card);
        if(defend_rank > attack_rank)
            return 1;
        /* defender has a trump suit */
    } else if(!strcmp(defend_suit, trump_suit))
        return 1;
    return 0;
}
#endif

void mark_card_for_defenders_stack(player_cards deck,
                                   struct cards_on_table *cot, char *trump_suit)
{
    int i;

    while(deck) {
        for(i = 0; i <= cot->card_arr_idx; ++i)
            if(((i == 0 || !(i % 3)) && cot->card_arr[i+2][0] == '-') &&
                    is_card_beaten(cot->card_arr[i], deck->str, trump_suit))
            {
                deck->is_usable = 1;
                break;
            }
        deck = deck->next;
    }
}
#if 0
static int check_matched_ranks(const char *attack_card,
                               const char *not_defender_card)
{
    int attack_rank, not_defender_rank;

    attack_rank = convert_rank_to_int(attack_card);
    not_defender_rank = convert_rank_to_int(not_defender_card);
    return attack_rank == not_defender_rank;
}
#endif

void mark_card_for_tossing_stack(player_cards deck, struct cards_on_table *cot)
{
    int i;

    while(deck) {
        for(i = 0; i <= cot->card_arr_idx; ++i) {
            if(cot->card_arr[i][0] == '-' || cot->card_arr[i][0] == '\\')
                continue;
            if(check_matched_ranks(cot->card_arr[i], deck->str)) {
                deck->is_usable = 1;
                break;
            }
        }
        deck = deck->next;
    }
}
/* rename: and_unmarked */
char* card_search_by_letter(player_cards deck, int letter)
{
    while(deck) {
        if(deck->tip == letter && deck->is_usable) {
            deck->is_usable = 0;
            return deck->str;
        }
        deck = deck->next;
    }
    return NULL;
}