use async_trait::async_trait;
use rustyflow::{flow::Flow, node::Node, error::FlowError};
use serde_json::{json, Value};
struct GreetingNode;
#[async_trait]
impl Node for GreetingNode {
    async fn call(&self, input: Value) -> Result<Value, FlowError> {
        let name = input["name"].as_str().unwrap_or("World");
        Ok(json!({ "message": format!("Hello, {}!", name) }))
    }
}
#[tokio::main]
async fn main() {
    let flow = Flow::new(vec![Box::new(GreetingNode)]);
    let result = flow.execute(json!({"name": "Rust"})).await.unwrap();
    println!("{}", result); // {"message": "Hello, Rust!"}
}

#[async_trait]
pub trait Node: Send + Sync {
    async fn call(&self, input: Value) -> Result<Value, FlowError>;
}

let flow = Flow::new(vec![
    Box::new(DataPreprocessor),
    Box::new(ModelInference),
    Box::new(PostProcessor),
]);

let parallel_flow = ParallelFlow::new(vec![
    Box::new(ClassificationModel),
    Box::new(SentimentAnalysis),
    Box::new(EntityExtraction),
]);

#[derive(Deserialize)]
struct CalculateRequest {
    operation: String,
    a: f64,
    b: f64,
}
#[derive(Serialize)]
struct CalculateResponse {
    result: f64,
}
struct Calculator;
#[async_trait]
impl Tool for Calculator {
    type Input = CalculateRequest;
    type Output = CalculateResponse;
    async fn run(&self, input: Self::Input) -> Result<Self::Output, FlowError> {
        let result = match input.operation.as_str() {
            "add" => input.a + input.b,
            "multiply" => input.a * input.b,
            _ => return Err(FlowError::NodeFailed("Unknown operation".to_string())),
        };
        Ok(CalculateResponse { result })
    }
}

let processor = StringProcessor::new("_processed");
let batch_node = Batch::new(processor);
let flow = Flow::new(vec![Box::new(batch_node)]);
// Input: ["item1", "item2", "item3"]
// Output: ["item1_processed", "item2_processed", "item3_processed"]

use rustyflow::flow::Flow;
#[tokio::main]
async fn main() {
    let flow = Flow::new(vec![
        Box::new(DataValidator),
        Box::new(TextProcessor),
        Box::new(ResultFormatter),
    ]);
    
    let result = flow.execute(json!({"text": "Hello World"})).await?;
}

use rustyflow::flow::ParallelFlow;
#[tokio::main]
async fn main() {
    let parallel_flow = ParallelFlow::new(vec![
        Box::new(ServiceA),
        Box::new(ServiceB),
        Box::new(ServiceC),
    ]);
    
    let results = parallel_flow.execute(json!({"data": "input"})).await?;
    // Returns array of results from all services
}

use rustyflow::batch::Batch;
#[tokio::main]
async fn main() {
    let processor = DocumentProcessor::new();
    let batch_processor = Batch::new(processor);
    let flow = Flow::new(vec![Box::new(batch_processor)]);
    
    let documents = json!(["doc1.txt", "doc2.txt", "doc3.txt"]);
    let results = flow.execute(documents).await?;
}

use rustyflow::tool::ToolNode;
#[tokio::main]
async fn main() {
    let calculator = Calculator;
    let tool_node = ToolNode::new(calculator);
    let flow = Flow::new(vec![Box::new(tool_node)]);
    
    let request = json!({
        "operation": "add",
        "a": 10.0,
        "b": 5.0
    });
    
    let result = flow.execute(request).await?;
    // Result: {"result": 15.0}
}

use axum::{Router, routing::post};
use rustyflow::flow::Flow;
#[tokio::main]
async fn main() {
    let flow = Arc::new(Flow::new(vec![
        Box::new(AuthenticationNode),
        Box::new(ProcessingNode),
        Box::new(ResponseNode),
    ]));
    let app = Router::new()
        .route("/execute", post(execute_flow))
        .with_state(flow);
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

#[derive(Error, Debug)]
pub enum FlowError {
    #[error("Node execution failed: {0}")]
    NodeFailed(String),
    
    #[error("Data serialization/deserialization error: {0}")]
    SerdeError(#[from] serde_json::Error),
    
    #[error("An unknown error occurred")]
    Unknown,
}