use core::fmt;

/// This is the implementation of a Card. 
/// Smart card! ;-) Can do a few things by herself.

#[derive(Debug)]
/// A playing Card. Knows its face `value` 
/// and the punishment `points` (in the game 
/// these are symbolised by little bull heads).
pub struct Card {
    pub value: i8,
    pub points: i8,
}

impl Card {
    /// Generate a new card with the face `value` parameter.
    /// Calculates the `points` for the value.
    pub fn new(value: i8)->Self {

        let mut points = 0;
        if value % 10 == 5 {
            // ends with 5 = 2 point
            points = 2;
            // println!("*5 add 1, val={}, pt={}", value, points);
        }

        if value % 10 == 0 {
            // ends with 0 = 3 point
            points = 3;
            // println!("*0 add 2, val={}, pt={}", value, points);
        }

        if value % 10 == value / 10 {
            // same numbers = 5 points (11,22,33... but 55=7)
            points += 5;
            // println!("NN add 5, val={}, pt={}", value, points);
        }

        if points == 0 {
            // rest of the cards are 1 point
            points = 1;
        }

        // Return a Card
        Card {
            value,
            points,
        }
    }
}

impl fmt::Display for Card {
    /// Print formatter for a card, so it can be written in `println!()`
    fn fmt( &self, f: &mut fmt::Formatter ) -> fmt::Result {
        write!(f, "(Card {}, points {})", self.value, self.points)
    }
}

impl PartialEq for Card {
    /// This is used for sorting cards.
    fn eq(&self, other: &Self) -> bool {
        self.value == other.value
    }
}

/// This is used for sorting cards. Eq is required some by some strict sorting methods.
impl Eq for Card {} 

impl PartialOrd for Card {
    /// This is used for sorting cards.
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        match self.value.partial_cmp(&other.value) {
            Some(core::cmp::Ordering::Equal) => {None}
            ord => return ord,
        }
    }
}

/// This is used for sorting cards. Ord (and Eq) is required some by some strict sorting methods.
impl Ord for Card {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.value.cmp(&other.value)
    }
}