extern crate arrayfire;

use arrayfire::{Array, Dim4, convolve2};

fn main() {
    let grid = Array::new(&init_grid(), Dim4::new(&[300, 300, 1, 1]));

    let mut max = -99999;
    let mut max_size = 0;
    let mut y_of_max_array = 0;
    let mut x_of_max_array = 0;

    let mut result = vec![0; 90000];

    for size in 1..300 {
        let kernel = arrayfire::constant(1.0, Dim4::new(&[size, size, 1, 1]));

        convolve2(&grid, &kernel, arrayfire::ConvMode::DEFAULT, arrayfire::ConvDomain::AUTO).host(&mut result);

        let mut max_value = -99999;
        let mut max_x = 0;
        let mut max_y = 0;

        for y in (size / 2) as usize..(300 - (size / 2) as usize) {
            for x in (size / 2) as usize..(300 - (size / 2) as usize) {
                if result[y * 300 + x] > max_value {
                    max_value = result[y * 300 + x];
                    max_y = y;
                    max_x = x;
                }
            }
        }

        if max_value > max {
            max = max_value;
            y_of_max_array = max_y;
            x_of_max_array = max_x;
            max_size = size;
        }

        println!("{} {} {}", max_x, max_y, max_value);
    }

    println!("{} {} {}", x_of_max_array, y_of_max_array, max_size);
}

fn init_grid() -> [i32; 90000] {
    let mut grid: [i32; 90000] = [0; 90000];

    for y in 0..300 {
        for x in 0..300 {
            grid[y * 300 + x] = power(x as i32, y as i32);
        }
    }

    grid
}

fn power(x: i32, y: i32) -> i32 {
    let rack_id = x + 10;
    let power_level = (rack_id * y + 7672) * rack_id;
    let partial = (power_level / 100) % 10;
    (partial - 5)
}