use std::env::args;
use std::fs::File;
use std::io::BufRead;
use std::io::BufReader;

struct Board {
    pub numbers: [i32; 25],
    pub marks: [bool; 25],
    pub won: bool,
}

fn load_data() -> (Vec<i32>, Vec<Board>) {
    let path = args().nth(1).unwrap();
    let file = File::open(path).unwrap();

    let mut state = 10;
    let mut numbers: Vec<i32> = vec![];
    let mut boards: Vec<Board> = vec![];

    for line in BufReader::new(file).lines() {
        let l = line.unwrap();
        match state {
            10 => {
                numbers = l
                    .split(',')
                    .map(|p| p.parse::<i32>().unwrap())
                    .collect();
                state = 5;
            },
            0|1|2|3|4 => {
                let row: Vec<i32> = l
                    .split_whitespace()
                    .map(|p| p.parse::<i32>().unwrap())
                    .collect();
                for i in 0..row.len() {
                    boards[0].numbers[state * 5 + i] = row[i];
                }

                state += 1;
            },
            5 => {
                assert!(l == "");
                boards.insert(0, Board {
                    numbers: [0; 25],
                    marks: [false; 25],
                    won: false,
                });
                state = 0;
            },
            _ => {
                unreachable!();
            },
        }
    }

    return (numbers, boards);
}

fn score(board: &Board) -> Result<i32, ()> {
    let mut sum = 0;
    for i in 0..25 {
        if !board.marks[i] {
            sum += board.numbers[i];
        }
    }

    for row in 0..5 {
        if
            board.marks[row * 5 + 0]
            && board.marks[row * 5 + 1]
            && board.marks[row * 5 + 2]
            && board.marks[row * 5 + 3]
            && board.marks[row * 5 + 4]
        {
            return Ok(sum);
        }

        if
            board.marks[0 * 5 + row]
            && board.marks[1 * 5 + row]
            && board.marks[2 * 5 + row]
            && board.marks[3 * 5 + row]
            && board.marks[4 * 5 + row]
        {
            return Ok(sum);
        }
    }
    return Err(());
}


fn main() {
    let (numbers, mut boards) = load_data();

    for number in numbers {
        for board in boards.iter_mut() {
            if board.won {
                continue;
            }
            for i in 0..25 {
                if board.numbers[i] == number {
                    board.marks[i] = true;
                }
            }
            match score(board) {
                Ok(v) => {
                    board.won = true;
                    print!("{}\n", v * number);
                },
                Err(_) => {},
            }
        }
    }
}