use std::env;
use std::fs;
use std::process;
//use std::{thread, time};
use std::collections::HashMap;

fn main() {
    //println!("Hello world!");

    let args: Vec<String> = env::args().collect();
    let path: String;

    if args.len() > 1 {
         path = args[1].clone();
    } else {
        println!("Specify an input file!");
        process::exit(1);
    }

    if ! fs::metadata(path.clone()).is_ok() {
        println!("Path does not exist!");
        process::exit(1);
    }

    //let rawInput = fs::read_to_string(path.clone()).unwrap();
    //let splitInput: Vec<&str> = rawInput.lines().collect();

    let mut left: Vec<i32> = vec![];
    let mut right: Vec<i32> = vec![];

    for line in fs::read_to_string(path.clone()).unwrap().lines() {
        //let line = splitInput[i];
        let split: Vec<&str> = line.split("   ").collect();

        //println!("{}",split[0]);

        left.push(split[0].parse().unwrap());
        right.push(split[1].parse().unwrap());
    }

    left.sort();
    right.sort();

    let mut left_dup = HashMap::new();
    let mut right_dup = HashMap::new();

    // This is kinda ass but I don't care :)
    let mut i: usize = 0;
    while i < left.len() {
        let mut k: usize = i;
        while k < left.len() && left[i] == left[k] {
            k+=1;
        }

        left_dup.insert(left[i],k-i);

        i = k;
    }

    //println!("{}", left_dup[&3]);

    i = 0;
    while i < right.len() {
        let mut k: usize = i;
        while k < right.len() && right[i] == right[k] {
            k+=1;
        }

        right_dup.insert(right[i],k-i);

        i = k;
    }

    //println!("{}", right_dup[&3]);

    let mut accum: i32 = 0;
    for (left, num) in &left_dup {
        let shit = match right_dup.get(left) {
            Some(val) => *val,
            None => 0,
        };
        accum += (*left * (*num as i32)) * (shit as i32);
    }

    println!("Answer: {}", accum);
}