use std::collections::{HashMap, HashSet};
use std::hash::Hash;

#[derive(Debug, Default)]
struct DFA<T: Eq + Hash> {
    state: isize,
    transitions: HashMap<(isize, T), isize>,
    goals: HashSet<isize>,
}

#[derive(Debug)]
enum DFAResult<T> {
    Success,
    Failure,
    Invalid(isize, T),
}

impl<T> DFAResult<T> {
    fn from_bool(b: bool) -> Self {
        if b {
            Success
        } else {
            Failure
        }
    }
}

use self::DFAResult::*;

impl<T: Eq + Hash + Clone> DFA<T> {
    fn eval(&mut self, mut iter: impl Iterator<Item = T>) -> DFAResult<T> {
        while let Some(transition) = iter.next() {
            unsafe {
                let raw = &transition as *const T;
                match self.transitions.get(&(self.state, transition)) {
                    Some(&state) => self.state = state,
                    None => return Invalid(self.state, (*raw).clone()),
                }
            }
        }
        DFAResult::from_bool(self.goals.contains(&self.state))
    }
}

#[derive(Debug, Default)]
struct DFABuilder<T: Eq + Hash> {
    dfa: DFA<T>,
}

impl<T: Eq + Hash + Clone> DFABuilder<T> {
    fn add_transition(mut self, from: isize, on: T, to: isize) -> Self {
        self.dfa
            .transitions
            .entry((from, on))
            .and_modify(|state| *state = to)
            .or_insert(to);
        self
    }

    fn add_goal(mut self, goal: isize) -> Self {
        self.dfa.goals.insert(goal);
        self
    }

    fn start_state(mut self, start: isize) -> Self {
        self.dfa.state = start;
        self
    }

    fn build(self) -> DFA<T> {
        self.dfa
    }
}

fn main() {
    let mut dfa = DFABuilder::default()
        .add_transition(0, 0_u128, 1)
        .add_transition(0, 1_u128, 0)
        .add_transition(1, 0_u128, 0)
        .add_transition(1, 1_u128, 1)
        .add_goal(0)
        .build();

    dbg!(dfa.eval([0, 1, 1, 0, 2].into_iter().cloned()));
}