use num_traits::{identities::One, Num};
use std::{
    cmp::min,
    collections::{hash_map::RandomState, HashSet},
    time::Instant,
};

fn product<T: Num + Copy>(v: &Vec<T>) -> T {
    v.iter().fold(One::one(), |acc, &v_x| acc * v_x)
}

fn naive_solution(k: u32) -> u32 {
    let max_ps = 2 * k;
    let mut numbers = vec![1; k as usize];
    let mut result = u32::MAX;
    let mut idx = k as usize - 1;

    while numbers[0] <= k {
        let p = product(&numbers);
        let s = numbers.iter().sum::<u32>();

        if p == s {
            result = min(result, p);
            return result;
        } else if p > max_ps || s > max_ps {
            idx -= 1;
        } else {
            numbers[idx] += 1;
        }
    }

    return 0;
}

// ChatGPT failing once again
fn _chatgpt_solution(k: u32) -> u32 {
    let mut prod = vec![2 * k; k as usize + 1];
    let mut sums = vec![2 * k; k as usize + 1];

    prod[1] = 1; // product of a single number is 1
    sums[1] = 1; // sum of a single number is 1

    // iterate through all possible combinations of numbers
    for i in 2..k + 1 {
        for j in (i..2 * k + 1).rev() {
            for p in 1..=j - i {
                let q = j - i - p;
                if q >= i && prod[p as usize] <= j / prod[q as usize] {
                    let s = sums[p as usize] + q;
                    if s < sums[j as usize] {
                        sums[j as usize] = s;
                        prod[j as usize] = prod[p as usize] * q;
                    }
                }
            }
        }
    }

    sums[k as usize]
}

fn main() {
    println!("Hello, this is Patrick!");
    let now = Instant::now();

    let max_k = 12;
    let solution = naive_solution;

    let results: Vec<u32> = ((2..=max_k).into_iter().map(|k| solution(k))).collect();
    let hash_results: HashSet<u32, RandomState> = HashSet::from_iter(results.into_iter());
    let result: u32 = hash_results.into_iter().sum();

    println!(
        "The sum of all minimal product-sum numbers for 2 <= k <= {} is: {}",
        max_k, result,
    );

    println!("Time passed: {:?}", Instant::now() - now);
}