use std::collections::HashMap;
use std::io::{Bytes, Read};
use std::iter::Peekable;
use crate::common;

pub type Number = i32;

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct Rule {
    pub first: Number,
    pub second: Number,
}

pub fn read_rules<R: Read>(mut input: &mut Peekable<Bytes<R>>) -> HashMap<Number, Vec<Rule>> {
    let mut rules_by_number = HashMap::<Number, Vec<Rule>>::new();

    while let Some(Ok(ch)) = input.peek() {
        if ch == &b'\n' {
            input.next();
            break;
        }
        let first = common::read_number(&mut input);
        input.next();
        let second = common::read_number(&mut input);
        input.next();

        let rule = Rule { first, second };
        rules_by_number
            .entry(rule.first)
            .or_default()
            .push(rule.clone());
        rules_by_number.entry(rule.second).or_default().push(rule);
    }
    rules_by_number
}

pub fn read_number_list<R: Read>(mut input: &mut Peekable<Bytes<R>>) -> Vec<Number> {
    let mut numbers = Vec::<Number>::new();

    while let Some(Ok(ch)) = input.peek() {
        if ch == &b'\n' {
            break;
        } else if ch == &b',' {
            input.next();
            continue;
        }
        let number = common::read_number(&mut input);
        numbers.push(number);
    }
    numbers
}

pub fn read_number<R: Read>(input: &mut Peekable<Bytes<R>>) -> Number {
    let mut number: Number = 0;
    while let Some(Ok(b'0'..=b'9')) = input.peek() {
        number *= 10;
        number += (input.next().unwrap().unwrap() - b'0') as Number;
    }
    number
}