#[derive(Debug)]
pub enum Error {
  MismatchedBrackets,
  IOError(std::io::Error),
  EOF
}

impl From<std::io::Error> for Error {
  fn from(err: std::io::Error) -> Error {
    Error::IOError(err)
  }
}

type CellContent = u8;

struct Tape {
  contents: [CellContent; 30000]
}

impl Tape {
  pub fn get_cell(&self, index: usize) -> CellContent {
    return self.contents[index];
  }
  pub fn set_cell(&mut self, index: usize, value: CellContent) {
    self.contents[index] = value;
  }
  pub fn increment(&mut self, index: usize) {
    if self.contents[index] == 255 {
      self.contents[index] = 0;
    }
    else {
      self.contents[index] += 1;
    }
  }
  pub fn decrement(&mut self, index: usize) {
    if self.contents[index] == 0 {
      self.contents[index] = 255;
    }
    else {
      self.contents[index] -= 1;
    }
  }
  pub fn new() -> Tape {
    Tape {
      contents: [0; 30000]
    }
  }
}

struct State<'s, R: std::io::Read + 's, W: std::io::Write + 's> {
  tape: Tape,
  source: Vec<char>,
  instruction_index: usize,
  data_index: usize,
  input: &'s mut R,
  output: &'s mut W,
  small_buffer: [u8; 1]
}

impl<'s, R: std::io::Read, W: std::io::Write> State<'s, R, W> {
  fn run_single(&mut self) -> Result<bool, Error> {
    match self.source.get(self.instruction_index) {
      Some(chr) => {
        //println!("processing {}", chr);
        let result: Result<bool, Error> = match chr {
          &'.' => {
            self.output.write(&[self.tape.get_cell(self.data_index)])?;
            Ok(true)
          },
          &',' => {
            let count = self.input.read(&mut self.small_buffer)?;
            if count < 1 {
              return Err(Error::EOF);
            }
            self.tape.set_cell(self.data_index, self.small_buffer[0]);
            Ok(true)
          },
          &'+' => {
            self.tape.increment(self.data_index);
            Ok(true)
          },
          &'-' => {
            self.tape.decrement(self.data_index);
            Ok(true)
          },
          &'<' => {
            self.data_index -= 1;
            Ok(true)
          },
          &'>' => {
            self.data_index += 1;
            Ok(true)
          },
          &'[' => {
            if self.tape.get_cell(self.data_index) > 0 {
              Ok(true)
            }
            else {
              // otherwise, do amazing magic loop stuff with ¡oreology!
              let mut nested = 1;
              loop {
                self.instruction_index += 1;
                let chr = match self.source.get(self.instruction_index) {
                  Some(x) => Ok(x),
                  None => Err(Error::EOF)
                }?;
                if *chr == ']' {
                  nested -= 1;
                  if nested < 1 {
                    break;
                  }
                }
                if *chr == '[' {
                  nested += 1;
                }
              }
              Ok(true)
            }
          },
          &']' => {
            if self.tape.get_cell(self.data_index) == 0 {
              Ok(true)
            }
            else {
              let mut nested = 1;
              loop {
                if self.instruction_index < 1 {
                  return Err(Error::MismatchedBrackets);
                }
                self.instruction_index -= 1;
                let chr = self.source[self.instruction_index];
                if chr == '[' {
                  nested -= 1;
                  if nested < 1 {
                    break;
                  }
                }
                if chr == ']' {
                  nested += 1;
                }
              }
              Ok(true)
            }
          },
          _ => Ok(true)
        };
        if result? {
          self.instruction_index += 1;
        }
        Ok(true)
      },
      None => Ok(false)
    }
  }
  pub fn execute(&mut self) -> Result<(), Error> {
    loop {
      if !self.run_single()? {
        break;
      }
    }
    //self.output.write(&[13]);
    self.output.flush()?;
    Ok(())
  }
  pub fn new<'a>(src: &str, input: &'a mut R, output: &'a mut W) -> State<'a, R, W> {
    State {
      tape: Tape::new(),
      source: src.chars().collect(),
      instruction_index: 0,
      data_index: 0,
      input,
      output,
      small_buffer: [0; 1]
    }
  }
}

pub fn execute<R: std::io::Read, W: std::io::Write>(source: &str, input: &mut R, output: &mut W) -> Result<(), Error> {
  let mut state = State::new(source, input, output);
  state.execute()
}


/*
  [x]  >	increment the data pointer (to point to the next cell to the right).
  [x]  <	decrement the data pointer (to point to the next cell to the left).
  [x]  +	increment (increase by one) the byte at the data pointer.
  [x]  -	decrement (decrease by one) the byte at the data pointer.
  [x]  .	output the byte at the data pointer.
  [x]  ,	accept one byte of input, storing its value in the byte at the data pointer.
  [x]  [	if the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching ] command.
  [x]  ]	if the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching [ command.
*/