use std::fs;
use std::path::PathBuf;

use clap::Parser;

use itertools::Itertools;
use std::ops::Range;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    input_file: PathBuf,
}

fn main() {
    // Parse CLI arguments
    let cli = Cli::parse();

    // Read file
    let input_text = fs::read_to_string(&cli.input_file)
        .expect(format!("File \"{}\" not found", cli.input_file.display()).as_str());

    let map: Vec> = input_text.lines().map(|r| r.chars().collect()).collect();

    let mut expanding_rows = vec![];
    // Expand rows
    map.iter().enumerate().for_each(|(row_num, r)| {
        if r.iter().filter(|c| **c == '.').count() == r.len() {
            expanding_rows.push(row_num);
        }
    });

    let mut expanding_cols = vec![];

    // Find expanding cols
    for col in 0..map[0].len() {
        // Determine if all '.'
        let expand = map.iter().filter(|row| row[col] == '.').count() == map.len();

        if expand {
            expanding_cols.push(col);
        }
    }

    // Find galaxies
    let mut galaxies: Vec<(usize, usize)> = vec![];
    for (row_num, row) in map.iter().enumerate() {
        for (col_num, char) in row.iter().enumerate() {
            if *char == '#' {
                galaxies.push((row_num.try_into().unwrap(), col_num.try_into().unwrap()));
            }
        }
    }

    println!("Num Galaxies: ({})", galaxies.len());

    println!(
        "Expanding rows: {:?}\tExpanding cols: {:?}",
        expanding_rows, expanding_cols
    );

    // Distance between each pair
    let expansion_1 = 2;
    let expansion_2 = 1_000_000;
    let mut sum_distances_1 = 0;
    let mut sum_distances_2 = 0;
    println!(
        "Total combinations: {}",
        galaxies.iter().tuple_combinations::<(_, _)>().count()
    );
    for (g1, g2) in galaxies.iter().tuple_combinations() {
        let vert_range: Range = if g1.0 < g2.0 {
            (g1.0)..(g2.0)
        } else {
            (g2.0)..(g1.0)
        };
        let horr_range: Range = if g1.1 < g2.1 {
            (g1.1)..(g2.1)
        } else {
            (g2.1)..(g1.1)
        };

        let vert_expansions = expanding_rows
            .iter()
            .filter(|r| vert_range.contains(*r))
            .count();
        let horr_expansions = expanding_cols
            .iter()
            .filter(|r| horr_range.contains(*r))
            .count();
        let expansions = vert_expansions + horr_expansions;

        let distance = vert_range.len() + horr_range.len();

        sum_distances_1 += distance + (expansions * (expansion_1 - 1));
        sum_distances_2 += distance + (expansions * (expansion_2 - 1));
    }

    println!("Total distance: {}", sum_distances_1);
    println!("Part 2 distance: {}", sum_distances_2);
}