use std::io::Read;
use std::collections::HashMap;

use crate::newtypes;
use crate::file::BlockId;
use binrw::{binrw,BinReaderExt,BinWriterExt};
use strafesnet_common::model;
use strafesnet_common::aabb::Aabb;
use strafesnet_common::bvh::{BvhNode,RecursiveContent};
use strafesnet_common::gameplay_modes;

#[derive(Debug)]
pub enum Error{
	InvalidHeader(binrw::Error),
	InvalidMode(newtypes::gameplay_modes::ModeError),
	InvalidBlockId(BlockId),
	InvalidMeshId(model::MeshId),
	InvalidModelId(model::ModelId),
	InvalidTextureId(model::TextureId),
	InvalidData(binrw::Error),
	IO(std::io::Error),
	File(crate::file::Error),
}
impl std::fmt::Display for Error{
	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
		write!(f,"{self:?}")
	}
}
impl std::error::Error for Error{}

/* block types

BLOCK_MAP_HEADER:
DefaultStyleInfo style_info
//bvh goes here
u32 num_nodes
u32 num_spacial_blocks
u32 num_resource_blocks
u32 num_resources_external
//node 0 parent node is implied to be None
for node_id in 1..num_nodes{
	u32 parent_node
}

//NOTE: alternate realities are not necessary.
//portals/wormholes simply use an in-model and and out-model.
//skyboxes are inverted models with a special shader.

//ideally spacial blocks are sorted from distance to start zone
//texture blocks are inserted before the first spacial block they are used in
for spacial_block_id in 0..num_spacial_blocks{
	u32 node_id
	u32 block_id //data block
	Aabb extents
}
//the order of these lists uniquely generates the incremental Ids
//MeshId, TextureId etc. based on resource type
//the first 8 bits of resource_uuid describe the type (mesh, texture, etc)
//if the map file references only external resources, num_resource_blocks = 0
for resource_idx in 0..num_resource_blocks{
	Resource resource_type
	u32 block_id
}
for resource_idx in 0..num_resources_external{
	u128 resource_uuid
}

BLOCK_MAP_RESOURCE:
Resource resource_type
//an individual one of the following:
	- model (Mesh)
	- shader (compiled SPIR-V)
	- image (JpegXL)
	- sound (Opus)
	- video (AV1)
	- animation (Trey thing)

BLOCK_MAP_REGION:
u64 num_models
for model_id in 0..num_models{
	ModelInstance mode_instance
}

*/

//if you hash the resource itself and set the first 8 bits to this, that's the resource uuid
#[binrw]
#[brw(little,repr=u8)]
#[repr(u8)]
enum ResourceType{
	Mesh,
	Texture,
	//Shader,
	//Sound,
	//Video,
	//Animation,
}

struct ResourceMap<T>{
	meshes:HashMap<model::MeshId,T>,
	textures:HashMap<model::TextureId,T>,
}
impl<T> Default for ResourceMap<T>{
	fn default()->Self{
		Self{
			meshes:HashMap::new(),
			textures:HashMap::new(),
		}
	}
}

#[binrw]
#[brw(little)]
struct SpacialBlockHeader{
	id:BlockId,
	extents:newtypes::aabb::Aabb,
}
#[binrw]
#[brw(little)]
struct ResourceBlockHeader{
	resource:ResourceType,
	id:BlockId,
}

#[binrw]
#[brw(little)]
struct MapHeader{
	num_spacial_blocks:u32,
	num_resource_blocks:u32,
	//num_resources_external:u32,
	num_modes:u32,
	num_attributes:u32,
	num_render_configs:u32,
	#[br(count=num_spacial_blocks)]
	spacial_blocks:Vec<SpacialBlockHeader>,
	#[br(count=num_resource_blocks)]
	resource_blocks:Vec<ResourceBlockHeader>,
	//#[br(count=num_resources_external)]
	//external_resources:Vec<ResourceExternalHeader>,
	#[br(count=num_modes)]
	modes:Vec<newtypes::gameplay_modes::NormalizedMode>,
	#[br(count=num_attributes)]
	attributes:Vec<newtypes::gameplay_attributes::CollisionAttributes>,
	#[br(count=num_render_configs)]
	render_configs:Vec<newtypes::model::RenderConfig>,
}

#[binrw]
#[brw(little)]
struct Region{
	//consider including a bvh in the region instead of needing to rebalance the physics bvh on the fly
	model_count:u32,
	#[br(count=model_count)]
	models:Vec<(u32,newtypes::model::Model)>,
}

//code deduplication reused in into_complete_map
fn read_region<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<Vec<(model::ModelId,model::Model)>,Error>{
	//load region from disk
	//parse the models and determine what resources need to be loaded
	//load resources into self.resources
	//return Region
	let mut block=file.block_reader(block_id).map_err(Error::File)?;
	let region:Region=block.read_le().map_err(Error::InvalidData)?;
	Ok(region.models.into_iter().map(|(model_id,model)|
		(model::ModelId::new(model_id),model.into())
	).collect())
}
fn read_mesh<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<model::Mesh,Error>{
	let mut block=file.block_reader(block_id).map_err(Error::File)?;
	let mesh:newtypes::model::Mesh=block.read_le().map_err(Error::InvalidData)?;
	Ok(mesh.into())
}
fn read_texture<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<Vec<u8>,Error>{
	let mut block=file.block_reader(block_id).map_err(Error::File)?;
	let mut texture=Vec::new();
	block.read_to_end(&mut texture).map_err(Error::IO)?;
	Ok(texture)
}

pub struct StreamableMap<R:BinReaderExt>{
	file:crate::file::File<R>,
	//this includes every platform... move the unconstrained datas to their appropriate data block?
	modes:gameplay_modes::NormalizedModes,
	//this is every possible attribute... need some sort of streaming system
	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
	//this is every possible render configuration... shaders and such... need streaming
	render_configs:Vec<model::RenderConfig>,
	//this makes sense to keep in memory for streaming, a map of which blocks occupy what space
	bvh:BvhNode<BlockId>,
	//something something resources hashmaps
	resource_blocks:ResourceMap<BlockId>,
	//resource_external:ResourceMap<ResourceId>,
}
impl<R:BinReaderExt> StreamableMap<R>{
	pub(crate) fn new(mut file:crate::file::File<R>)->Result<Self,Error>{
		//assume the file seek is in the right place to start reading a map header
		let header:MapHeader=file.data_mut().read_le().map_err(Error::InvalidHeader)?;
		let modes=header.modes.into_iter().map(TryInto::try_into).collect::<Result<_,_>>().map_err(Error::InvalidMode)?;
		let attributes=header.attributes.into_iter().map(Into::into).collect();
		let render_configs=header.render_configs.into_iter().map(Into::into).collect();
		let bvh=header.spacial_blocks.into_iter().map(|spacial_block|
			(spacial_block.id,spacial_block.extents.into())
		).collect();
		//generate mesh ids and texture ids from resource list order
		let mut resource_blocks=ResourceMap::default();
		for resource_block_header in header.resource_blocks{
			match resource_block_header.resource{
				ResourceType::Mesh=>{
					resource_blocks.meshes.insert(
						//generate the id from the current length
						model::MeshId::new(resource_blocks.meshes.len() as u32),
						resource_block_header.id
					);
				},
				ResourceType::Texture=>{
					resource_blocks.textures.insert(
						model::TextureId::new(resource_blocks.textures.len() as u32),
						resource_block_header.id
					);
				},
			}
		}
		Ok(Self{
			file,
			modes:gameplay_modes::NormalizedModes::new(modes),
			attributes,
			render_configs,
			bvh:strafesnet_common::bvh::generate_bvh(bvh),
			resource_blocks,
			//resource_external:Default::default(),
		})
	}
	pub fn get_intersecting_region_block_ids(&self,aabb:&Aabb)->Vec<BlockId>{
		let mut block_ids=Vec::new();
		self.bvh.sample_aabb(aabb,&mut |&block_id|block_ids.push(block_id));
		block_ids
	}
	pub fn load_region(&mut self,block_id:BlockId)->Result<Vec<(model::ModelId,model::Model)>,Error>{
		read_region(&mut self.file,block_id)
	}
	pub fn load_mesh(&mut self,mesh_id:model::MeshId)->Result<model::Mesh,Error>{
		let block_id=*self.resource_blocks.meshes.get(&mesh_id).ok_or(Error::InvalidMeshId(mesh_id))?;
		read_mesh(&mut self.file,block_id)
	}
	pub fn load_texture(&mut self,texture_id:model::TextureId)->Result<Vec<u8>,Error>{
		let block_id=*self.resource_blocks.textures.get(&texture_id).ok_or(Error::InvalidTextureId(texture_id))?;
		read_texture(&mut self.file,block_id)
	}
	pub fn into_complete_map(mut self)->Result<strafesnet_common::map::CompleteMap,Error>{
		let mut block_ids=Vec::new();
		self.bvh.into_visitor(&mut |block_id|block_ids.push(block_id));
		//count on reading the file in sequential order being fastest
		block_ids.sort_unstable();
		//load all regions
		let mut model_pairs=HashMap::new();
		for block_id in block_ids{
			model_pairs.extend(read_region(&mut self.file,block_id)?);
		}
		let mut models=Vec::with_capacity(model_pairs.len());
		for model_id in 0..model_pairs.len() as u32{
			let model_id=model::ModelId::new(model_id);
			models.push(model_pairs.remove(&model_id).ok_or(Error::InvalidModelId(model_id))?);
		}
		//load all meshes
		let mut meshes=Vec::with_capacity(self.resource_blocks.meshes.len());
		for mesh_id in 0..self.resource_blocks.meshes.len() as u32{
			let mesh_id=model::MeshId::new(mesh_id);
			let block_id=self.resource_blocks.meshes[&mesh_id];
			meshes.push(read_mesh(&mut self.file,block_id)?);
		};
		//load all textures
		let mut textures=Vec::with_capacity(self.resource_blocks.textures.len());
		for texture_id in 0..self.resource_blocks.textures.len() as u32{
			let texture_id=model::TextureId::new(texture_id);
			let block_id=self.resource_blocks.textures[&texture_id];
			textures.push(read_texture(&mut self.file,block_id)?);
		}
		Ok(strafesnet_common::map::CompleteMap{
			modes:self.modes,
			attributes:self.attributes,
			meshes,
			models,
			textures,
			render_configs:self.render_configs,
		})
	}
}

// silly redefinition of Bvh for determining the size of subnodes
// without duplicating work by running weight calculation recursion top down on every node
pub struct BvhWeightNode<W,T>{
	content:RecursiveContent<BvhWeightNode<W,T>,T>,
	weight:W,
	aabb: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 weigh_contents<T,W:Copy+std::iter::Sum<W>,F:Fn(&T)->W>(node:BvhNode<T>,f:&F)->BvhWeightNode<W,T>{
	let (content,aabb)=node.into_inner();
	match content{
		RecursiveContent::Leaf(model)=>BvhWeightNode{
			weight:f(&model),
			content:RecursiveContent::Leaf(model),
			aabb,
		},
		RecursiveContent::Branch(children)=>{
			let branch:Vec<BvhWeightNode<W,T>>=children.into_iter().map(|child|
				weigh_contents(child,f)
			).collect();
			BvhWeightNode{
				weight:branch.iter().map(|node|node.weight).sum(),
				content:RecursiveContent::Branch(branch),
				aabb,
			}
		},
	}
}

const BVH_NODE_MAX_WEIGHT:usize=64*1024;//64 kB
fn collect_spacial_blocks(
	block_location:&mut Vec<u64>,
	block_headers:&mut Vec<SpacialBlockHeader>,
	sequential_block_data:&mut std::io::Cursor<&mut Vec<u8>>,
	bvh_node:BvhWeightNode<usize,(model::ModelId,newtypes::model::Model)>
)->Result<(),Error>{
	//inspect the node weights top-down.
	//When a node weighs less than the limit,
	//serialize its entire contents into a region block
	if *bvh_node.weight()<BVH_NODE_MAX_WEIGHT{
		let mut models=Vec::new();
		let mut model_count=0;
		let extents=bvh_node.aabb().clone().into();
		bvh_node.into_visitor(&mut |(model_id,model)|{
			model_count+=1;
			models.push((model_id.get(),model));
		});
		let id=BlockId::new(block_headers.len() as u32+1);
		block_headers.push(SpacialBlockHeader{
			id,
			extents,
		});
		let region=Region{
			model_count,
			models,
		};
		binrw::BinWrite::write_le(&region,sequential_block_data).map_err(Error::InvalidData)?;
		block_location.push(sequential_block_data.position());
	}else{
		match bvh_node.into_content(){
			RecursiveContent::Branch(bvh_node_list)=>{
				for bvh_node in bvh_node_list{
					collect_spacial_blocks(block_location,block_headers,sequential_block_data,bvh_node)?;
				}
			},
			RecursiveContent::Leaf(_)=>panic!(),//bvh branches are 20 leaves minimum
		}
	}
	Ok(())
}

/// TODO: Optionally provide a bot that describes the path through the map
/// otherwise sort by distance to start zone
pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::CompleteMap)->Result<(),Error>{
	//serialize models and make a bvh that knows the file size of the branch
	let boxen=map.models.into_iter().enumerate().map(|(model_id,model)|{
		//grow your own aabb
		let mesh=map.meshes.get(model.mesh.get() as usize).ok_or(Error::InvalidMeshId(model.mesh))?;
		let mut aabb=Aabb::default();
		for &pos in &mesh.unique_pos{
			aabb.grow(model.transform.transform_point3(pos).narrow_64().unwrap());
		}
		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
	}).collect::<Result<Vec<_>,_>>()?;
	let bvh=weigh_contents(strafesnet_common::bvh::generate_bvh(boxen),&|_|size_of::<newtypes::model::Model>());
	//build blocks
	//block location is initialized with two values
	//the first value represents the location of the first byte after the file header
	//the second value represents the first byte of the second data block
	//the first data block is always the map header, so the difference is the map header size.
	//this information is filled in later after the sizes are known.
	let mut block_location=vec![0,0];//for file header
	let mut spacial_blocks=Vec::new();//for map header
	let mut sequential_block_data=Vec::new();
	let mut cursor_to_data=std::io::Cursor::new(&mut sequential_block_data);
	collect_spacial_blocks(&mut block_location,&mut spacial_blocks,&mut cursor_to_data,bvh)?;
	let mut block_count=spacial_blocks.len() as u32+1;//continue block id
	let mut resource_blocks=Vec::new();//for map header
	//meshes
	for mesh in map.meshes.into_iter(){
		resource_blocks.push(ResourceBlockHeader{
			resource:ResourceType::Mesh,
			id:BlockId::new(block_count),
		});
		block_count+=1;
		let serializable_mesh:newtypes::model::Mesh=mesh.into();
		binrw::BinWrite::write_le(&serializable_mesh,&mut cursor_to_data).map_err(Error::InvalidData)?;
		block_location.push(cursor_to_data.position());
	}
	//textures
	for mut texture in map.textures.into_iter(){
		resource_blocks.push(ResourceBlockHeader{
			resource:ResourceType::Texture,
			id:BlockId::new(block_count),
		});
		block_count+=1;
		sequential_block_data.append(&mut texture);
		block_location.push(sequential_block_data.len() as u64);
	}
	//build header
	let map_header=MapHeader{
		num_spacial_blocks:spacial_blocks.len() as u32,
		num_resource_blocks:resource_blocks.len() as u32,
		//num_resources_external:0,
		num_modes:map.modes.len() as u32,
		num_attributes:map.attributes.len() as u32,
		num_render_configs:map.render_configs.len() as u32,
		spacial_blocks,
		resource_blocks,
		//external_resources:Vec::new(),
		modes:map.modes.into_iter().map(Into::into).collect(),
		attributes:map.attributes.into_iter().map(Into::into).collect(),
		render_configs:map.render_configs.into_iter().map(Into::into).collect(),
	};
	//probe header length
	let mut map_header_data=Vec::new();
	binrw::BinWrite::write_le(&map_header,&mut std::io::Cursor::new(&mut map_header_data)).map_err(Error::InvalidData)?;

	// calculate final file header
	let mut offset=crate::file::Header::calculate_size(block_count) as u64;
	offset+=map_header_data.len() as u64;
	// priming includes map header
	let priming=offset;
	for position in &mut block_location{
		*position+=offset;
	}
	let file_header=crate::file::Header{
		fourcc:crate::file::FourCC::Map,
		version:0,
		priming,
		resource:0,
		block_count,
		block_location,
	};

	//write (updated) file header
	writer.write_le(&file_header).map_err(Error::InvalidData)?;
	//write map header
	writer.write(&map_header_data).map_err(Error::IO)?;
	//write blocks
	writer.write(&sequential_block_data).map_err(Error::IO)?;
	Ok(())
}
