#[derive(Debug, Clone)]
pub struct Domain {
    pub width: usize,
    pub height: usize,
    pub cells: Vec<(f64, f64)>,
    pub enabled: Vec<f64>,
}

impl Domain {
    pub fn empty(width: usize, height: usize) -> Self {
        let grid_size = (width+2)*(height*2);
        let cells = core::iter::repeat_n((0.0, 0.0), grid_size).collect();
        let mut enabled: Vec<f64> = core::iter::repeat_n(1.0, grid_size).collect();

        for x in 0..width+2 {
            *enabled.get_mut(x).unwrap() = 0.0;
            *enabled.get_mut((height+1)*width + x).unwrap() = 0.0;
        }
        for y in 0..height+2 {
            *enabled.get_mut(y*width + 0).unwrap() = 0.0;
            *enabled.get_mut(y*width + width-1).unwrap() = 0.0;
        }

        Domain {
            width,
            height,
            cells,
            enabled
        }
    }

    pub fn get_mut(&mut self, x: usize, y: usize) -> Option<&mut (f64, f64)> {
        self.cells.get_mut((y + 1)*self.width + x + 1)
    }
}

pub fn simulate(start: &mut Domain) {
    let dT: f64 = 1.0 / 30.0;

    for i in 0..25 {
        for y in 1..start.height-1 {
            for x in 1..start.width-1 {
                let own_cell_idx = y * start.width + x;
                let top_cell_idx = (y-1) * start.width + x;
                let right_cell_idx = y * start.width + x + 1;

                let own_cell = start.cells.get(own_cell_idx).copied().unwrap();
                let top_cell = start.cells.get(top_cell_idx).copied().unwrap();
                let right_cell = start.cells.get(right_cell_idx).copied().unwrap();

                let d = right_cell.0 - own_cell.0 + top_cell.1 - own_cell.1;

                let s_right = start.enabled.get(y*start.width+x+1).copied().unwrap();
                let s_left = start.enabled.get(y*start.width+x-1).copied().unwrap();
                let s_top = start.enabled.get((y-1)*start.width+x).copied().unwrap();
                let s_bot = start.enabled.get((y+1)*start.width+x).copied().unwrap();
                let total = s_right + s_left + s_top + s_bot;

                start.cells.get_mut(own_cell_idx).unwrap().0 = own_cell.0 + d*(s_left/total);
                start.cells.get_mut(own_cell_idx).unwrap().1 = own_cell.1 +  d*(s_top/total);

                start.cells.get_mut(right_cell_idx).unwrap().0 = right_cell.0 - d*(s_right/total);
                start.cells.get_mut(top_cell_idx).unwrap().1 = top_cell.1 - d*(s_bot/total);
            }
        }
    }

    // Advaction
    simulate_advaction(start, dT);
}

fn simulate_advaction(start: &mut Domain, dT: f64) {
    for y in 1..start.height-1 {
        for x in 1..start.width-1 {
            let own_cell_idx = y * start.width + x;

            let own_cell = start.cells.get(own_cell_idx).copied().unwrap();

            let u = own_cell.0;

            let v = (own_cell.1 + start.cells.get(y * start.width + x - 1).copied().unwrap().1
                + start.cells.get((y-1) * start.width + x).copied().unwrap().1
                + start.cells.get((y-1) * start.width + x - 1).copied().unwrap().1) / 4.0;

            let prev_x = x as f64 + 0.5 - dT*u;
            let prev_y = y as f64 + 0.5 - dT*v;

            println!("[AD] ({}, {}) --({}, {})--> ({}, {})", x, y, u, v, prev_x, prev_y);

            let cell = (prev_x.round() as usize, prev_y.round() as usize);
            let cell_left = (cell.0 - 1, cell.1);
            let cell_left_top = (cell.0 - 1, cell.1 - 1);
            let cell_top = (cell.0, cell.1 - 1);

            println!("[AD] Right-B {:?} - Left-B {:?} - Right-T {:?} - Left-T {:?}", cell, cell_left, cell_top, cell_left_top);

            let w00 = 1.0 - (prev_x - (cell_left.0 as f64 + 0.5))/1.0;
            let w01 = (prev_x - (cell_left.0 as f64 + 0.5))/1.0;
            let w10 = 1.0 - (prev_y - (cell_left.1 as f64 + 0.5))/1.0;
            let w11 = (prev_y - (cell_left.1 as f64 + 0.5))/1.0;
            println!("W00 {} - W01 {} - W10 {} - W11 {}", w00, w01, w10, w11);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn advaction_x_only() {
        let input = Domain::empty(6, 6);

        let mut target = input.clone();

        target.get_mut(2, 2).unwrap().0 = 1.0;

        println!("{:?}", target);
        simulate_advaction(&mut target, 0.1);
        println!("{:?}", target);

        assert!(false);
    }
}