use std::fs::File;
use std::io::{BufReader};
use std::io::prelude::*;
use std::collections::HashSet;

fn main(){
    let file = File::open("./input.txt").expect("Read failed");
    let reader = BufReader::new(file);

   let mut line_vec = Vec::new();



    for line in reader.lines(){
        let line_as_string = line.unwrap();
        let split_line = line_as_string.split('|').collect::<Vec<&str>>();
        let input = split_line[0].to_owned();
        let result = split_line[1].to_owned();
        let input_list: Vec<String> = input.split_whitespace().map(|x| x.to_owned()).collect();
        let result_list: Vec<String> = result.split_whitespace().map(|x| x.to_owned()).collect();

        line_vec.push((input_list, result_list));
    }

    let mut easy_values = 0;

    for line in line_vec.iter(){
        let result = line.to_owned().1;

        for res in result {
            let len_res = res.len();
            if len_res == 2 || len_res == 3 || len_res == 4 || len_res == 7 {
                easy_values += 1;
            }
        }
    }
    println!("Easy values: {}", easy_values);

    let mut output_sum = 0;

    for line in line_vec{
        let input = line.0;
        let result = line.1;
        
        let mut segments = ['x'; 7]; // segment mapping
        let mut digits = [""; 10]; //Pos of digits

        digits[1] = input.iter().find(|x| x.len() == 2).unwrap();
        digits[4] = input.iter().find(|x| x.len() == 4).unwrap();
        digits[7] = input.iter().find(|x| x.len() == 3).unwrap();
        digits[8] = input.iter().find(|x| x.len() == 7).unwrap();

        segments[0] = digits[7].chars().find(|x| !digits[1].contains(x.clone() )).unwrap();
        segments[1] = digits[4].chars().find(|&x| 
            !digits[1].contains(x ) && 
            input.iter().all(|digit| digit.len() != 6 || digit.contains(x))
        ).unwrap();
        digits[5] = input.iter().find(|x| x.len() == 5 && x.contains(segments[0]) && x.contains(segments[1])).unwrap();
        segments[2] = digits[1].chars().find(|&x| !digits[5].contains(x)).unwrap();
        segments[5] = digits[1].chars().find(|&x| digits[5].contains(x)).unwrap();

        digits[2] = input.iter().find(|x| x.len() == 5 && x.contains(segments[0]) && x.contains(segments[2]) && !x.contains(segments[5])).unwrap();
        digits[3] = input.iter().find(|x| x.len() == 5 && x.contains(segments[0]) && x.contains(segments[2]) && x.contains(segments[5])).unwrap();
        digits[6] = input.iter().find(|x| x.len() == 6 && !x.contains(segments[2])).unwrap();
        segments[4] = digits[6].chars().find(|&x| !digits[5].contains(x)).unwrap();
        digits[0] = input.iter().find(|x| x.len() == 6 && x.contains(segments[2])&& x.contains(segments[4])).unwrap();
        segments[3] = digits[8].chars().find(|&x| !digits[0].contains(x)).unwrap();
        segments[6] = digits[0].chars().find(|&x| x != segments[0] && x != segments[1] && x != segments[2] && x != segments[4] && x != segments[5]).unwrap();
        digits[9] = input.iter().find(|x| x.len() == 6 && !x.contains(segments[4])).unwrap();

        
        let mut output_value: String = "".to_string();

        for val in &result {
            let mut val_hash = HashSet::new();
            for ch in val.chars() {
                val_hash.insert(ch);
            }


            let index = digits.iter().position(|&r| HashSet::from_iter(r.chars()) == val_hash   ).unwrap();
            println!("Element is {}", index);
            output_value.push_str(&index.to_string());
        }
        
        let output_value_int = output_value.parse::<i32>().unwrap();
        println!("Final Result is {}", output_value_int);
        output_sum += output_value_int;



    }

    println!("Final Final Result is {}", output_sum);

}