pub struct Mark {
	i: usize
}

pub trait Read<'a> {
	// Per char reading.
	fn next_char(&mut self) -> Result<char>;
	fn peek_char(&mut self) -> Result<char>;

	// Sectioning off data.
	fn mark(&self) -> Mark;
	/// Returns reference to the section.
	fn from_mark(&mut self, m: Mark) -> &'a str;

	/// Attempt to enter a new level of nesting.
	fn enter_nest(&mut self) -> Result<()>;
	/// Leave a nest.
	fn leave_nest(&mut self);

	/// Called when the parser passes a line.
	fn passed_line(&mut self);
}

//pub trait Visitor {}

pub struct Parser<'a, R: Read + 'a> {
	r: &'a mut R
}

impl<'a, R: Read> Parser<'a, R> {
	fn parse_value(&mut self) -> Result<()> {
		loop {
			match self.r.next() {
				Some(c) => match c {
					COMMENT_CHAR => if !self.skip_to_next_line() {
						return Ok(())
					},
					// Whitespace
					LF_CHAR => self.r.mark_line(),
					CR_CHAR => {
						self.skip_char(LF_CHAR);
						self.r.mark_line();
					},
					SPACE_CHAR | TAB_CHAR => {
						self.skip_one();
					},
					// Values
					DICT_START_CHAR => return self.parse_dict(),
					LIST_START_CHAR => return self.parse_list(),
					TEXT_DELIM_CHAR => return self.parse_text(),
					MULTI_TEXT_DELIM_CHAR => return self.parse_multi_text(),
					REAL_NEG_CHAR => return self.parse_real_negative(),
					REAL_ZERO_CHAR => return self.parse_real_positive_decimal(),
					'1'...'9' => return self.parse_real_positive_int(),
					'a'...'z' => return self.parse_initial_lowercase(c),
					'A'...'Z' => return self.parse_initial_uppercase(c),
					// Unexpected
					c => return Some(ParseError::Unexpected(c))
				},
				None => return Ok(())
			}
		}
	}

	#[inline]
	fn skip_one(&mut self) -> bool {
		match self.r.next() {
			Some(_) => true,
			None => false
		}
	}

	#[inline]
	fn skip_char(&mut self, c: char) -> bool {
		match self.r.peek() {
			Some(peeked_c) if c == peeked_c => self.skip_one(),
			Some(_) => true,
			_ => false
		}
	}
	
	#[inline]
	fn skip_to_next_line(&mut self) -> bool {
		loop {
			match self.r.next() {
				Some(LF_CHAR) => {
					self.r.mark_line();
					return true
				},
				Some(CR_CHAR) => {
					if self.skip_char(LF_CHAR) {
						self.r.mark_line();
						return true
					} else {
						return false
					}
				},
				Some(_) => return true,
				None => return false
			}
		}
	}

	#[inline]
	fn parse_dict(&mut self) -> Option<ParseError> {
		if self.r.enter_ctx() {
			None
		} else {
			Some(ParseError::NestingLimit)
		}
	}
	
	#[inline]
	fn parse_list(&mut self) -> Option<ParseError> {
		if self.r.enter_ctx() {
			None
		} else {
			Some(ParseError::NestingLimit)
		}
	}
	
	#[inline]
	fn parse_text(&mut self) -> Option<ParseError> {
		None
	}
	
	#[inline]
	fn parse_multi_text(&mut self) -> Option<ParseError> {
		None
	}
	
	#[inline]
	fn parse_real_negative(&mut self) -> Option<ParseError> {
		None
	}

	#[inline]
	fn parse_real_positive_int(&mut self) -> Option<ParseError> {
		None
	}
	
	#[inline]
	fn parse_real_positive_decimal(&mut self) -> Option<ParseError> {
		None
	}
	
	#[inline]
	fn parse_initial_lowercase(&mut self, c: char) -> Option<ParseError> {
		None
	}
	
	#[inline]
	fn parse_initial_uppercase(&mut self, c: char) -> Option<ParseError> {
		None
	}
}