// https://adventofcode.com/2024/day/2
//
// run command: `cargo run ./input.txt`

use std::env;
use std::error::Error;
use std::fs::File;
use std::io::{BufReader, prelude::*};
use std::str::FromStr;

/// Parse a report into a Vec<T>
fn parse_report<T>(line: &str) -> Result<Vec<T>, <T as FromStr>::Err>
where
    T: FromStr,
{
    let parsed_line = line
        .split(char::is_whitespace)
        .map(|v| v.parse())
        .collect::<Result<Vec<T>, _>>()?;
    Ok(parsed_line)
}

#[derive(Eq, PartialEq, Copy, Clone, Debug)]
enum TransitionState {
    Good, // Good state
    Bad,  // Bad state
          // Dampened,    // Could be removed to make a good state
          // DampenedEnd, // Could be removed to make a good state, end or start of report
}

#[derive(Eq, PartialEq, Copy, Clone, Debug)]
enum TransitionDirection {
    Asc,  // level is increasing
    Desc, // level is decreasing
}

#[derive(Debug)]
struct LevelTransition {
    state: TransitionState,
    direction: TransitionDirection,
}

/// Given two level inputs, return a LevelTransition of the state:
///   - `TransitionState::Bad` if the difference between
///     the levels is either 0 or great than 3
///   - otherwise `TransitionState::Good`
///
///   And direction:
///   - `TransitionDirection::Asc` if the value from curr_level to next_level is increasing
///   - `TransitionDirection::Desc` if the value from curr_level to next_level is decreasing
fn compare_levels(curr_level: i64, next_level: i64) -> LevelTransition {
    let level_diff = next_level - curr_level;

    // If the diff is 0 or greater than 3, return bad state
    let state = if level_diff == 0 || level_diff.abs() > 3 {
        TransitionState::Bad
    } else {
        TransitionState::Good
    };

    // If great than zero they are ascending
    let direction = if level_diff > 0 {
        TransitionDirection::Asc
    } else {
        TransitionDirection::Desc
    };

    return LevelTransition { state, direction };
}

/// Tests if a report is safe
fn is_report_safe_no_dampening(report: &Vec<i64>) -> bool {
    // Turn the report into a bunch of states for each adjacent pair in the report
    let report: Vec<LevelTransition> = report
        .windows(2)
        .map(|l| compare_levels(l[0], l[1]))
        .collect();

    // Setup the loop by checking the first start as a special case
    let mut prev_transition = &report[0];
    if prev_transition.state != TransitionState::Good {
        return false;
    }

    // Check each state
    for level_transition in report[1..].iter() {
        // If bad, then it's just bad
        if level_transition.state != TransitionState::Good {
            return false;
        }

        // If the states aren't the same as the prev, it must
        // have changed direction
        if level_transition.direction != prev_transition.direction {
            return false;
        }

        // Setup for next iteration
        prev_transition = level_transition;
    }
    return true;
}

/// Tests if a report is safe or code be made safe if you remove a single
/// level from the report
fn is_report_safe_with_dampening_brute_force(report: &Vec<i64>) -> bool {
    if is_report_safe_no_dampening(&report) {
        return true;
    }

    // Loop through removing a single level to test all dampening combinations
    for index in 0..report.len() {
        let sub_report = [&report[0..index], &report[index + 1..]].concat();
        if is_report_safe_no_dampening(&sub_report) {
            return true;
        }
    }
    return false;
}

// fn compare_levels_3(prev_level: i64, curr_level: i64, next_level: i64) -> LevelTransition {
//     let first_transition = compare_levels(prev_level, curr_level);
//     let second_transition = compare_levels(curr_level, next_level);
//     if first_transition.state != TransitionState::Good
//         || second_transition.state != TransitionState::Good
//         || first_transition.direction != second_transition.direction
//     {
//         let jump_transition = compare_levels(prev_level, next_level);
//         if jump_transition.state == TransitionState::Good {
//             //println!("Dampening value window: {:?}", window_tuple);
//             // If we removed the middle value, we would be in a SAFE state, mark as DAMPENED
//             LevelTransition {
//                 state: TransitionState::Dampened,
//                 ..jump_transition
//             }
//         } else {
//             // Removing the middle value does not help us. mark as BAD
//             LevelTransition {
//                 state: TransitionState::Bad,
//                 ..jump_transition
//             }
//         }
//     } else {
//         // Both transitions are good and moving in the same directions, so we can return either.
//         second_transition
//     }
// }

// fn is_report_safe_with_dampening(report: Vec<i64>) -> bool {
//     match report.len() {
//         0..=2 => return true,
//         3 => match compare_levels_3(report[0], report[1], report[2]).state {
//             TransitionState::Good | TransitionState::Dampened | TransitionState::DampenedEnd => {
//                 return true;
//             }
//             TransitionState::Bad => return false,
//         },
//         4.. => {
//             let first_transition = compare_levels(report[0], report[1]);
//             let (prev_transition, dampen_cnt) = match first_transition.state {
//                 TransitionState::Bad | TransitionState::Dampened | TransitionState::DampenedEnd => {
//                     // Damnpen first level
//                     let second_transition=compare_levels(report[1], report[2]);
//                     if second_transition.state != TransitionState::Good {
//                         // Already dampened
//                         return false
//                     }
//                     (second_transition, 1)
//                 },
//                 TransitionState::Good => {
//                     let second_transition = compare_levels_3(report[0], report[1], report[2]);
//                 },
//             }

//         }
//     };
// }

// fn is_report_safe_with_dampening(report: Vec<i64>) -> bool {
//     let mut modified_report: Vec<Option<i64>> = vec![None];
//     let mut tmp_report: Vec<Option<i64>> = report.iter().map(|v| Some(*v)).collect();
//     modified_report.append(&mut tmp_report);
//     modified_report.push(None);

//     let mut transitions = Vec::new();
//     for window in modified_report.windows(3) {
//         let window_tuple = (window[0], window[1], window[2]);
//         let state = match window_tuple {
//             // We loop through in 3 value windows. We padded a None on
//             // either side of the vec to detect the ends of the report for special handling.
//             //
//             // If the middle value from the window could be removed to make that section of repo SAFE,
//             //mark as Dempened. We will use this later to determine if there's only a single dampened
//             //value we can remove to meet the dampening criteria.
//             (None, Some(curr), Some(next)) | (Some(curr), Some(next), None) => {
//                 // Matched first or last element, which means we only have one check to do
//                 // and we always return Dampened instead of Bad
//                 let local_transition = compare_levels(curr, next);
//                 if local_transition.state == TransitionState::Bad {
//                     // shadow bad with dampened since can always
//                     // remove the first and last element.
//                     LevelTransition {
//                         state: TransitionState::DampenedEnd,
//                         ..local_transition
//                     }
//                 } else {
//                     local_transition
//                 }
//             }
//             (Some(prev), Some(curr), Some(next)) => compare_levels_3(prev, curr, next),
//             _ => panic!("This should never happen!"),
//         };
//         transitions.push(state);
//     }

//     let (mut dampened_cnt, mut prev_direction) = match transitions[0].state {
//         TransitionState::Good => (0, transitions[0].direction),
//         TransitionState::Dampened | TransitionState::DampenedEnd => (1, transitions[1].direction),
//         TransitionState::Bad => {
//             panic!("This should never happen!");
//         }
//     };
//     for transition in &transitions {
//         match transition.state {
//             TransitionState::Good => {
//                 if transition.direction != prev_direction {
//                     println!(
//                         "Failed for non matching direction: {:?} -> {:?}",
//                         report, transitions
//                     );
//                     return false;
//                 }
//             }
//             TransitionState::Dampened => {
//                 dampened_cnt += 1;
//                 if transition.direction != prev_direction {
//                     println!(
//                         "Failed for non matching direction: {:?} -> {:?}",
//                         report, transitions
//                     );
//                     return false;
//                 }
//             }
//             TransitionState::DampenedEnd => {
//                 dampened_cnt += 1;
//             }
//             TransitionState::Bad => {
//                 // If it's marked as bad we can't fix it by dampening, return false
//                 return false;
//             }
//         }
//         // We can only dampen one value
//         if dampened_cnt > 1 {
//             println!(
//                 "Failed for too much dampening: {:?} -> {:?}",
//                 report, transitions
//             );
//             return false;
//         }
//         prev_direction = transition.direction;
//     }
//     true
// }

fn main() -> Result<(), Box<dyn Error>> {
    // Handle command input
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        panic!(
            "{} must be run with a single argument of files name!",
            &args[0]
        )
    }
    let input_file_string = &args[1];

    let input_file = File::open(input_file_string)?;
    let input_reader = BufReader::new(input_file);

    let mut accumulator_no_dampening = 0;
    let mut accumulator_with_dampening = 0;
    for line in input_reader.lines() {
        let line = line?;
        let parsed_report: Vec<i64> = parse_report(&line)?;
        if is_report_safe_no_dampening(&parsed_report) {
            accumulator_no_dampening += 1;
        }
        if is_report_safe_with_dampening_brute_force(&parsed_report) {
            accumulator_with_dampening += 1;
        }
    }

    println!(
        "Number of SAFE reports (No Dampening - Part 1): {}",
        accumulator_no_dampening
    );
    println!(
        "Number of SAFE reports (With Dampening - Part 2): {}",
        accumulator_with_dampening
    );

    Ok(())
}