use crate::genetics::prelude::*;

pub struct GenomeBuilder {
    genome: PlantGenome,
    current_gene: usize,
}

impl GenomeBuilder {

    pub fn new() -> Self {
        Self {
            genome: PlantGenome::new(),
            current_gene: 0
        }
    }

    pub fn finish(mut self) -> PlantGenome {
        self.genome.update_graph();
        return self.genome;
    }

    pub fn create_root(mut self, root: Gene) -> Result<Self,GenomeBuilderError> {
        // Check for root existance
        if self.genome.genes.len() > 0 {
            return Err(GenomeBuilderError::RootExists);
        }
        self.genome.genes.push(root);

        return Ok(self);
    }

    pub fn insert_gene(mut self, gene: Gene, parent: Gene) -> Result<Self,GenomeBuilderError> {
        // Check for gene collision
        if self.genome.genes.contains(&gene){
            return Err(GenomeBuilderError::GeneExists);
        }

        let edge = Edge::new(parent,gene.clone());
        self.genome.edges.push(edge);

        self.current_gene = self.genome.genes.len();
        self.genome.genes.push(gene);

        Ok(self)
    }
    pub fn add_gene(mut self, gene: Gene) -> Result<Self,GenomeBuilderError> {
        // Check for root existance
        if self.genome.genes.len() == 0 {
           return Err(GenomeBuilderError::RootDoesntExist);
        }
        // Check for gene collision
        if self.genome.genes.contains(&gene){
            return Err(GenomeBuilderError::GeneExists);
        }
        let edge = Edge::new(self.get_current_gene().clone(),gene.clone());
        self.genome.edges.push(edge);

        self.current_gene = self.genome.genes.len();
        self.genome.genes.push(gene);

        Ok(self)

    }
    pub fn back(mut self, amount: Option<usize>) -> Self {
        for _ in 0..amount.unwrap_or(0) {
            
        }
        self
    }
    #[inline(always)]
    pub fn get_current_gene(&self) -> &Gene {
        &self.genome.genes[self.current_gene]
    }

    #[inline(always)]
    pub fn get_current_gene_mut(&mut self) -> &mut Gene {
        &mut self.genome.genes[self.current_gene]
    }
    
}

#[derive(Debug)]
pub enum GenomeBuilderError {
    RootExists,
    RootDoesntExist,
    GeneExists,
    EdgeExists,
}