path: root/svgbob/src/buffer/cell_buffer.rs

use crate::{
    buffer::{fragment_buffer::FragmentTree, Fragment, StringBuffer},
    util::parser,
};
pub use cell::{Cell, CellGrid};
pub use contacts::Contacts;
use itertools::Itertools;
use sauron::{
    html,
    html::{attributes::*, *},
    svg,
    svg::{attributes::*, *},
    Node,
};
pub use settings::Settings;
pub use span::Span;
use std::{
    collections::BTreeMap,
    fmt,
    ops::{Deref, DerefMut},
};

mod cell;
mod contacts;
mod endorse;
mod settings;
mod span;

/// The simplest buffer.
/// This is maps which char belong to which cell skipping the whitespaces
#[derive(Debug)]
pub struct CellBuffer {
    map: BTreeMap<Cell, char>,
    /// class, <style>
    /// assemble into
    ///
    /// ```css
    /// .class { styles }
    /// ```
    css_styles: Vec<(String, String)>,
}

impl Deref for CellBuffer {
    type Target = BTreeMap<Cell, char>;

    fn deref(&self) -> &Self::Target {
        &self.map
    }
}

impl DerefMut for CellBuffer {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.map
    }
}

impl CellBuffer {
    pub fn new() -> Self {
        CellBuffer {
            map: BTreeMap::new(),
            css_styles: vec![],
        }
    }

    pub fn add_css_styles(&mut self, css_styles: Vec<(String, String)>) {
        self.css_styles.extend(css_styles);
    }

    /// Groups cell that are adjacents (cells that are next to each other, horizontally or
    /// vertically)
    /// Note: using .rev() since this has a high change that the last cell is adjacent with the
    /// current cell tested
    pub fn group_adjacents(&self) -> Vec<Span> {
        let mut adjacents: Vec<Span> = vec![];
        for (cell, ch) in self.iter() {
            let belongs_to_adjacents = adjacents.iter_mut().rev().any(|contacts| {
                if contacts.is_adjacent(cell) {
                    contacts.push((*cell, *ch));
                    true
                } else {
                    false
                }
            });
            if !belongs_to_adjacents {
                adjacents.push(Span::new(*cell, *ch));
            }
        }
        Self::merge_recursive(adjacents)
    }

    /// merge span recursively until it hasn't changed the number of spans
    fn merge_recursive(adjacents: Vec<Span>) -> Vec<Span> {
        let original_len = adjacents.len();
        let merged = Self::second_pass_merge(adjacents);
        // if has merged continue merging until nothing can be merged
        if merged.len() < original_len {
            Self::merge_recursive(merged)
        } else {
            merged
        }
    }

    /// second pass merge is operating on span comparing to other spans
    fn second_pass_merge(adjacents: Vec<Span>) -> Vec<Span> {
        let mut new_groups: Vec<Span> = vec![];
        for span in adjacents.into_iter() {
            let is_merged = new_groups.iter_mut().rev().any(|new_group| {
                if new_group.can_merge(&span) {
                    new_group.merge(&span);
                    true
                } else {
                    false
                }
            });
            if !is_merged {
                new_groups.push(span);
            }
        }
        new_groups
    }

    fn bounds(&self) -> Option<(Cell, Cell)> {
        let xlimits = self.iter().map(|(cell, _)| cell.x).minmax().into_option();
        let ylimits = self.iter().map(|(cell, _)| cell.y).minmax().into_option();
        match (xlimits, ylimits) {
            (Some((min_x, max_x)), Some((min_y, max_y))) => {
                Some((Cell::new(min_x, min_y), Cell::new(max_x, max_y)))
            }
            _ => None,
        }
    }

    /// get the svg node of this cell buffer, using the default settings for the sizes
    pub fn get_node(&self) -> Node<()> {
        let (node, _w, _h) = self.get_node_with_size(&Settings::default());
        node
    }

    /// calculate the appropriate size (w,h) in pixels for the whole cell buffer to fit
    /// appropriately
    pub(crate) fn get_size(&self, settings: &Settings) -> (f32, f32) {
        let (top_left, bottom_right) = self.bounds().unwrap_or((Cell::new(0, 0), Cell::new(0, 0)));
        let w = settings.scale * (bottom_right.x + 2) as f32 * Cell::width();
        let h = settings.scale * (bottom_right.y + 2) as f32 * Cell::height();
        (w, h)
    }

    /// get all nodes of this cell buffer
    pub fn get_node_with_size(&self, settings: &Settings) -> (Node<()>, f32, f32) {
        let (w, h) = self.get_size(&settings);
        // vec_fragments are the fragment result of successful endorsement
        //
        // vec_groups are not endorsed, but are still touching, these will be grouped together in
        // the svg node
        let (vec_fragments, vec_contacts): (Vec<Vec<Fragment>>, Vec<Vec<Contacts>>) = self
            .group_adjacents()
            .into_iter()
            .map(|span| span.endorse())
            .unzip();

        // partition the vec_groups into groups that is alone and the group
        // that is contacting their parts
        let (single_member, vec_groups): (Vec<Contacts>, Vec<Contacts>) = vec_contacts
            .into_iter()
            .flatten()
            .partition(move |contacts| contacts.0.len() == 1);

        let single_member_fragments: Vec<Fragment> = single_member
            .into_iter()
            .flat_map(|contact| contact.0)
            .collect();

        let group_nodes: Vec<Node<()>> = vec_groups
            .into_iter()
            .map(|contact| contact.0)
            .map(move |contacts| {
                let mut group_members = contacts
                    .iter()
                    .map(move |gfrag| gfrag.scale(settings.scale).into())
                    .collect::<Vec<_>>();
                g(vec![], group_members)
            })
            .collect();

        let mut fragments: Vec<Fragment> = vec_fragments.into_iter().flatten().collect();
        fragments.extend(single_member_fragments);
        let mut svg_node = Self::fragments_to_node(fragments, self.legend_css(), settings, w, h)
            .add_children(group_nodes);
        (svg_node, w, h)
    }

    /// construct the css from the # Legend: of the diagram
    fn legend_css(&self) ->