Dependencies

pub struct DependencyGraph {
    pub cards: CardDependencyGraph,
    // Future: sprints, boards
}

pub type CardDependencyGraph = Graph<CardEdgeType>;

pub enum CardEdgeType {
    /// This card blocks the target (must complete before target can start)
    /// Enforces DAG - no cycles allowed
    Blocks,
    
    /// General relationship (informational, allows cycles)
    RelatesTo,
    
    /// Organizational grouping - parent contains child
    /// Enforces DAG - no cycles allowed (can't be own ancestor)
    ParentOf,
}

// Blocks and ParentOf require DAG (no cycles)
assert!(CardEdgeType::Blocks.requires_dag());
assert!(CardEdgeType::ParentOf.requires_dag());

// RelatesTo allows cycles
assert!(CardEdgeType::RelatesTo.allows_cycles());

// Card A must complete before Card B can start
graph.add_blocks(card_a, card_b)?;

// Prevents cycles
graph.add_blocks(card_b, card_c)?;
graph.add_blocks(card_c, card_a)?; // Error: CycleDetected

// Get all cards blocking a given card
let blockers = graph.blockers(card_b);
assert!(blockers.contains(&card_a));

// Get all cards blocked by a given card
let blocked = graph.blocked_by(card_a);
assert!(blocked.contains(&card_b));

// Check if all blocking cards are complete
let can_start = graph.can_start(card_c, |id| {
    cards.iter()
        .find(|c| c.id == id)
        .map(|c| c.is_completed())
        .unwrap_or(false)
});

if can_start {
    println!("Card C ready to start!");
}

// Card B becomes a child of Card A
graph.set_parent(card_b, card_a)?;

// Multiple children allowed
graph.set_parent(card_c, card_a)?;
graph.set_parent(card_d, card_a)?;

assert_eq!(graph.children(card_a).len(), 3);

// Get direct children
let children = graph.children(parent_id);

// Get direct parents
let parents = graph.parents(child_id);

// Get all ancestors (parents, grandparents, etc.)
let ancestors = graph.ancestors(child_id);

// Get all descendants (children, grandchildren, etc.)
let descendants = graph.descendants(parent_id);

// Count direct children (for [N] badge)
let count = graph.child_count(parent_id);

// Remove specific parent-child link
graph.remove_parent(child_id, parent_id)?;

// Returns EdgeNotFound if relationship doesn't exist

// Create bidirectional relationship
graph.add_relates_to(card_a, card_b)?;

// Both cards see the relationship
assert!(graph.related(card_a).contains(&card_b));
assert!(graph.related(card_b).contains(&card_a));

// Allows cycles
graph.add_relates_to(card_b, card_c)?;
graph.add_relates_to(card_c, card_a)?; // OK - cycles allowed

// Archive all edges for a card (soft delete)
graph.archive_card_edges(card_id);

// Archived edges are excluded from queries
assert_eq!(graph.blockers(card_id).len(), 0);

// Can be restored
graph.unarchive_node(card_id);
assert_eq!(graph.blockers(card_id).len(), 1);

// Remove all edges permanently
graph.remove_card_edges(card_id);

// All incoming and outgoing edges deleted
assert_eq!(graph.blockers(card_id).len(), 0);
assert_eq!(graph.blocked_by(card_id).len(), 0);
assert_eq!(graph.children(card_id).len(), 0);
assert_eq!(graph.parents(card_id).len(), 0);

use kanban_core::KanbanError;

match graph.add_blocks(card_a, card_b) {
    Ok(()) => println!("Dependency added"),
    Err(KanbanError::CycleDetected) => {
        println!("Would create cycle");
    }
    Err(KanbanError::SelfReference) => {
        println!("Can't block self");
    }
    Err(e) => println!("Error: {:?}", e),
}

pub struct Edge<E> {
    pub source: Uuid,
    pub target: Uuid,
    pub edge_type: E,
    pub direction: EdgeDirection,
    pub weight: Option<f64>,
    pub created_at: DateTime<Utc>,
    pub archived_at: Option<DateTime<Utc>>,
}

pub enum EdgeDirection {
    Directed,      // One-way (Blocks, ParentOf)
    Bidirectional, // Two-way (RelatesTo)
}

// Check if adding edge would create cycle
if graph.would_create_cycle(source, target) {
    return Err(KanbanError::CycleDetected);
}

// Find all reachable nodes
let reachable = graph.reachable_from(start_node);

let epic = create_card("Implement User Auth");
let subtask1 = create_card("Design auth schema");
let subtask2 = create_card("Implement login");
let subtask3 = create_card("Add password reset");

// Create hierarchy
graph.set_parent(subtask1, epic)?;
graph.set_parent(subtask2, epic)?;
graph.set_parent(subtask3, epic)?;

// subtask2 depends on subtask1
graph.add_blocks(subtask1, subtask2)?;

println!("Epic has {} subtasks", graph.child_count(epic));

let design = create_card("Design API");
let implement = create_card("Implement API");
let test = create_card("Test API");
let document = create_card("Document API");

// Linear dependency chain
graph.add_blocks(design, implement)?;
graph.add_blocks(implement, test)?;
graph.add_blocks(test, document)?;

// Check what's ready
for card in cards {
    if graph.can_start(card.id, |id| is_complete(id)) {
        println!("Ready: {}", card.title);
    }
}

let feature_a = create_card("Feature A");
let feature_b = create_card("Feature B");
let integration = create_card("Integration Test");

// Integration depends on both features
graph.add_blocks(feature_a, integration)?;
graph.add_blocks(feature_b, integration)?;

// Features are related but independent
graph.add_relates_to(feature_a, feature_b)?;