use std::collections::HashMap;
use crate::character;
use crate::api;
use crate::mpsc::*;
use std::{thread};
use std::sync::{Arc,Mutex};
use std::time::Duration;

mod strings;

// Parse the tokens in a file
// Returns success or an error string
pub async fn token_parse(
	tokens: &Vec<&str>,
	mut characters: &mut HashMap::<String, character::Character>,
	data_to_send: Arc<Mutex<api::Data_to_send>>,
	rx: &Receiver<u8>,
) -> Result<(),String>
{
	let mut index: usize = 0;
	// Run an infinite loop
	loop
	{
		match rx.try_recv()
		{
			Ok(_) =>
			{
				match tokens.get(index) {
					Some(token) => {
						// The instructions are related to characters
						if token.chars().next().unwrap() == '@'
						{
							let character_name: String = token.chars().skip(1).collect();
							// If the character doesn't exist, then create it
							if ! characters.contains_key(&character_name)
							{
								let new_character = character::Character::new(character_name.clone());
								characters.insert(character_name.clone(),new_character);
							}
							println!("Doing something with a character: {}", character_name);
							// The index is incremented to after the character's instructions
							index += match character_parse(index+1, &tokens, character_name, &mut characters, &data_to_send, &rx).await
							{
								Ok(increment) => {
									increment
								},
								Err(error) => return Err(error),
							}
						}
						// Miscelleneous instructions
						if token.to_lowercase() == "end"
						{
							return Ok(()) // quit
						}
					},
					None => return Err(String::from("File reached termination point")),
				}
				index += 1;
			},
			Err(_) => thread::sleep(Duration::from_millis(4000)),
		}
	}
}
// Parsing character related instructions
async fn character_parse
(
	index: usize,
	tokens: &Vec<&str>,
	character_name: String,
	characters: &mut HashMap::<String, character::Character>,
	data_to_send: &Arc<Mutex<api::Data_to_send>>,
	rx: &Receiver<u8>,
) -> Result<usize,String>
{
	let mut sum_index: usize = index;
	loop
	{
		// Ensure the index is valid (the index is not beyond the vector)
		let _ = match tokens.get(sum_index)
		{
			Some(token) => {
				match token.to_lowercase().as_str()
				{
					// The character is saying something, so grab the text and pass it
					// to the client
					"says" =>
					{
						match strings::extract_quoted(&tokens[sum_index+1..])
						{
							Some(output_string) =>
							{
								println!("{}", output_string);
								let mut data = data_to_send.lock().unwrap();
								data.action_type = String::from("output");
								data.content = output_string;
								data.character = character_name.clone();
							},
							None => return Err(String::from("Unable to read string")),
						}
					},
					// Catch all condition, if the instruction is unrecognised as a
					// character command
					_ => return Err(String::from("Invalid command")),
				}
			},
			None => return Err(String::from("File reached termination point"))
		};
		sum_index += 1;
	}
}