If you have rain that falls on a graph how do you figure out which valleys have trapped water with probably the most in-elegant algorithm possible

watertrap.r

fn main() {
    let height: [i8; 12] = [0,1,0,2,1,0,1,3,2,1,2,1];
    let len = height.len();
    let mut left_highest: i8;
    let mut right_highest: i8;
    let mut sum_ground: i8 = 0;
    let mut sum_gwater: i8 = 0;
    let mut gwater_here: i8;
    let mut left_i: usize;
    let mut right_i: usize;
    let mut spill: bool;
    for i in 0..height.len() {
        spill = false;
        println!("i: {}", i);
        if i == 0 { sum_ground += height[i]; } // Square 0 has no water since to the left is empty
        else if i == len-1 { sum_ground += height[i]; } // Last square has no water either since right is empty
        else {
            sum_ground += height[i];
            left_highest = 0;
            right_highest = 0;
            gwater_here = 0;
            // Iterate left and right to try to find highest point that doesnt step down after
            if height[i-1] < height[i] || height[i+1] < height[i] { spill = true; } else {
                left_i = i-1;
                while left_i > 0 {  // you think "i-1..0"?  think again.
                    println!("left_i: {}, left_h: {}, left_highest: {}", left_i, height[left_i], left_highest);
                    if height[left_i] > left_highest {
                        left_highest = height[left_i];
                    } else if height[left_i] < left_highest { // step down left
                        break;
                    }
                    left_i-=1;
                }
                right_i = i+1;
                while right_i < height.len() {
                    println!("right_i: {}, right_h: {}, right_highest: {}", right_i, height[right_i], right_highest);
                    if height[right_i] > right_highest {
                        right_highest = height[right_i];
                    } else if height[right_i] < right_highest { // step down right
                        break;
                    }
                    right_i+=1;
                }
            }
            if !spill { 
                if left_highest > right_highest && right_highest > height[i] {
                    sum_gwater += left_highest;
                    gwater_here = left_highest;
                } 
                if right_highest > left_highest && left_highest > height[i] {
                    sum_gwater += right_highest;
                    gwater_here = right_highest;
                }
                println!("index: {}, height: {}, left: {}, right: {}, gwater_here: {}", i, height[i], left_highest, right_highest, gwater_here);
            } else {
                println!("index: {}, height: {}, spill, gwater_here: {}", i, height[i], gwater_here);
                gwater_here = height[i];
                sum_gwater += gwater_here;
            }
        }
    }
    println!("sum_ground: {}, sum_gwater: {}, water:{}", sum_ground, sum_gwater, sum_gwater-sum_ground);
}