package hearths

import (
    "fmt"
    "deck/deck"
)

type CardStack struct {
    cards []deck.Card
}

func (c *CardStack) DrawCardByString(str string) (deck.Card, error) {
    return c.cardByString(str, true)
}

func (c *CardStack) RevealCardByString(str string) (deck.Card, error) {
    return c.cardByString(str, false)
}

// Expects string like "Ts" or "2h" (1. face 2. suit)
func (c *CardStack) cardByString(str string, rm bool) (deck.Card, error) {
    if len(str) < 2 {
        return deck.Card{}, fmt.Errorf("Card string too short")
    }
    face := string(str[0])
    suit := string(str[1])

    for i, card := range c.cards {
        if card.FaceName() == face && card.SuitName() == suit {
            return c.cardByIndex(i, rm)
        }
    }
    return deck.Card{}, fmt.Errorf("Card not found")
}

func (c *CardStack) DrawCard(card deck.Card) (deck.Card, error) {
    return c.findCard(card, true)
}

func (c *CardStack) RevealCard(card deck.Card) (deck.Card, error) {
    return c.findCard(card, false)
}

// Expects string like "Ts" or "2h" (1. face 2. suit)
func (c *CardStack) findCard(cc deck.Card, rm bool) (deck.Card, error) {
    for i, card := range c.GetCards() {
        if cc == card {
            return c.cardByIndex(i, rm)
        }
    }
    return deck.Card{}, fmt.Errorf("Card not found")
}

func (c *CardStack) cardByIndex(n int, rm bool) (deck.Card, error) {
    if n > len(c.GetCards()) {
        return deck.Card{}, fmt.Errorf("Index out of bounds")
    }

    card := c.GetCards()[n]
    if rm {
        c.SetCards(append(c.GetCards()[:n], c.GetCards()[n+1:]...))
    }
    return card, nil
}

func (c *CardStack) HasCards(cards []deck.Card) ([]deck.Card, error) {
    return c.getCardsSlice(cards, false)
}

func (c *CardStack) DrawCards(cards []deck.Card) ([]deck.Card, error) {
    return c.getCardsSlice(cards, true)
}

// Returns cards that are missing
func (c *CardStack) getCardsSlice(cards []deck.Card, rm bool) ([]deck.Card, error) {
    var err error
    var returnc = []deck.Card{}
    for _, card := range cards {
        fmt.Println("BEFORE c.findCard(cards): ")
        deck.PrintCards(cards)
        _, err = c.findCard(card, rm)
        fmt.Println("AFTER c.findCard(cards): ")
        deck.PrintCards(cards)
        if err != nil {
            return returnc, err
        }
    }
    return returnc, nil
}

func (c *CardStack) AppendCard(card deck.Card) error {
    _, err := c.RevealCardByString(card.Name())
    if err == nil {
        return fmt.Errorf("Card already in the stack. Appending not possible")
    }

    c.SetCards(append(c.GetCards(), card))
    return nil
}

func (c *CardStack) AppendCards(cards []deck.Card) error {
    var err error
    var appended []deck.Card

    for _, card := range cards {
        err = c.AppendCard(card)
        if err != nil {
            // Reset to initial state
            for _, toRm := range appended {
                c.DrawCard(toRm)
            }
            return err
        } else {
            appended = append(appended, card)
        }
    }
    return nil
}

func (c CardStack) SubStack(from int, to int) (CardStack, error) {
    counted := c.Count()
    if from < 0 || from > counted {
        return CardStack{}, fmt.Errorf("From value is malformed")
    }
    if to < 0 || to > counted {
        return CardStack{}, fmt.Errorf("To value is malformed")
    }
    newCs := CardStack{}
    newCs.SetCards(c.cards[from:to])
    return newCs, nil
}

func (c *CardStack) SetCards(cards []deck.Card) {
    c.cards = cards
}

func (c *CardStack) GetCards() []deck.Card {
    return c.cards
}

func (c *CardStack) Count() int {
    return len(c.cards)
}

func (c *CardStack) Print() {
    deck.PrintCards(c.GetCards())
}

// Middle pile
type Pile struct {
    cards CardStack
}

func (p *Pile) Count() int {
    return p.cards.Count()
}

func (p *Pile) Next() int {
    return p.Count()
}

func (p *Pile) NeedsMore() bool {
    return p.Count() < 4
}

func (p *Pile) Print() {
    p.cards.Print()
}