use std::error::Error;
use std::fmt;
use std::iter::{Enumerate, FusedIterator};
use std::slice;

use crate::item;

#[derive(Clone, Debug, Eq)]
pub struct Storage
{
	base: Vec<u32>,
	total: u64,
}

impl Storage
{
	pub const fn new() -> Self
	{
		Self{base: Vec::new(), total: 0}
	}
	
	pub fn is_empty(&self) -> bool
	{
		self.total == 0
	}
	
	pub fn get_total(&self) -> u64
	{
		self.total
	}
	
	pub fn get(&self, ty: item::Type) -> u32
	{
		match self.base.get(u16::from(ty) as usize)
		{
			None => 0,
			Some(cnt) => *cnt,
		}
	}
	
	pub fn set(&mut self, ty: item::Type, count: u32) -> u32
	{
		let idx = u16::from(ty) as usize;
		match self.base.get_mut(idx)
		{
			None =>
			{
				self.base.resize(idx + 1, 0);
				self.base[idx] = count;
				self.total += count as u64;
				0
			},
			Some(curr) =>
			{
				let prev = *curr;
				self.total = self.total - prev as u64 + count as u64;
				*curr = count;
				prev
			},
		}
	}
	
	pub fn add(&mut self, ty: item::Type, add: u32, max: u32) -> (u32, u32)
	{
		let idx = u16::from(ty) as usize;
		match self.base.get_mut(idx)
		{
			None =>
			{
				let actual = add.min(max);
				self.base.resize(idx + 1, 0);
				self.base[idx] = actual;
				self.total += add as u64;
				(actual, actual)
			}
			Some(curr) =>
			{
				if *curr < max
				{
					let actual = add.min(max - *curr);
					*curr += actual;
					self.total += actual as u64;
					(actual, *curr)
				}
				else {(0, *curr)}
			},
		}
	}
	
	pub fn try_add(&mut self, ty: item::Type, add: u32, max: u32) -> Result<(u32, u32), TryAddError>
	{
		let idx = u16::from(ty) as usize;
		match self.base.get_mut(idx)
		{
			None =>
			{
				if add <= max
				{
					self.base.resize(idx + 1, 0);
					self.base[idx] = add;
					self.total += add as u64;
					Ok((add, add))
				}
				else {Err(TryAddError{ty, have: 0, add, max})}
			},
			Some(curr) =>
			{
				if *curr <= max && max - *curr <= add
				{
					*curr += add;
					self.total += add as u64;
					Ok((add, *curr))
				}
				else {Err(TryAddError{ty, have: *curr, add, max})}
			},
		}
	}
	
	pub fn sub(&mut self, ty: item::Type, sub: u32, min: u32) -> (u32, u32)
	{
		match self.base.get_mut(u16::from(ty) as usize)
		{
			None => (0, 0),
			Some(curr) =>
			{
				if *curr > min
				{
					let actual = sub.min(*curr - min);
					*curr -= actual;
					self.total -= actual as u64;
					(actual, *curr)
				}
				else {(0, *curr)}
			},
		}
	}
	
	pub fn try_sub(&mut self, ty: item::Type, sub: u32, min: u32) -> Result<(u32, u32), TrySubError>
	{
		let idx = u16::from(ty) as usize;
		match self.base.get_mut(idx)
		{
			None => Err(TrySubError{ty, have: 0, sub, min}),
			Some(curr) =>
			{
				if *curr >= min && *curr - min >= sub
				{
					*curr -= sub;
					self.total -= sub as u64;
					Ok((sub, *curr))
				}
				else {Err(TrySubError{ty, have: *curr, sub, min})}
			},
		}
	}
	
	pub fn add_all(&mut self, other: &Storage, max_each: u32) -> (u64, u64)
	{
		let mut added = 0u64;
		if max_each > 0 && other.get_total() > 0
		{
			let mut iter = other.base.iter().enumerate();
			// resize our vector only once and if necessary
			let (last, add_last) = iter.rfind(|(_, n)| **n != 0).unwrap();
			if self.base.len() <= last
			{
				self.base.resize(last + 1, 0);
			}
			// process items by increasing ID
			for (idx, add) in iter
			{
				let curr = self.base[idx];
				if curr < max_each
				{
					let actual = (*add).min(max_each - curr);
					self.base[idx] += actual;
					added += actual as u64;
				}
			}
			// process the final element (which we've retrieved first)
			let curr = self.base[last];
			if curr < max_each
			{
				let actual = (*add_last).min(max_each - curr);
				self.base[last] += actual;
				added += actual as u64;
			}
			// update total
			self.total += added;
		}
		(added, self.total)
	}
	
	pub fn pull_all(&mut self, other: &mut Storage, max_each: u32) -> (u64, u64, u64)
	{
		let mut added = 0u64;
		if max_each > 0 && other.get_total() > 0
		{
			let mut iter = other.base.iter_mut().enumerate();
			// resize our vector only once and if necessary
			let (last, add_last) = iter.rfind(|(_, n)| **n != 0).unwrap();
			if self.base.len() <= last
			{
				self.base.resize(last + 1, 0);
			}
			// process items by increasing ID
			for (idx, add) in iter
			{
				let curr = self.base[idx];
				if curr < max_each
				{
					let actual = (*add).min(max_each - curr);
					self.base[idx] += actual;
					*add -= actual;
					added += actual as u64;
				}
			}
			// process the final element (which we've retrieved first)
			let curr = self.base[last];
			if curr < max_each
			{
				let actual = (*add_last).min(max_each - curr);
				self.base[last] += actual;
				*add_last -= actual;
				added += actual as u64;
			}
			// update totals
			self.total += added;
			other.total -= added;
		}
		(added, self.total, other.total)
	}
	
	pub fn sub_all(&mut self, other: &Storage, min_each: u32) -> (u64, u64)
	{
		let mut subbed = 0u64;
		if self.get_total() > 0 && other.get_total() > 0
		{
			// no need for resizing, we only remove
			// process items by increasing ID
			for (idx, sub) in other.base.iter().enumerate()
			{
				if let Some(curr) = self.base.get(idx)
				{
					if *curr > min_each
					{
						let actual = (*sub).min(*curr - min_each);
						self.base[idx] -= actual;
						subbed += actual as u64;
					}
				}
				else {break;}
			}
			// update total
			self.total -= subbed;
		}
		(subbed, self.total)
	}
	
	pub fn diff_all(&mut self, other: &mut Storage, min_each: u32) -> (u64, u64, u64)
	{
		let mut subbed = 0u64;
		if self.get_total() > 0 && other.get_total() > 0
		{
			// no need for resizing, we only remove
			// consider only indexes present in both
			let end = self.base.len().min(other.base.len());
			let lhs = &mut self.base[..end];
			let rhs = &mut other.base[..end];
			// process items by increasing ID
			for (l, r) in lhs.into_iter().zip(rhs)
			{
				if *l > min_each && *r > min_each
				{
					let actual = (*l - min_each).min(*r - min_each);
					*l -= actual;
					*r -= actual;
					subbed -= actual as u64;
				}
			}
			// update totals
			self.total -= subbed;
			other.total -= subbed;
		}
		(subbed, self.total, other.total)
	}
	
	pub fn iter<'s>(&'s self) -> Iter<'s>
	{
		Iter{base: self.base.iter().enumerate(), all: true}
	}
	
	pub fn iter_nonzero<'s>(&'s self) -> Iter<'s>
	{
		Iter{base: self.base.iter().enumerate(), all: false}
	}
	
	pub fn clear(&mut self)
	{
		self.base.clear()
	}
}

// manual because padding with zeros doesn't affect equality
impl PartialEq for Storage
{
	fn eq(&self, other: &Self) -> bool
	{
		let mut li = self.base.iter().fuse();
		let mut ri = other.base.iter().fuse();
		loop
		{
			match (li.next(), ri.next())
			{
				(None, None) => return true,
				(l, r) =>
				{
					if l.unwrap_or(&0) != r.unwrap_or(&0) {return false;}
				},
			}
		}
	}
}

impl fmt::Display for Storage
{
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
	{
		let mut first = true;
		for (ty, cnt) in self.iter_nonzero()
		{
			if first {first = false;}
			else {f.write_str(", ")?;}
			write!(f, "{cnt} {ty}")?;
		}
		Ok(())
	}
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct TryAddError
{
	pub ty: item::Type,
	pub have: u32,
	pub add: u32,
	pub max: u32
}

impl fmt::Display for TryAddError
{
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
	{
		write!(f, "adding {} {:?} to current {} would exceed {}", self.add, self.ty, self.have, self.max)
	}
}

impl Error for TryAddError {}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct TrySubError
{
	pub ty: item::Type,
	pub have: u32,
	pub sub: u32,
	pub min: u32
}

impl fmt::Display for TrySubError
{
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
	{
		write!(f, "removing {} {:?} from current {} would drop below {}", self.sub, self.ty, self.have, self.min)
	}
}

impl Error for TrySubError {}

#[derive(Clone, Debug)]
pub struct Iter<'l>
{
	base: Enumerate<slice::Iter<'l, u32>>,
	all: bool,
}

impl<'l> Iterator for Iter<'l>
{
	type Item = (item::Type, u32);
	
	fn next(&mut self) -> Option<Self::Item>
	{
		while let Some((idx, cnt)) = self.base.next()
		{
			if *cnt > 0 || self.all
			{
				if let Ok(ty) = item::Type::try_from(idx as u16)
				{
					return Some((ty, *cnt));
				}
			}
		}
		None
	}
	
	fn size_hint(&self) -> (usize, Option<usize>)
	{
		(0, self.base.size_hint().1)
	}
}

impl<'l> FusedIterator for Iter<'l> where Enumerate<slice::Iter<'l, u32>>: FusedIterator {}