use std::collections::HashMap;
use std::rc::Rc;

pub mod commands;

#[derive(Debug, Clone)]
pub struct Operation {
  trigger: [bool; 2],
  force: [bool; 2],
  cont: [bool; 4],
  op: String,
  args: Vec<String>
}

impl Operation {
  pub fn op(&self) -> &str {
    &self.op
  }

  pub fn trigger(&self) -> [bool; 2] {
    self.trigger
  }
}

#[derive(Debug)]
struct StackFrame {
  store_load: Vec<Status>, // TODO move out
  ops: *const Operation,
  len: usize,
  pos: usize,
}

struct FrameHolder<'a, 'b> where 'b: 'a {
  frame: Option<StackFrame>,
  _lt: std::marker::PhantomData<&'a [Operation]>,
  state: &'b mut State,
}

impl<'a, 'b> FrameHolder<'a, 'b> where 'b: 'a  {
  fn new(state: &'b mut State, ops: &'a [Operation]) -> FrameHolder<'a, 'b> where 'b: 'a {
    FrameHolder {
      frame: Some(StackFrame { store_load: Vec::new(), ops: ops.as_ptr(), len: ops.len(), pos: 0 }),
      _lt: std::marker::PhantomData,
      state: state
    }
  }

  fn with<F, R>(mut self, f: F) -> R where F: FnOnce(&mut State) -> R {
    let frame = self.frame.take().unwrap();
    self.state.frames.push(frame);
    f(self.state)
  }
}

impl<'a, 'b> Drop for FrameHolder<'a, 'b> where 'b: 'a  {
  fn drop(&mut self) {
    self.state.frames.pop();
  }
}

#[derive(Debug)]
pub struct State {
  frames: Vec<StackFrame>,
  commands: HashMap<&'static str, Rc<Command>>,
}

impl State {
  pub fn new() -> State {
    State { frames: Vec::new(), commands: HashMap::new() }
  }

  pub fn register_command<T: 'static + Command>(&mut self, command: T) {
    self.commands.insert(command.get_name(), Rc::new(command));
  }

  pub fn get_op<F, R>(&self, f: F) -> R where F: FnOnce(&Operation) -> R {
    let op = unsafe {
      let frame = self.frames.last().unwrap();
      &std::slice::from_raw_parts(frame.ops, frame.len)[frame.pos]
    };
    f(op)
  }

  pub fn get_pos(&self) -> usize {
    self.frames.last().unwrap().pos
  }

  pub fn call(&mut self, prog: &[Operation]) -> Status {
    FrameHolder::new(self, prog).with(|x| x.run(0))
  }

  pub fn run(&mut self, from: usize) -> Status {
    let mut status = Status::Success;
    // `unsafe` means we're holding both an immutable and a mutable reference to `self` here
    // but it works
    let oldpos = self.frames.last_mut().unwrap().pos;
    let ops = unsafe {
      let frame = self.frames.last().unwrap();
      std::slice::from_raw_parts(frame.ops, frame.len)
    };
    for (pos, op) in ops.iter().enumerate().skip(from) {
      self.frames.last_mut().unwrap().pos = pos;
      status = if op.trigger[*status] {
        let newstatus = {
          if let Some(x) = self.commands.get(op.op.as_str()).map(|x| x.clone()) {
            x.run(self, status, &op.args)
          } else {
            Status::Failure
          }
        };
        if newstatus.is_return() {
          self.frames.last_mut().unwrap().pos = oldpos;
          return newstatus;
        }
        if op.cont[*status * 2 + *newstatus] {
          Status::Success
        } else {
          Status::Failure
        }
      } else if op.force[*status] {
        status
      } else {
        self.frames.last_mut().unwrap().pos = oldpos;
        return status;
      }
    }
    self.frames.last_mut().unwrap().pos = oldpos;
    status
  }
}

#[derive(Debug, Copy, Clone)]
pub enum Status {
  Failure,
  Success,
  ReturnFailure,
  ReturnSuccess,
}

impl Status {
  pub fn is_return(&self) -> bool {
    use Status::*;

    match *self {
      Failure | Success => false,
      ReturnFailure | ReturnSuccess => true,
    }
  }
}

impl std::ops::Deref for Status {
  type Target = usize;

  fn deref(&self) -> &usize {
    use Status::*;

    static ONE: usize = 1;
    static ZERO: usize = 0;
    match *self {
      Failure | ReturnFailure => &ZERO,
      Success | ReturnSuccess => &ONE,
    }
  }
}

impl std::ops::Not for Status {
  type Output = Status;

  fn not(self) -> Self::Output {
    use Status::*;

    match self {
      Failure => Success,
      Success => Failure,
      ReturnFailure => ReturnSuccess,
      ReturnSuccess => ReturnFailure,
    }
  }
}

impl std::ops::Neg for Status {
  type Output = Status;

  fn neg(self) -> Self::Output {
    use Status::*;

    match self {
      Failure => ReturnFailure,
      Success => ReturnSuccess,
      ReturnFailure => Failure,
      ReturnSuccess => Success,
    }
  }
}

impl From<bool> for Status {
  fn from(b: bool) -> Status {
    if b {
      Status::Success
    } else {
      Status::Failure
    }
  }
}

pub trait Command {
  fn get_name(&self) -> &'static str;

  fn run(&self, state: &mut State, status: Status, args: &[String]) -> Status;
}

impl std::fmt::Debug for Command {
  fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
    write!(fmt, "Command: {}", self.get_name())
  }
}


pub fn parse<I>(program: I) -> Vec<Operation> where I: Iterator<Item=char> {
  program.chain("\n".chars()).scan(String::new(), |state, x| {
    if x == '\r' || x == '\n' {
      let s = state.clone();
      state.clear();
      Some(Some(s))
    } else {
      state.push(x);
      Some(None)
    }
  }).flat_map(|x| x) // flatten
    .filter(|x| !x.is_empty())
    .filter(|x| !x.starts_with("#"))
    .map(|x| {
      let mut itr = x.chars();
      let trigger = itr.next().and_then(|c| c.to_digit(16)).unwrap();
      let cont = itr.next().and_then(|c| c.to_digit(16)).unwrap();
      if itr.next().unwrap() != ' ' { panic!(); }
      let mut parts = itr.as_str().split(' ');
      let op = parts.next().unwrap().to_owned();
      let args = parts.map(|x| x.to_owned()).collect();
      Operation {
        trigger: [trigger & 1 != 0, trigger & 2 != 0],
        force: [trigger & 4 != 0, trigger & 8 != 0],
        cont: [cont & 1 != 0, cont & 2 != 0, cont & 4 != 0, cont & 8 != 0],
        op: op,
        args: args
      }
    })
    .collect()
}