use std::{fs, collections::HashMap};

fn main() {
    let input = fs::read_to_string("input.txt").unwrap();
    let mut input: Vec<_> = input.split('\n')
        .map(|line| line.split(' ').collect::<Vec<_>>())
        .collect();

    for line in 0..input.len() {
        let hand = input[line][0];
        if hand == "JJJJJ" {
            input[line].push("7");
            continue;
        }
        let mut card_freq: HashMap<char, i16> = HashMap::new();
        let joker_count: i16 = hand.chars().filter(|c| c == &'J').count().try_into().unwrap();
        for card in hand.chars().filter(|c| c != &'J') {
            card_freq.entry(card)
                .and_modify(|count| *count += 1)
                .or_insert(1);
        }

        // The most helpful place for the jokers will always be with the max card count
        let max = card_freq.clone().into_iter().max_by(|a, b| a.1.cmp(&b.1)).unwrap();
        card_freq.entry(max.0)
            .and_modify(|count| *count += joker_count);

        let mut set_count: HashMap<i16, i16> = HashMap::new();
        for i in 1..=5 {
            let card_count = card_freq.values().filter(|x| **x == i).count().try_into().unwrap();
            if card_count != 0 {
                set_count.insert(i, card_count);
            }
        }

        let power = match set_count {
            x if x.contains_key(&5) => "7",
            x if x.contains_key(&4) => "6",
            x if x.contains_key(&3) && x.contains_key(&2) => "5",
            x if x.contains_key(&3) => "4",
            x if x.get(&2).unwrap_or(&0) >= &2 => "3",
            x if x.get(&2).unwrap_or(&0) == &1 => "2",
            HashMap { .. } => "1"
        };

        input[line].push(power);
    }

    input.sort_by(|lhs, rhs| {
        let lhs_power: i32 = lhs[2].parse().unwrap();
        let rhs_power: i32 = rhs[2].parse().unwrap();
        if lhs_power != rhs_power {
            return lhs_power.cmp(&rhs_power);
        }

        let lhs_hand: Vec<i32> = lhs[0].chars().map(card_value).collect();
        let rhs_hand: Vec<i32> = rhs[0].chars().map(card_value).collect();
        for i in 0..5 {
            if lhs_hand[i] == rhs_hand[i] { continue; }
            return lhs_hand[i].cmp(&rhs_hand[i]);
        }

        panic!("Should not be reachable");
    });


    let mut total_winnings = 0;
    for i in 0..input.len() {
        let bid: usize = input[i][1].parse().unwrap();
        total_winnings += (i + 1) * bid;
    }

    println!("{}", total_winnings);


}


fn card_value(card: char) -> i32 {
    match card {
        'A' => 13,
        'K' => 12,
        'Q' => 11,
        'T' => 10,
        '9' => 9,
        '8' => 8,
        '7' => 7,
        '6' => 6,
        '5' => 5,
        '4' => 4,
        '3' => 3,
        '2' => 2,
        'J' => 1,
        _ => panic!("invalid card")
    }
}

// use std::{fs, collections::HashMap};

// fn main() {
//     let input = fs::read_to_string("input.txt").unwrap();
//     let mut input: Vec<_> = input.split('\n')
//         .map(|line| line.split(' ').collect::<Vec<_>>())
//         .collect();

//     for line in 0..input.len() {
//         let hand = input[line][0];
//         let mut card_freq: HashMap<char, i16> = HashMap::new();
//         for card in hand.chars() {
//             card_freq.entry(card)
//                 .and_modify(|count| *count += 1)
//                 .or_insert(1);
//         }

//         let mut set_count: HashMap<i16, i16> = HashMap::new();
//         for i in 1..=5 {
//             let card_count = card_freq.values().filter(|x| **x == i).count().try_into().unwrap();
//             if card_count != 0 {
//                 set_count.insert(i, card_count);
//             }
//         }

//         let power = match set_count {
//             x if x.contains_key(&5) => "7",
//             x if x.contains_key(&4) => "6",
//             x if x.contains_key(&3) && x.contains_key(&2) => "5",
//             x if x.contains_key(&3) => "4",
//             x if x.get(&2).unwrap_or(&0) >= &2 => "3",
//             x if x.get(&2).unwrap_or(&0) == &1 => "2",
//             HashMap { .. } => "1"
//         };

//         input[line].push(power);
//     }

//     input.sort_by(|lhs, rhs| {
//         let lhs_power: i32 = lhs[2].parse().unwrap();
//         let rhs_power: i32 = rhs[2].parse().unwrap();
//         if lhs_power != rhs_power {
//             return lhs_power.cmp(&rhs_power);
//         }

//         let lhs_hand: Vec<i32> = lhs[0].chars().map(card_value).collect();
//         let rhs_hand: Vec<i32> = rhs[0].chars().map(card_value).collect();
//         for i in 0..5 {
//             if lhs_hand[i] == rhs_hand[i] { continue; }
//             return lhs_hand[i].cmp(&rhs_hand[i]);
//         }

//         panic!("Should not be reachable");
//     });


//     let mut total_winnings = 0;
//     for i in 0..input.len() {
//         let bid: usize = input[i][1].parse().unwrap();
//         total_winnings += (i + 1) * bid;
//     }

//     println!("{}", total_winnings);


// }


// fn card_value(card: char) -> i32 {
//     match card {
//         'A' => 13,
//         'K' => 12,
//         'Q' => 11,
//         'J' => 10,
//         'T' => 9,
//         '9' => 8,
//         '8' => 7,
//         '7' => 6,
//         '6' => 5,
//         '5' => 4,
//         '4' => 3,
//         '3' => 2,
//         '2' => 1,
//         _ => panic!("invalid card")
//     }
// }