use super::_PreserveIndexVec;
use std::ops::{Index, IndexMut};

pub struct Edge {
    pub vertex1_index: usize,
    pub vertex2_index: usize,
    pub length: f64,
    pub ferment_intensity: f64,
}

impl Edge {
    pub fn another(&self, current: usize) -> usize {
        if self.vertex1_index == current {
            return self.vertex2_index;
        } else if self.vertex2_index == current {
            return self.vertex1_index;
        } else {
            panic!("Edge not connected to specified vertex");
        }
    }
}

pub struct EdgesVec {
    data: _PreserveIndexVec<Edge>,
}

impl EdgesVec {
    pub fn new() -> Self {
        return Self {
            data: _PreserveIndexVec::new(),
        };
    }

    pub fn add(&mut self, vertex1: usize, vertex2: usize, length: f64) -> usize {
        let data = Edge {
            vertex1_index: vertex1,
            vertex2_index: vertex2,
            length,
            ferment_intensity: 0.0,
        };
        return self.data.add(data);
    }

    pub fn remove(&mut self, edge_index: usize) {
        self.data.remove(edge_index)
    }
    pub fn iter(&self) -> impl Iterator<Item=&Edge>{
        return self.data.iter()
    }
    
    pub fn iter_mut(&mut self) -> impl Iterator<Item=&mut Edge>{
        return self.data.iter_mut()
    }
}

impl Index<usize> for EdgesVec {
    type Output = Edge;

    fn index(&self, index: usize) -> &Self::Output {
        return self.data.index(index);
    }
}

impl IndexMut<usize> for EdgesVec {
    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
        return self.data.index_mut(index);
    }
}