use std::fs::read_to_string;

fn main() {
    // store of numbers
    let mut numbers: Vec<i32> = Vec::new();
    // whether the number counts
    let mut numbers_occur: Vec<bool> = Vec::new();
    // spatial information about the data
    // natural number is index in numbers table, negative are special
    let mut adjacency_table: Vec<i32> = Vec::new();
    const EMPTY_SPACE: i32 = -1;
    const SYMBOL: i32 = -2;
    const GEAR: i32 = -3;
    let mut row_counter = 0;
    let mut col_counter = 0;
    for line in read_to_string("input.txt").unwrap().lines() {
        let mut parsing_number = false;
        let mut constructed_number = 0;
        if line.is_empty() {
            break;
        }
        col_counter += 1;
        row_counter = line.len() as i32;
        for c in line.chars() {
            match c {
                '0'..='9' => {
                    let value = c as i32 - '0' as i32;
                    constructed_number = constructed_number * 10 + value;
                    parsing_number = true;
                    adjacency_table.push(numbers.len() as i32);
                }
                _ => {
                    if parsing_number {
                        numbers.push(constructed_number);
                        numbers_occur.push(false);
                        parsing_number = false;
                        constructed_number = 0;
                    }
                    match c {
                        '.' => {
                            adjacency_table.push(EMPTY_SPACE);
                        }
                        '*' => {
                            adjacency_table.push(GEAR);
                        }
                        _ => {
                            adjacency_table.push(SYMBOL);
                        }
                    }
                }
            }
        }
        if parsing_number {
            numbers.push(constructed_number);
            numbers_occur.push(false);
        }
    }
    let mut sum1 = 0;
    let mut sum2 = 0;
    for row in 0 .. row_counter {
        for col in 0 ..col_counter {
            let value = adjacency_table[(row * col_counter + col) as usize];
            if value == SYMBOL || value == GEAR {
                let mut num1 = -1;
                let mut num2 = -1;
                let mut valid_gear = value == GEAR;
                for offset_row in -1..2 {
                    for offset_col in -1..2 {
                        let new_row = row + offset_row;
                        let new_col = col + offset_col;
                        if new_row >= 0 && new_row < row_counter && new_col >= 0 && new_col < col_counter {
                            let new_value = adjacency_table[(new_row * col_counter + new_col) as usize];
                            if new_value >= 0 {
                                numbers_occur[new_value as usize] = true;
                                if value == GEAR {
                                    if num1 == -1 {
                                        num1 = new_value;
                                    } else if num1 != new_value {
                                      if num2 == -1 {
                                          num2 = new_value;
                                      } else if num2 != new_value {
                                          valid_gear = false;
                                      }
                                    }
                                }
                            }
                        }
                    }
                }
                if valid_gear && num1 >= 0 && num2 >= 0 {
                    sum2 += numbers[num1 as usize] * numbers[num2 as usize];
                }
            }
        }
    }
    for i in 0 .. numbers.len() {
        if numbers_occur[i] {
            sum1 += numbers[i];
        }
    }
    println!("Sum1: {}", sum1);
    println!("Sum2: {}", sum2);
}