Build a Rust Backend API Server

use actix_web::{web, App, HttpServer, HttpResponse, Responder};
use actix_web::{get, post, patch, delete};
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Item {
    pub id: Option<u64>,
    pub name: String,
    pub description: String,
}

#[derive(Debug, Deserialize)]
pub struct ItemUpdate {
    pub name: Option<String>,
    pub description: Option<String>,
}

// Application state with shared items vector
pub struct AppState {
    pub items: Mutex<Vec<Item>>,
}

#[get("/api/items")]
pub async fn get_items(data: web::Data<AppState>) -> impl Responder {
    let items = data.items.lock().unwrap();
    HttpResponse::Ok().json(&*items)
}

#[get("/api/items/{id}")]
pub async fn get_item(
    path: web::Path<u64>,
    data: web::Data<AppState>
) -> impl Responder {
    let id = path.into_inner();
    let items = data.items.lock().unwrap();
    
    if let Some(item) = items.iter().find(|i| i.id == Some(id)) {
        HttpResponse::Ok().json(item)
    } else {
        HttpResponse::NotFound().body("Item not found")
    }
}

#[post("/api/items")]
pub async fn create_item(
    item: web::Json<Item>,
    data: web::Data<AppState>
) -> impl Responder {
    let mut items = data.items.lock().unwrap();
    let mut new_item = item.into_inner();
    
    // Generate new ID
    let new_id = items.len() as u64 + 1;
    new_item.id = Some(new_id);
    
    items.push(new_item.clone());
    HttpResponse::Created().json(new_item)
}

#[patch("/api/items/{id}")]
pub async fn update_item(
    path: web::Path<u64>,
    item_update: web::Json<ItemUpdate>,
    data: web::Data<AppState>
) -> impl Responder {
    let id = path.into_inner();
    let mut items = data.items.lock().unwrap();
    
    if let Some(item) = items.iter_mut().find(|i| i.id == Some(id)) {
        if let Some(name) = &item_update.name {
            item.name = name.clone();
        }
        if let Some(desc) = &item_update.description {
            item.description = desc.clone();
        }
        HttpResponse::Ok().json(item)
    } else {
        HttpResponse::NotFound().body("Item not found")
    }
}

#[delete("/api/items/{id}")]
pub async fn delete_item(
    path: web::Path<u64>,
    data: web::Data<AppState>
) -> impl Responder {
    let id = path.into_inner();
    let mut items = data.items.lock().unwrap();
    
    let initial_len = items.len();
    items.retain(|i| i.id != Some(id));
    
    if items.len() != initial_len {
        HttpResponse::Ok().body("Item deleted")
    } else {
        HttpResponse::NotFound().body("Item not found")
    }
}

// Configure routes function
pub fn config_app(cfg: &mut web::ServiceConfig) {
    cfg.service(get_items)
       .service(get_item)
       .service(create_item)
       .service(update_item)
       .service(delete_item);
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // Initialize application state with some sample items
    let app_state = web::Data::new(AppState {
        items: Mutex::new(vec![
            Item {
                id: Some(1),
                name: "Sample Item".to_string(),
                description: "This is a sample item".to_string(),
            }
        ]),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .configure(config_app)
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}