use embedded_graphics::{pixelcolor::BinaryColor, prelude::*};
use embedded_layout::View;

pub trait Component {
  fn set_top_left(&mut self, top_left: Point);
  fn set_size(&mut self, size: Size);
}

pub struct Frame {
  //drawable: Component,
  pub weight: f32,
}

pub struct VSplit<T, U> {
  pub top_left: Point,
  pub size: Size,
  pub left: T,
  pub right: U,
  pub ratio: f32,
}

impl<T, U> VSplit<T, U> {
  pub fn new(left: T, right: U) -> Self {
    VSplit {
      top_left: Point::new(0, 0),
      size: Size::new(0, 0),
      left,
      right,
      ratio: 0.5,
    }
  }
}

impl<C, T, U> Component for VSplit<T, U>
where
  C: PixelColor + From<BinaryColor>,
  T: Drawable<Color = C>,
  U: Drawable<Color = C>,
{
  fn set_top_left(&mut self, top_left: Point) {
    self.top_left = top_left;
  }
  fn set_size(&mut self, size: Size) {
    self.size = size;
  }
}

impl<C, T, U> Drawable for VSplit<T, U>
where
  C: PixelColor + From<BinaryColor>,
  T: Drawable<Color = C> + Component + Clone,
  U: Drawable<Color = C> + Component + Clone,
{
  type Color = C;
  type Output = ();

  fn draw<D>(&self, target: &mut D) -> Result<Self::Output, D::Error>
  where
    D: DrawTarget<Color = C>,
  {
    let left_width = (self.size.width as f32 * self.ratio) as u32;
    let mut left = self.left.clone();
    left.set_top_left(self.top_left);
    left.set_size(Size::new(self.size.height, left_width));

    let mut right = self.right.clone();
    right.set_top_left(Point::new(left_width as i32, 0));
    right.set_size(Size::new(self.size.height, self.size.width - left_width));

    left.draw(target)?;
    right.draw(target)?;

    Ok(())
  }
}

pub struct HSplit<T> {
  pub top_left: Point,
  pub size: Size,
  pub top: T,
  pub bottom: T,
}