use serde::{Deserialize, Serialize};
use std::{fs, path::Path};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SwarmService {
    pub name: String,
    pub image: Option<String>,
    pub mode: Option<String>,
    pub replicas: Option<String>,
    pub updated_at: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SwarmTask {
    pub id: String,
    pub service: String,
    pub node: Option<String>,
    pub desired_state: Option<String>,
    pub current_state: Option<String>,
    pub error: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SwarmStateFile {
    pub services: Vec<SwarmService>,
    pub tasks: Vec<SwarmTask>,
}

#[derive(Clone)]
pub struct SwarmStore {
    path: std::path::PathBuf,
}

impl SwarmStore {
    pub fn new(path: std::path::PathBuf) -> Self {
        Self { path }
    }

    pub fn list_services(&self) -> Vec<SwarmService> {
        self.load().map(|s| s.services).unwrap_or_default()
    }

    pub fn list_tasks(&self, service_name: &str) -> Vec<SwarmTask> {
        self.load()
            .map(|s| {
                s.tasks
                    .into_iter()
                    .filter(|t| t.service == service_name)
                    .collect()
            })
            .unwrap_or_default()
    }

    fn load(&self) -> Option<SwarmStateFile> {
        load_state(&self.path)
    }
}

fn load_state(path: &Path) -> Option<SwarmStateFile> {
    let raw = fs::read_to_string(path).ok()?;
    serde_json::from_str(&raw).ok()
}