//! A flow of paragraphs and other block-level nodes.

use super::prelude::*;
use super::{AlignNode, ParNode, PlaceNode, SpacingKind, TextNode};

/// Arrange spacing, paragraphs and other block-level nodes into a flow.
///
/// This node is reponsible for layouting both the top-level content flow and
/// the contents of boxes.
#[derive(Hash)]
pub struct FlowNode(pub StyleVec<FlowChild>);

/// A child of a flow node.
#[derive(Hash)]
pub enum FlowChild {
    /// A paragraph / block break.
    Parbreak,
    /// A column / region break.
    Colbreak,
    /// Vertical spacing between other children.
    Spacing(SpacingKind),
    /// An arbitrary block-level node.
    Node(PackedNode),
}

impl Layout for FlowNode {
    fn layout(
        &self,
        ctx: &mut LayoutContext,
        regions: &Regions,
        styles: StyleChain,
    ) -> Vec<Constrained<Arc<Frame>>> {
        let mut layouter = FlowLayouter::new(regions);

        for (child, map) in self.0.iter() {
            let styles = map.chain(&styles);
            match child {
                FlowChild::Parbreak => {
                    let em = styles.get(TextNode::SIZE).abs;
                    let amount = styles.get(ParNode::SPACING).resolve(em);
                    layouter.layout_spacing(SpacingKind::Linear(amount.into()));
                }
                FlowChild::Colbreak => {
                    layouter.finish_region();
                }
                FlowChild::Spacing(kind) => {
                    layouter.layout_spacing(*kind);
                }
                FlowChild::Node(ref node) => {
                    layouter.layout_node(ctx, node, styles);
                }
            }
        }

        layouter.finish()
    }
}

impl Merge for FlowChild {
    fn merge(&mut self, _: &Self) -> bool {
        false
    }
}

impl Debug for FlowNode {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        f.write_str("Flow ")?;
        self.0.fmt(f)
    }
}

impl Debug for FlowChild {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            Self::Parbreak => f.pad("Parbreak"),
            Self::Colbreak => f.pad("Colbreak"),
            Self::Spacing(kind) => write!(f, "{:?}", kind),
            Self::Node(node) => node.fmt(f),
        }
    }
}

/// Performs flow layout.
pub struct FlowLayouter {
    /// The regions to layout children into.
    regions: Regions,
    /// Whether the flow should expand to fill the region.
    expand: Spec<bool>,
    /// The full size of `regions.current` that was available before we started
    /// subtracting.
    full: Size,
    /// The size used by the frames for the current region.
    used: Size,
    /// The sum of fractional ratios in the current region.
    fr: Fractional,
    /// Whether to add leading before the next node.
    leading: bool,
    /// Spacing and layouted nodes.
    items: Vec<FlowItem>,
    /// Finished frames for previous regions.
    finished: Vec<Constrained<Arc<Frame>>>,
}

/// A prepared item in a flow layout.
enum FlowItem {
    /// Absolute spacing between other items.
    Absolute(Length),
    /// Fractional spacing between other items.
    Fractional(Fractional),
    /// A frame for a layouted child node and how to align it.
    Frame(Arc<Frame>, Spec<Align>),
    /// An absolutely placed frame.
    Placed(Arc<Frame>),
}

impl FlowLayouter {
    /// Create a new flow layouter.
    pub fn new(regions: &Regions) -> Self {
        let expand = regions.expand;
        let full = regions.current;

        // Disable vertical expansion for children.
        let mut regions = regions.clone();
        regions.expand.y = false;

        Self {
            regions,
            expand,
            full,
            used: Size::zero(),
            fr: Fractional::zero(),
            leading: false,
            items: vec![],
            finished: vec![],
        }
    }

    /// Layout spacing.
    pub fn layout_spacing(&mut self, spacing: SpacingKind) {
        match spacing {
            SpacingKind::Linear(v) => {
                // Resolve the linear and limit it to the remaining space.
                let resolved = v.resolve(self.full.y);
                let limited = resolved.min(self.regions.current.y);
                self.regions.current.y -= limited;
                self.used.y += limited;
                self.items.push(FlowItem::Absolute(resolved));
            }
            SpacingKind::Fractional(v) => {
                self.items.push(FlowItem::Fractional(v));
                self.fr += v;
                self.leading = false;
            }
        }
    }

    /// Layout a node.
    pub fn layout_node(
        &mut self,
        ctx: &mut LayoutContext,
        node: &PackedNode,
        styles: StyleChain,
    ) {
        // Don't even try layouting into a full region.
        if self.regions.is_full() {
            self.finish_region();
        }

        // Placed nodes that are out of flow produce placed items which aren't
        // aligned later.
        let mut is_placed = false;
        if let Some(placed) = node.downcast::<PlaceNode>() {
            is_placed = true;
            if placed.out_of_flow() {
                let frame = node.layout(ctx, &self.regions, styles).remove(0);
                self.items.push(FlowItem::Placed(frame.item));
                return;
            }
        }

        // Add leading.
        if self.leading {
            let em = styles.get(TextNode::SIZE).abs;
            let amount = styles.get(ParNode::LEADING).resolve(em);
            self.layout_spacing(SpacingKind::Linear(amount.into()));
        }

        // How to align the node.
        let aligns = Spec::new(
            // For non-expanding paragraphs it is crucial that we align the
            // whole paragraph as it is itself aligned.
            styles.get(ParNode::ALIGN),
            // Vertical align node alignment is respected by the flow node.
            node.downcast::<AlignNode>()
                .and_then(|aligned| aligned.aligns.y)
                .unwrap_or(Align::Top),
        );

        let frames = node.layout(ctx, &self.regions, styles);
        let len = frames.len();
        for (i, frame) in frames.into_iter().enumerate() {
            // Grow our size, shrink the region and save the frame for later.
            let size = frame.item.size;
            self.used.y += size.y;
            self.used.x.set_max(size.x);
            self.regions.current.y -= size.y;
            self.items.push(FlowItem::Frame(frame.item, aligns));

            if i + 1 < len {
                self.finish_region();
            }
        }

        self.leading = !is_placed;
    }

    /// Finish the frame for one region.
    pub fn finish_region(&mut self) {
        // Determine the size of the flow in this region dependening on whether
        // the region expands.
        let mut size = self.expand.select(self.full, self.used);

        // Account for fractional spacing in the size calculation.
        let remaining = self.full.y - self.used.y;
        if self.fr.get() > 0.0 && self.full.y.is_finite() {
            self.used.y = self.full.y;
            size.y = self.full.y;
        }

        let mut output = Frame::new(size);
        let mut offset = Length::zero();
        let mut ruler = Align::Top;

        // Place all frames.
        for item in self.items.drain(..) {
            match item {
                FlowItem::Absolute(v) => {
                    offset += v;
                }
                FlowItem::Fractional(v) => {
                    offset += v.resolve(self.fr, remaining);
                }
                FlowItem::Frame(frame, aligns) => {
                    ruler = ruler.max(aligns.y);
                    let x = aligns.x.resolve(size.x - frame.size.x);
                    let y = offset + ruler.resolve(size.y - self.used.y);
                    let pos = Point::new(x, y);
                    offset += frame.size.y;
                    output.push_frame(pos, frame);
                }
                FlowItem::Placed(frame) => {
                    output.push_frame(Point::zero(), frame);
                }
            }
        }

        // Generate tight constraints for now.
        let mut cts = Constraints::new(self.expand);
        cts.exact = self.full.map(Some);
        cts.base = self.regions.base.map(Some);

        // Advance to the next region.
        self.regions.next();
        self.full = self.regions.current;
        self.used = Size::zero();
        self.fr = Fractional::zero();
        self.leading = false;
        self.finished.push(output.constrain(cts));
    }

    /// Finish layouting and return the resulting frames.
    pub fn finish(mut self) -> Vec<Constrained<Arc<Frame>>> {
        if self.expand.y {
            while self.regions.backlog.len() > 0 {
                self.finish_region();
            }
        }

        self.finish_region();
        self.finished
    }
}