use crate::{pixel::Pixel, ser::Source};
use std::{
    io,
    ops::{Index, IndexMut},
};

pub struct Frame {
    pub size: (usize, usize),
    buffer: Vec<Vec<Pixel>>,
}

impl Frame {
    pub fn new(size: (usize, usize)) -> Self {
        Self {
            size,
            buffer: (0..size.0)
                .map(|_| (0..size.1).map(|_| Pixel::default()).collect())
                .collect(),
        }
    }
    pub fn read(source: &mut impl Source, size: (usize, usize)) -> io::Result<Self> {
        let mut frame = Frame::new(size);
        for x in 0..size.0 {
            for y in 0..size.1 {
                let pixel = source.get::<Pixel>()?;
                frame[(x, y)] = pixel;
            }
        }
        Ok(frame)
    }
}

impl Index<(usize, usize)> for Frame {
    type Output = Pixel;
    fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
        &self.buffer[x][y]
    }
}
impl IndexMut<(usize, usize)> for Frame {
    fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut Self::Output {
        &mut self.buffer[x][y]
    }
}

pub struct View<'a> {
    frame: &'a Frame,
    offset: (usize, usize),
    size: (usize, usize),
}

impl<'a> View<'a> {
    pub fn new(frame: &'a Frame, offset: (usize, usize), size: (usize, usize)) -> Self {
        Self {
            frame,
            offset,
            size,
        }
    }
    pub fn diff(&self, rhs: &Self) -> f64 {
        assert_eq!(self.size, rhs.size);
        let mut acc = 0.0;
        for x in 0..self.size.0 {
            for y in 0..self.size.1 {
                let a = self[(x, y)];
                let b = rhs[(x, y)];
                acc += Pixel::distance(a, b);
            }
        }
        acc
    }
}

impl Index<(usize, usize)> for View<'_> {
    type Output = Pixel;
    fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
        &self.frame[(x + self.offset.0, y + self.offset.1)]
    }
}