#[derive(Clone, Copy)]
pub struct BatchRef<T: UIElement> {
	index: usize,
	ty: PhantomData<T>,
}

ui_element!(Batch {
	width: f64,
	height: f64,

	elements: Vec<Element>
});

impl Batch {
	base_impl!();

	pub fn new(x: f64, y: f64, w: f64, h: f64) -> Batch {
		ui_create!(Batch {
			x: x,
			y: y,
			width: w,
			height: h,

			elements: Vec::new()
		})
	}

	fn update(&mut self, _: &mut render::Renderer) {}

	fn draw(&mut self, renderer: &mut render::Renderer, r: &Region, width: f64, height: f64, delta: f64) -> &Vec<u8> {
		if self.dirty {
			self.dirty = false;
			self.data.clear();

			let sx = r.w / self.width;
			let sy = r.h / self.height;

			for e in &mut self.elements {
				let reg = Container::get_draw_region_raw(e, sx, sy, r);
				e.set_dirty(true);
				self.data.extend(e.draw(renderer, &reg, width, height, delta));
			}
		}
		&self.data
	}

	pub fn get_size(&self) -> (f64, f64) {
		(self.width, self.height)
	}

	pub fn add<T: UIElement>(&mut self, e: T) -> BatchRef<T> {
		self.elements.push(e.wrap());
		BatchRef { index: self.elements.len() - 1, ty: PhantomData }
	}

	pub fn get<T: UIElement>(&self, r: BatchRef<T>) -> &T {
		T::unwrap_ref(&self.elements[r.index])
	}

	pub fn get_mut<T: UIElement>(&mut self, r: BatchRef<T>) -> &mut T {
		self.dirty = true;
		T::unwrap_ref_mut(&mut self.elements[r.index])
	}

	pub fn get_mut_at<T: UIElement>(&mut self, index: usize) -> &mut T {
		self.dirty = true;
		T::unwrap_ref_mut(&mut self.elements[index])
	}

	pub fn len(&self) -> usize {
		self.elements.len()
	}

	lazy_field!(width, f64, get_width, set_width);
	lazy_field!(height, f64, get_height, set_height);
}

impl UIElement for Batch {
	fn wrap(self) -> Element {
		Element::Batch(self)
	}

	fn unwrap_ref<'a>(e: &'a Element) -> &'a Batch {
		match e {
			&Element::Batch(ref val) => val,
			_ => panic!("Incorrect type"),
		}
	}

	fn unwrap_ref_mut<'a>(e: &'a mut Element) -> &'a mut Batch {
		match e {
			&mut Element::Batch(ref mut val) => val,
			_ => panic!("Incorrect type"),
		}
	}
}