#![feature(const_fn)]
#![allow(unused_parens)]
use std::collections::BTreeMap;
use std::io::SeekFrom;
use std::mem::size_of;
use std::path::Path;
use std::path::PathBuf;

use bincode::deserialize;
use bincode::serialize_into;
use bincode::serialized_size;

use futures::stream::Stream;
use futures::stream::StreamExt;

use serde::de::DeserializeOwned;
use serde::Deserialize;
use serde::Serialize;

use tokio::fs::File;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;

mod error;
pub use error::Error;

#[derive(Debug, Deserialize, Serialize)]
pub struct IndexEntry {
	key: u64,
	position: u64
}

impl IndexEntry {
	fn new(key: u64, position: u64) -> Self /* {{{ */ {
		Self{
			key: key,
			position: position
		}
	} // }}}
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Header {
	key_count: u64,
	index_start_pos: u64
}

pub trait Storable: Serialize + DeserializeOwned {}
impl<T> Storable for T where T: Serialize + DeserializeOwned {}

pub struct Store<T: Storable> /* {{{ */ {
	//path: PathBuf,
	file: File,
	header: Header,
	_nothing: Option<T> // TODO:  How do we get rid of this while keeping our generic parameters?
} // }}}

impl<T: Storable> Store<T> {
	pub async fn new(path: impl AsRef<Path>) -> Result<Self, Error> /* {{{ */ {
		let fd = tokio::fs::OpenOptions::new()
			.read(true)
			.write(true)
			.create(true)
			.append(false)
			.open(path.as_ref())
			.await?;
		Ok(Self{
			//path: path.as_ref().to_path_buf(),
			file: fd,
			header: Header{
				key_count: 0,
				index_start_pos: Self::header_size()
			},
			_nothing: None
		})
	} // }}}

	const fn header_size() -> u64 /* {{{ */ {
		size_of::<Header>() as u64
	} // }}}

	const fn index_entry_size() -> u64 /* {{{ */ {
		size_of::<IndexEntry>() as u64
	} // }}}

	fn index_start_position(&self) -> u64 /* {{{ */ {
		self.header.index_start_pos
	} // }}}

	fn data_start_position(&self) -> u64 /* {{{ */ {
		Self::header_size()
	} // }}}

	async fn get_header(&mut self) -> Result<Header, Error> /* {{{ */ {
		let mut buf = [0u8; Self::header_size() as usize];
		//let mut buf = [0u8; 8];
		self.file.seek(SeekFrom::Start(0)).await?;
		self.file.read(&mut buf).await?;
		Ok(deserialize(&buf)?)
	} // }}}

	async fn read_index_entry(&mut self) -> Result<IndexEntry, Error> /* {{{ */ {
		let mut buf = [0u8; Self::index_entry_size() as usize];
		//let mut buf = [0u8; 16];
		self.file.read(&mut buf).await?;
		Ok(deserialize(&buf)?)
	} // }}}

	async fn get_index_entry(&mut self, i: u64) -> Result<IndexEntry, Error> /* {{{ */ {
		self.file.seek(SeekFrom::Start(self.index_start_position() + (i * Self::index_entry_size()))).await?;
		let entry = self.read_index_entry().await?;
		Ok(entry)
	} // }}}

	async fn find_index_entry(&mut self, key: u64) -> Result<Option<IndexEntry>, Error> /* {{{ */  {
		let mut size = (self.header.key_count / 2) + 1;
		let mut index = self.header.key_count / 2;
		let mut entry;
		while(size > 0) {
			size /= 2;
			entry = self.get_index_entry(index).await?;
			if(key == entry.key) {
				return Ok(Some(entry));
			} else if(key < entry.key) {
				index -= size;
			} else {
				index += size;
			}
		}
		Ok(None)
	} // }}}

	async fn read_value(&mut self) -> Result::<T, Error> /* {{{ */ {
		let mut buf = vec![0u8; 1024]; // TODO:  Adjust this size?
		self.file.read(&mut buf).await?;
		Ok(deserialize(&buf)?)
	} // }}}

	pub async fn get(&mut self, key: u64) -> Result<T, Error> /* {{{ */ {
		self.header = self.get_header().await?;
		let index = match self.find_index_entry(key).await? {
			Some(v) => v,
			None => return Err(Error::NotFound(key))
		};
		self.file.seek(SeekFrom::Start(index.position)).await?;
		self.read_value().await
	} // }}}

	pub async fn write(&mut self, mut values: impl Stream<Item=(u64, T)> + Unpin) -> Result<(), Error> /* {{{ */ {
		//let mut buf = [0u8; Self::index_entry_size()];
		let mut buf = [0u8; 1024];

		let mut pos = self.data_start_position();
		let mut index = BTreeMap::new();

		self.file.seek(SeekFrom::Start(pos)).await?;
		while let Some(item) = values.next().await {
			//let item = item?;
			let size = serialized_size(&item.1)? as usize;
			serialize_into(&mut buf[..], &item.1)?;
			index.insert(item.0, pos);
			pos += self.file.write(&buf[0..size]).await? as u64;
		}

		self.header.index_start_pos = pos;
		self.header.key_count = index.len() as u64;

		for entry in index.into_iter().map(|(k, p)| IndexEntry::new(k, p)) {
			serialize_into(&mut buf[..], &entry)?;
			self.file.write(&buf[0..Self::index_entry_size() as usize]).await?;
		}

		serialize_into(&mut buf[..], &self.header)?;
		self.file.seek(SeekFrom::Start(0)).await?;
		self.file.write(&buf[0..Self::header_size() as usize]).await?;

		self.file.flush().await?;
		Ok(())
	} // }}}
}

#[cfg(test)]
mod tests {
	use futures::stream;
	use rand::prelude::SliceRandom;
	use crate::*;

	#[tokio::test]
	async fn fixedwidth() /* {{{ */ {
		// setup {{{
		#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
		struct Struct {
			a: u8,
			b: i16,
			c: u32,
			d: u64
		}
		impl Struct {
			fn new(i: u8) -> Self {
				Self{a: i, b: i as i16 * 2, c: i as u32 * 4, d: i as u64 * 8}
			}
			fn new2(i: u8) -> Self {
				Self{a: 255 - i, b: -(i as i16) * 2, c: i as u32 * 11, d: i as u64 * 17}
			}
		}
		let mut values = (0..255_u8).map(|i| (i as u64, Struct::new(i))).collect::<Vec<_>>();
		values.extend((0..255_u8).map(|i| (i as u64 + 255, Struct::new2(i))));
		// }}}

		let path = tempfile::NamedTempFile::new().unwrap().into_temp_path();
		let mut store: Store<Struct> = Store::new(path).await.unwrap();
		store.write(stream::iter(values.clone().into_iter())).await.unwrap();

		let mut rng = rand::thread_rng();
		let mut indices = (0..values.len() as u64).collect::<Vec<u64>>();
		for i in 1..16 {
			indices.shuffle(&mut rng);
			for i in indices.iter() {
				let result = store.get(*i).await.unwrap();
				assert_eq!(result, values[*i as usize].1);
			}
		}
	} // }}}

	#[tokio::test]
	async fn strings() /* {{{ */ {
		// setup {{{
		#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
		struct Struct {
			number: u8,
			name: String,
			maybe_name: Option<String>
		}
		impl Struct {
			fn new(i: u8) -> Self {
				Self{
					number: i,
					name: english_numbers::convert_all_fmt(i as i64),
					maybe_name: match i % 2 {
						0 => Some(english_numbers::convert_long(i as i64, english_numbers::Formatting::none())),
						_ => None
					}
				}
			}
		}
		let values = (0..255_u8).map(|i| (i as u64, Struct::new(i))).collect::<Vec<_>>();
		// }}}

		let path = tempfile::NamedTempFile::new().unwrap().into_temp_path();
		let mut store: Store<Struct> = Store::new(path).await.unwrap();
		store.write(stream::iter(values.clone().into_iter())).await.unwrap();

		let mut rng = rand::thread_rng();
		let mut indices = (0..values.len() as u64).collect::<Vec<u64>>();
		for i in 1..16 {
			indices.shuffle(&mut rng);
			for i in indices.iter() {
				let result = store.get(*i).await.unwrap();
				assert_eq!(result, values[*i as usize].1);
			}
		}
	} // }}}
}