use crate::aabb::Aabb;

//da algaritum
//lista boxens
//sort by {minx,maxx,miny,maxy,minz,maxz} (6 lists)
//find the sets that minimizes the sum of surface areas
//splitting is done when the minimum split sum of surface areas is larger than the node's own surface area

//start with bisection into octrees because a bad bvh is still 1000x better than no bvh
//sort the centerpoints on each axis (3 lists)
//bv is put into octant based on whether it is upper or lower in each list

pub enum RecursiveContent<R,T>{
	Branch(Vec<R>),
	Leaf(T),
}
impl<R,T> Default for RecursiveContent<R,T>{
	fn default()->Self{
		Self::Branch(Vec::new())
	}
}
pub struct BvhNode<T>{
	content:RecursiveContent<BvhNode<T>,T>,
	aabb:Aabb,
}
impl<T> Default for BvhNode<T>{
	fn default()->Self{
		Self{
			content:Default::default(),
			aabb:Aabb::default(),
		}
	}
}
pub struct BvhWeightNode<W,T>{
	content:RecursiveContent<BvhWeightNode<W,T>,T>,
	weight:W,
	aabb:Aabb,
}

impl<T> BvhNode<T>{
	pub fn the_tester<F:FnMut(&T)>(&self,aabb:&Aabb,f:&mut F){
		match &self.content{
			RecursiveContent::Leaf(model)=>f(model),
			RecursiveContent::Branch(children)=>for child in children{
				//this test could be moved outside the match statement
				//but that would test the root node aabb
				//you're probably not going to spend a lot of time outside the map,
				//so the test is extra work for nothing
				if aabb.intersects(&child.aabb){
					child.the_tester(aabb,f);
				}
			},
		}
	}
	pub fn into_visitor<F:FnMut(T)>(self,f:&mut F){
		match self.content{
			RecursiveContent::Leaf(model)=>f(model),
			RecursiveContent::Branch(children)=>for child in children{
				child.into_visitor(f)
			},
		}
	}
	pub fn weigh_contents<W:Copy+std::iter::Sum<W>,F:Fn(&T)->W>(self,f:&F)->BvhWeightNode<W,T>{
		match self.content{
			RecursiveContent::Leaf(model)=>BvhWeightNode{
				weight:f(&model),
				content:RecursiveContent::Leaf(model),
				aabb:self.aabb,
			},
			RecursiveContent::Branch(children)=>{
				let branch:Vec<BvhWeightNode<W,T>>=children.into_iter().map(|child|
					child.weigh_contents(f)
				).collect();
				BvhWeightNode{
					weight:branch.iter().map(|node|node.weight).sum(),
					content:RecursiveContent::Branch(branch),
					aabb:self.aabb,
				}
			},
		}
	}
}

impl <W,T> BvhWeightNode<W,T>{
	pub const fn weight(&self)->&W{
		&self.weight
	}
	pub const fn aabb(&self)->&Aabb{
		&self.aabb
	}
	pub fn into_content(self)->RecursiveContent<BvhWeightNode<W,T>,T>{
		self.content
	}
	pub fn into_visitor<F:FnMut(T)>(self,f:&mut F){
		match self.content{
			RecursiveContent::Leaf(model)=>f(model),
			RecursiveContent::Branch(children)=>for child in children{
				child.into_visitor(f)
			},
		}
	}
}

pub fn generate_bvh<T>(boxen:Vec<(T,Aabb)>)->BvhNode<T>{
	generate_bvh_node(boxen,false)
}

fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
	let n=boxen.len();
	if force||n<20{
		let mut aabb=Aabb::default();
		let nodes=boxen.into_iter().map(|b|{
			aabb.join(&b.1);
			BvhNode{
				content:RecursiveContent::Leaf(b.0),
				aabb:b.1,
			}
		}).collect();
		BvhNode{
			content:RecursiveContent::Branch(nodes),
			aabb,
		}
	}else{
		let mut sort_x=Vec::with_capacity(n);
		let mut sort_y=Vec::with_capacity(n);
		let mut sort_z=Vec::with_capacity(n);
		for (i,(_,aabb)) in boxen.iter().enumerate(){
			let center=aabb.center();
			sort_x.push((i,center.x()));
			sort_y.push((i,center.y()));
			sort_z.push((i,center.z()));
		}
		sort_x.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
		sort_y.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
		sort_z.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
		let h=n/2;
		let median_x=sort_x[h].1;
		let median_y=sort_y[h].1;
		let median_z=sort_z[h].1;
		//locate a run of values equal to the median
		//partition point gives the first index for which the predicate evaluates to false
		let first_index_eq_median_x=sort_x.partition_point(|&(_,x)|x<median_x);
		let first_index_eq_median_y=sort_y.partition_point(|&(_,y)|y<median_y);
		let first_index_eq_median_z=sort_z.partition_point(|&(_,z)|z<median_z);
		let first_index_gt_median_x=sort_x.partition_point(|&(_,x)|x<=median_x);
		let first_index_gt_median_y=sort_y.partition_point(|&(_,y)|y<=median_y);
		let first_index_gt_median_z=sort_z.partition_point(|&(_,z)|z<=median_z);
		//pick which side median value copies go into such that both sides are as balanced as possible based on distance from n/2
		let partition_point_x=if n.abs_diff(2*first_index_eq_median_x)<n.abs_diff(2*first_index_gt_median_x){first_index_eq_median_x}else{first_index_gt_median_x};
		let partition_point_y=if n.abs_diff(2*first_index_eq_median_y)<n.abs_diff(2*first_index_gt_median_y){first_index_eq_median_y}else{first_index_gt_median_y};
		let partition_point_z=if n.abs_diff(2*first_index_eq_median_z)<n.abs_diff(2*first_index_gt_median_z){first_index_eq_median_z}else{first_index_gt_median_z};
		//this ids which octant the boxen is put in
		let mut octant=vec![0;n];
		for &(i,_) in &sort_x[partition_point_x..]{
			octant[i]+=1<<0;
		}
		for &(i,_) in &sort_y[partition_point_y..]{
			octant[i]+=1<<1;
		}
		for &(i,_) in &sort_z[partition_point_z..]{
			octant[i]+=1<<2;
		}
		//generate lists for unique octant values
		let mut list_list=Vec::with_capacity(8);
		let mut octant_list=Vec::with_capacity(8);
		for (i,(data,aabb)) in boxen.into_iter().enumerate(){
			let octant_id=octant[i];
			let list_id=if let Some(list_id)=octant_list.iter().position(|&id|id==octant_id){
				list_id
			}else{
				let list_id=list_list.len();
				octant_list.push(octant_id);
				list_list.push(Vec::new());
				list_id
			};
			list_list[list_id].push((data,aabb));
		}
		let mut aabb=Aabb::default();
		if list_list.len()==1{
			generate_bvh_node(list_list.remove(0),true)
		}else{
			BvhNode{
				content:RecursiveContent::Branch(
					list_list.into_iter().map(|b|{
						let node=generate_bvh_node(b,false);
						aabb.join(&node.aabb);
						node
					}).collect()
				),
				aabb,
			}
		}
	}
}