use super::TaskData;
use std::cmp::Ordering;

pub struct Solution;

impl Solution {
    const INC_CHECKER: MonotonicChecker = MonotonicChecker {
        max_step: 3,
        order: Ordering::Less,
    };

    const DEC_CHECKER: MonotonicChecker = MonotonicChecker {
        max_step: 3,
        order: Ordering::Greater,
    };

    /// Counts strictly safe sequences: fully increasing or decreasing,
    /// with adjacent elements differing by at most `max_step`.
    pub fn solve_simple(data: &TaskData) -> i32 {
        data.sequences
            .iter()
            .filter(|seq| {
                Self::INC_CHECKER.is_monotonic(seq)
                    || Self::DEC_CHECKER.is_monotonic(seq)
            })
            .count() as _
    }

    /// Counts sequences that are safe either directly or after skipping one element.
    pub fn solve_hard(data: &TaskData) -> i32 {
        data.sequences
            .iter()
            .filter(|seq| {
                Self::INC_CHECKER.is_monotonic_with_skip(seq)
                    || Self::INC_CHECKER.is_monotonic(&seq[1..])
                    || Self::DEC_CHECKER.is_monotonic_with_skip(seq)
                    || Self::DEC_CHECKER.is_monotonic(&seq[1..])
            })
            .count() as _
    }
}

/// Encapsulates monotonicity check logic with a fixed max step and ordering.
#[derive(Copy, Clone)]
struct MonotonicChecker {
    max_step: i32,
    order: Ordering,
}

impl MonotonicChecker {
    /// Checks if sequence is strictly monotonic with configured order and step.
    fn is_monotonic(&self, sequence: &[i32]) -> bool {
        sequence
            .windows(2)
            .all(|pair| self.is_valid_pair(pair[0], pair[1]))
    }

    /// Allows skipping at most one element to restore monotonicity.
    fn is_monotonic_with_skip(&self, sequence: &[i32]) -> bool {
        sequence.len() <= 2 || {
            let first = sequence[0];
            let second = sequence[1];
            let third = sequence[2];

            if self.is_valid_pair(first, second)
                && self.is_monotonic_with_skip(&sequence[1..])
            {
                return true;
            }

            self.is_valid_pair(first, third)
                && self.is_monotonic(&sequence[2..])
        }
    }

    /// Checks if two values satisfy order and max step constraint.
    fn is_valid_pair(&self, a: i32, b: i32) -> bool {
        a.cmp(&b) == self.order && (a - b).abs() <= self.max_step
    }
}