graphs-tui 0.2.0

//! Sequence diagram parser and renderer for Mermaid syntax
//!
//! Supports basic mermaid sequence diagram syntax

use crate::error::MermaidError;
use crate::types::RenderOptions;

/// A participant in the sequence diagram
#[derive(Debug, Clone)]
pub struct Participant {
    pub id: String,
    pub label: String,
}

/// Message arrow style
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArrowStyle {
    /// Solid arrow ->>
    Solid,
    /// Dotted arrow -->>
    Dotted,
    /// Solid line ->
    SolidLine,
    /// Dotted line -->
    DottedLine,
    /// Async arrow -)
    Async,
}

/// A message between participants
#[derive(Debug, Clone)]
pub struct Message {
    pub from: String,
    pub to: String,
    pub label: String,
    pub style: ArrowStyle,
}

/// Note position relative to participant
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NotePosition {
    Left,
    Right,
    Over,
}

/// A note attached to participant(s)
#[derive(Debug, Clone)]
pub struct Note {
    pub position: NotePosition,
    pub participants: Vec<String>,
    pub text: String,
}

/// Items that can appear in a sequence diagram
#[derive(Debug, Clone)]
pub enum SequenceItem {
    Message(Message),
    Note(Note),
    Activate(String),
    Deactivate(String),
    Loop {
        condition: String,
        items: Vec<SequenceItem>,
    },
    Alt {
        condition: String,
        items: Vec<SequenceItem>,
        else_items: Option<Vec<SequenceItem>>,
    },
    Opt {
        condition: String,
        items: Vec<SequenceItem>,
    },
}

/// Sequence diagram data
#[derive(Debug, Clone)]
pub struct SequenceDiagram {
    pub title: Option<String>,
    pub participants: Vec<Participant>,
    pub items: Vec<SequenceItem>,
    /// Legacy field for backwards compatibility
    pub messages: Vec<Message>,
}

/// Parse sequence diagram syntax
pub fn parse_sequence_diagram(input: &str) -> Result<SequenceDiagram, MermaidError> {
    let lines: Vec<&str> = input
        .lines()
        .map(|l| l.trim())
        .filter(|l| !l.is_empty() && !l.starts_with("%%"))
        .collect();

    if lines.is_empty() {
        return Err(MermaidError::EmptyInput);
    }

    // Validate header
    let first_line = lines[0].to_lowercase();
    if !first_line.starts_with("sequencediagram") {
        return Err(MermaidError::ParseError {
            line: 1,
            message: "Expected 'sequenceDiagram'".to_string(),
            suggestion: Some("Start with 'sequenceDiagram'".to_string()),
        });
    }

    let mut diagram = SequenceDiagram {
        title: None,
        participants: Vec::new(),
        items: Vec::new(),
        messages: Vec::new(),
    };

    let mut seen_participants: std::collections::HashSet<String> = std::collections::HashSet::new();

    let content_lines: Vec<&str> = lines.iter().skip(1).copied().collect();
    let (items, _) = parse_items(&content_lines, &mut seen_participants, &mut diagram, 0);
    diagram.items = items;

    // Also populate messages for backwards compatibility
    collect_messages(&diagram.items, &mut diagram.messages);

    if diagram.participants.is_empty() && diagram.items.is_empty() {
        return Err(MermaidError::ParseError {
            line: 1,
            message: "No sequence diagram content found".to_string(),
            suggestion: Some("Add messages like 'Alice->>Bob: Hello'".to_string()),
        });
    }

    Ok(diagram)
}

/// Collect all messages from items recursively (for backwards compatibility)
fn collect_messages(items: &[SequenceItem], messages: &mut Vec<Message>) {
    for item in items {
        match item {
            SequenceItem::Message(msg) => messages.push(msg.clone()),
            SequenceItem::Loop { items, .. }
            | SequenceItem::Alt { items, .. }
            | SequenceItem::Opt { items, .. } => {
                collect_messages(items, messages);
                if let SequenceItem::Alt {
                    else_items: Some(else_items),
                    ..
                } = item
                {
                    collect_messages(else_items, messages);
                }
            }
            _ => {}
        }
    }
}

/// Parse items from lines, handling nested blocks
fn parse_items(
    lines: &[&str],
    seen_participants: &mut std::collections::HashSet<String>,
    diagram: &mut SequenceDiagram,
    mut idx: usize,
) -> (Vec<SequenceItem>, usize) {
    let mut items = Vec::new();

    while idx < lines.len() {
        let line = lines[idx];
        let lower = line.to_lowercase();

        // Check for block end
        if lower == "end" {
            return (items, idx + 1);
        }

        // Check for else (in alt blocks)
        if lower == "else" || lower.starts_with("else ") {
            return (items, idx);
        }

        // Parse title
        if lower.starts_with("title") {
            let title_text = line
                .strip_prefix("title")
                .or_else(|| line.strip_prefix("Title"))
                .unwrap_or(line);
            diagram.title = Some(title_text.trim().to_string());
            idx += 1;
            continue;
        }

        // Parse participant declaration
        if lower.starts_with("participant") {
            if let Some(p) = parse_participant(line) {
                if !seen_participants.contains(&p.id) {
                    seen_participants.insert(p.id.clone());
                    diagram.participants.push(p);
                }
            }
            idx += 1;
            continue;
        }

        // Parse actor declaration
        if lower.starts_with("actor") {
            if let Some(p) = parse_actor(line) {
                if !seen_participants.contains(&p.id) {
                    seen_participants.insert(p.id.clone());
                    diagram.participants.push(p);
                }
            }
            idx += 1;
            continue;
        }

        // Parse activate
        if lower.starts_with("activate ") {
            let participant = line[9..].trim().to_string();
            auto_add_participant(&participant, seen_participants, diagram);
            items.push(SequenceItem::Activate(participant));
            idx += 1;
            continue;
        }

        // Parse deactivate
        if lower.starts_with("deactivate ") {
            let participant = line[11..].trim().to_string();
            items.push(SequenceItem::Deactivate(participant));
            idx += 1;
            continue;
        }

        // Parse Note
        if lower.starts_with("note ") {
            if let Some(note) = parse_note(line) {
                for p in &note.participants {
                    auto_add_participant(p, seen_participants, diagram);
                }
                items.push(SequenceItem::Note(note));
            }
            idx += 1;
            continue;
        }

        // Parse loop block
        if lower.starts_with("loop ") || lower == "loop" {
            let condition = if lower.len() > 5 {
                line[5..].trim().to_string()
            } else {
                String::new()
            };
            let (loop_items, next_idx) = parse_items(lines, seen_participants, diagram, idx + 1);
            items.push(SequenceItem::Loop {
                condition,
                items: loop_items,
            });
            idx = next_idx;
            continue;
        }

        // Parse alt block
        if lower.starts_with("alt ") || lower == "alt" {
            let condition = if lower.len() > 4 {
                line[4..].trim().to_string()
            } else {
                String::new()
            };
            let (alt_items, next_idx) = parse_items(lines, seen_participants, diagram, idx + 1);

            // Check for else
            let (else_items, final_idx) = if next_idx < lines.len() {
                let else_line = lines[next_idx].to_lowercase();
                if else_line == "else" || else_line.starts_with("else ") {
                    let (else_parsed, end_idx) = parse_items(lines, seen_participants, diagram, next_idx + 1);
                    (Some(else_parsed), end_idx)
                } else {
                    (None, next_idx)
                }
            } else {
                (None, next_idx)
            };

            items.push(SequenceItem::Alt {
                condition,
                items: alt_items,
                else_items,
            });
            idx = final_idx;
            continue;
        }

        // Parse opt block
        if lower.starts_with("opt ") || lower == "opt" {
            let condition = if lower.len() > 4 {
                line[4..].trim().to_string()
            } else {
                String::new()
            };
            let (opt_items, next_idx) = parse_items(lines, seen_participants, diagram, idx + 1);
            items.push(SequenceItem::Opt {
                condition,
                items: opt_items,
            });
            idx = next_idx;
            continue;
        }

        // Parse message
        if let Some(msg) = parse_message(line) {
            auto_add_participant(&msg.from, seen_participants, diagram);
            auto_add_participant(&msg.to, seen_participants, diagram);
            items.push(SequenceItem::Message(msg));
            idx += 1;
            continue;
        }

        idx += 1;
    }

    (items, idx)
}

/// Auto-add participant if not seen
fn auto_add_participant(
    id: &str,
    seen_participants: &mut std::collections::HashSet<String>,
    diagram: &mut SequenceDiagram,
) {
    if !seen_participants.contains(id) {
        let id_owned = id.to_string();
        seen_participants.insert(id_owned.clone());
        diagram.participants.push(Participant {
            label: id_owned.clone(),
            id: id_owned,
        });
    }
}

/// Parse a Note: Note left/right/over participant: text
fn parse_note(line: &str) -> Option<Note> {
    let lower = line.to_lowercase();
    let rest = line.strip_prefix("note").or_else(|| line.strip_prefix("Note"))?.trim();

    let (position, after_pos) = if lower.contains(" left of ") {
        (NotePosition::Left, rest.strip_prefix("left of").or_else(|| rest.strip_prefix("Left of"))?)
    } else if lower.contains(" right of ") {
        (NotePosition::Right, rest.strip_prefix("right of").or_else(|| rest.strip_prefix("Right of"))?)
    } else if lower.contains(" over ") {
        (NotePosition::Over, rest.strip_prefix("over").or_else(|| rest.strip_prefix("Over"))?)
    } else {
        return None;
    };

    let after_pos = after_pos.trim();

    // Find colon separator
    let (participants_str, text) = if let Some(colon_idx) = after_pos.find(':') {
        let p = after_pos[..colon_idx].trim();
        let t = after_pos[colon_idx + 1..].trim();
        (p, t.to_string())
    } else {
        (after_pos, String::new())
    };

    // Parse participants (can be comma-separated for "over")
    let participants: Vec<String> = participants_str
        .split(',')
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
        .collect();

    if participants.is_empty() {
        return None;
    }

    Some(Note {
        position,
        participants,
        text,
    })
}

/// Parse participant declaration: participant Alice or participant A as Alice
fn parse_participant(line: &str) -> Option<Participant> {
    let rest = line
        .strip_prefix("participant")
        .or_else(|| line.strip_prefix("Participant"))?
        .trim();

    if rest.contains(" as ") {
        let parts: Vec<&str> = rest.splitn(2, " as ").collect();
        if parts.len() == 2 {
            return Some(Participant {
                id: parts[0].trim().to_string(),
                label: parts[1].trim().to_string(),
            });
        }
    }

    Some(Participant {
        id: rest.to_string(),
        label: rest.to_string(),
    })
}

/// Parse actor declaration: actor Alice or actor A as Alice
fn parse_actor(line: &str) -> Option<Participant> {
    let rest = line
        .strip_prefix("actor")
        .or_else(|| line.strip_prefix("Actor"))?
        .trim();

    if rest.contains(" as ") {
        let parts: Vec<&str> = rest.splitn(2, " as ").collect();
        if parts.len() == 2 {
            return Some(Participant {
                id: parts[0].trim().to_string(),
                label: parts[1].trim().to_string(),
            });
        }
    }

    Some(Participant {
        id: rest.to_string(),
        label: rest.to_string(),
    })
}

/// Parse message: From->>To: Label
fn parse_message(line: &str) -> Option<Message> {
    // Order matters - check longer patterns first
    let patterns = [
        ("-->>", ArrowStyle::Dotted),
        ("->>", ArrowStyle::Solid),
        ("-->", ArrowStyle::DottedLine),
        ("->", ArrowStyle::SolidLine),
        ("-)", ArrowStyle::Async),
    ];

    for (pattern, style) in patterns {
        if let Some(idx) = line.find(pattern) {
            let from = line[..idx].trim().to_string();
            let rest = line[idx + pattern.len()..].trim();

            // Parse label after colon
            let (to, label) = if let Some(colon_idx) = rest.find(':') {
                let to = rest[..colon_idx].trim().to_string();
                let label = rest[colon_idx + 1..].trim().to_string();
                (to, label)
            } else {
                (rest.to_string(), String::new())
            };

            if !from.is_empty() && !to.is_empty() {
                return Some(Message {
                    from,
                    to,
                    label,
                    style,
                });
            }
        }
    }

    None
}

/// Render sequence diagram to ASCII representation
#[allow(clippy::needless_range_loop)]
pub fn render_sequence_diagram(diagram: &SequenceDiagram, options: &RenderOptions) -> String {
    let mut output = String::new();

    if diagram.participants.is_empty() {
        return "No participants".to_string();
    }

    // Character set
    let (box_h, box_v, box_tl, box_tr, box_bl, box_br) = if options.ascii {
        ('-', '|', '+', '+', '+', '+')
    } else {
        ('─', '│', '┌', '┐', '└', '┘')
    };

    let arrow_r = if options.ascii { '>' } else { '▶' };
    let arrow_l = if options.ascii { '<' } else { '◀' };

    // Calculate participant column widths
    let min_col_width = 12;
    let col_widths: Vec<usize> = diagram
        .participants
        .iter()
        .map(|p| (p.label.len() + 4).max(min_col_width))
        .collect();

    // Calculate participant x positions (center of each column)
    let mut positions: Vec<usize> = Vec::new();
    let mut x = 0;
    for width in &col_widths {
        positions.push(x + width / 2);
        x += width;
    }
    let total_width = x;

    // Title
    if let Some(ref title) = diagram.title {
        let padding = (total_width.saturating_sub(title.len())) / 2;
        output.push_str(&" ".repeat(padding));
        output.push_str(title);
        output.push('\n');
        output.push_str(&" ".repeat(padding));
        output.push_str(&"─".repeat(title.len()));
        output.push_str("\n\n");
    }

    // Draw participant boxes at top
    // Box top line
    let mut line = vec![' '; total_width];
    for (i, p) in diagram.participants.iter().enumerate() {
        let center = positions[i];
        let box_width = p.label.len() + 2;
        let start = center.saturating_sub(box_width / 2);
        let end = start + box_width;

        if start < total_width {
            line[start] = box_tl;
        }
        for j in (start + 1)..end.min(total_width).saturating_sub(1) {
            line[j] = box_h;
        }
        if end > 0 && end - 1 < total_width {
            line[end - 1] = box_tr;
        }
    }
    output.push_str(&line.iter().collect::<String>());
    output.push('\n');

    // Box middle line (label)
    let mut line = vec![' '; total_width];
    for (i, p) in diagram.participants.iter().enumerate() {
        let center = positions[i];
        let box_width = p.label.len() + 2;
        let start = center.saturating_sub(box_width / 2);
        let end = start + box_width;

        if start < total_width {
            line[start] = box_v;
        }
        // Center label
        let label_start = start + 1;
        for (j, c) in p.label.chars().enumerate() {
            if label_start + j < total_width {
                line[label_start + j] = c;
            }
        }
        if end > 0 && end - 1 < total_width {
            line[end - 1] = box_v;
        }
    }
    output.push_str(&line.iter().collect::<String>());
    output.push('\n');

    // Box bottom line
    let mut line = vec![' '; total_width];
    for (i, p) in diagram.participants.iter().enumerate() {
        let center = positions[i];
        let box_width = p.label.len() + 2;
        let start = center.saturating_sub(box_width / 2);
        let end = start + box_width;

        if start < total_width {
            line[start] = box_bl;
        }
        for j in (start + 1)..end.min(total_width).saturating_sub(1) {
            line[j] = box_h;
        }
        if end > 0 && end - 1 < total_width {
            line[end - 1] = box_br;
        }
    }
    output.push_str(&line.iter().collect::<String>());
    output.push('\n');

    // Draw vertical lines (lifelines) and messages
    for msg in &diagram.messages {
        // Find participant indices
        let from_idx = diagram
            .participants
            .iter()
            .position(|p| p.id == msg.from || p.label == msg.from);
        let to_idx = diagram
            .participants
            .iter()
            .position(|p| p.id == msg.to || p.label == msg.to);

        if let (Some(from_i), Some(to_i)) = (from_idx, to_idx) {
            let from_x = positions[from_i];
            let to_x = positions[to_i];

            // Draw lifeline row with vertical lines at participant positions
            let mut line = vec![' '; total_width];
            for &pos in &positions {
                if pos < total_width {
                    line[pos] = if options.ascii { '|' } else { '│' };
                }
            }
            output.push_str(&line.iter().collect::<String>());
            output.push('\n');

            // Draw message arrow
            let mut line = vec![' '; total_width];
            for &pos in &positions {
                if pos < total_width {
                    line[pos] = if options.ascii { '|' } else { '│' };
                }
            }

            let (start_x, end_x, going_right) = if from_x < to_x {
                (from_x, to_x, true)
            } else {
                (to_x, from_x, false)
            };

            // Draw arrow line
            let arrow_char = match msg.style {
                ArrowStyle::Dotted | ArrowStyle::DottedLine => {
                    if options.ascii {
                        '-'
                    } else {
                        '·'
                    }
                }
                _ => {
                    if options.ascii {
                        '-'
                    } else {
                        '─'
                    }
                }
            };

            for x in (start_x + 1)..end_x {
                if x < total_width {
                    line[x] = arrow_char;
                }
            }

            // Draw arrow head
            let has_arrow = matches!(
                msg.style,
                ArrowStyle::Solid | ArrowStyle::Dotted | ArrowStyle::Async
            );
            if has_arrow {
                if going_right && end_x > 0 && end_x - 1 < total_width {
                    line[end_x - 1] = arrow_r;
                } else if !going_right && start_x + 1 < total_width {
                    line[start_x + 1] = arrow_l;
                }
            }

            output.push_str(&line.iter().collect::<String>());

            // Add label
            if !msg.label.is_empty() {
                output.push_str("  ");
                output.push_str(&msg.label);
            }
            output.push('\n');
        }
    }

    // Final lifeline row
    let mut line = vec![' '; total_width];
    for &pos in &positions {
        if pos < total_width {
            line[pos] = if options.ascii { '|' } else { '│' };
        }
    }
    output.push_str(&line.iter().collect::<String>());
    output.push('\n');

    output
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_simple_sequence() {
        let input = r#"sequenceDiagram
    Alice->>Bob: Hello
"#;
        let diagram = parse_sequence_diagram(input).unwrap();
        assert_eq!(diagram.participants.len(), 2);
        assert_eq!(diagram.messages.len(), 1);
        assert_eq!(diagram.messages[0].from, "Alice");
        assert_eq!(diagram.messages[0].to, "Bob");
        assert_eq!(diagram.messages[0].label, "Hello");
    }

    #[test]
    fn test_parse_participant_declaration() {
        let input = r#"sequenceDiagram
    participant A as Alice
    participant B as Bob
    A->>B: Hi
"#;
        let diagram = parse_sequence_diagram(input).unwrap();
        assert_eq!(diagram.participants.len(), 2);
        assert_eq!(diagram.participants[0].id, "A");
        assert_eq!(diagram.participants[0].label, "Alice");
    }

    #[test]
    fn test_parse_arrow_styles() {
        let input = r#"sequenceDiagram
    A->>B: Solid
    A-->>B: Dotted
    A->B: Line
    A-->B: DottedLine
"#;
        let diagram = parse_sequence_diagram(input).unwrap();
        assert_eq!(diagram.messages.len(), 4);
        assert_eq!(diagram.messages[0].style, ArrowStyle::Solid);
        assert_eq!(diagram.messages[1].style, ArrowStyle::Dotted);
        assert_eq!(diagram.messages[2].style, ArrowStyle::SolidLine);
        assert_eq!(diagram.messages[3].style, ArrowStyle::DottedLine);
    }

    #[test]
    fn test_render_sequence() {
        let msg = Message {
            from: "A".to_string(),
            to: "B".to_string(),
            label: "Hello".to_string(),
            style: ArrowStyle::Solid,
        };
        let diagram = SequenceDiagram {
            title: Some("Test".to_string()),
            participants: vec![
                Participant {
                    id: "A".to_string(),
                    label: "Alice".to_string(),
                },
                Participant {
                    id: "B".to_string(),
                    label: "Bob".to_string(),
                },
            ],
            items: vec![SequenceItem::Message(msg.clone())],
            messages: vec![msg],
        };
        let output = render_sequence_diagram(&diagram, &RenderOptions::default());
        assert!(output.contains("Test"));
        assert!(output.contains("Alice"));
        assert!(output.contains("Bob"));
        assert!(output.contains("Hello"));
    }

    #[test]
    fn test_seq_activate_deactivate() {
        let input = r#"sequenceDiagram
    Alice->>Bob: Hello
    activate Bob
    Bob-->>Alice: Hi
    deactivate Bob
"#;
        let diagram = parse_sequence_diagram(input).unwrap();
        assert_eq!(diagram.items.len(), 4);
        assert!(matches!(&diagram.items[1], SequenceItem::Activate(p) if p == "Bob"));
        assert!(matches!(&diagram.items[3], SequenceItem::Deactivate(p) if p == "Bob"));
    }

    #[test]
    fn test_seq_note_left_right() {
        let input = r#"sequenceDiagram
    Alice->>Bob: Hello
    Note right of Bob: Thinking
    Note left of Alice: Waiting
    Note over Alice,Bob: Both see this
"#;
        let diagram = parse_sequence_diagram(input).unwrap();
        assert_eq!(diagram.items.len(), 4);
        if let SequenceItem::Note(note) = &diagram.items[1] {
            assert_eq!(note.position, NotePosition::Right);
            assert_eq!(note.participants, vec!["Bob"]);
            assert_eq!(note.text, "Thinking");
        } else {
            panic!("Expected Note");
        }
    }

    #[test]
    fn test_seq_loop_block() {
        let input = r#"sequenceDiagram
    Alice->>Bob: Hello
    loop Every minute
        Bob->>Alice: Ping
    end
"#;
        let diagram = parse_sequence_diagram(input).unwrap();
        assert_eq!(diagram.items.len(), 2);
        if let SequenceItem::Loop { condition, items } = &diagram.items[1] {
            assert_eq!(condition, "Every minute");
            assert_eq!(items.len(), 1);
        } else {
            panic!("Expected Loop");
        }
    }

    #[test]
    fn test_seq_alt_else_block() {
        let input = r#"sequenceDiagram
    Alice->>Bob: Request
    alt Success
        Bob->>Alice: OK
    else Failure
        Bob->>Alice: Error
    end
"#;
        let diagram = parse_sequence_diagram(input).unwrap();
        assert_eq!(diagram.items.len(), 2);
        if let SequenceItem::Alt { condition, items, else_items } = &diagram.items[1] {
            assert_eq!(condition, "Success");
            assert_eq!(items.len(), 1);
            assert!(else_items.is_some());
            assert_eq!(else_items.as_ref().unwrap().len(), 1);
        } else {
            panic!("Expected Alt");
        }
    }
}