sprites 0.1.0

//! Filesystem operations for sprites
//!
//! This module provides file and directory operations on a sprite's filesystem.
//!
//! # Example
//!
//! ```no_run
//! use sprites::SpritesClient;
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let client = SpritesClient::new("token");
//!     let sprite = client.sprite("my-sprite");
//!     let fs = sprite.filesystem();
//!
//!     // Write a file
//!     fs.write_file("/tmp/hello.txt", b"Hello, world!").await?;
//!
//!     // Read it back
//!     let data = fs.read_file("/tmp/hello.txt").await?;
//!     println!("{}", String::from_utf8_lossy(&data));
//!
//!     // Create a directory
//!     fs.mkdir("/tmp/mydir").await?;
//!
//!     // List directory contents
//!     let entries = fs.read_dir("/tmp").await?;
//!     for entry in entries {
//!         println!("{}: {} bytes", entry.name, entry.size);
//!     }
//!
//!     Ok(())
//! }
//! ```

use crate::error::{Error, Result};
use crate::sprite::Sprite;
use chrono::{DateTime, Utc};
use serde::Deserialize;

/// Handle for filesystem operations on a sprite
#[derive(Clone)]
pub struct Filesystem {
    sprite: Sprite,
    cwd: Option<String>,
}

/// Information about a file
#[derive(Debug, Clone, Deserialize)]
pub struct FileInfo {
    /// File name
    pub name: String,

    /// File size in bytes
    #[serde(default)]
    pub size: u64,

    /// File mode (permissions)
    #[serde(default)]
    pub mode: u32,

    /// Last modification time
    #[serde(default, alias = "mod_time")]
    pub modified: Option<DateTime<Utc>>,

    /// Whether this is a directory
    #[serde(default)]
    pub is_dir: bool,
}

/// Entry in a directory listing
#[derive(Debug, Clone, Deserialize)]
pub struct DirEntry {
    /// Entry name
    pub name: String,

    /// Whether this is a directory
    #[serde(default)]
    pub is_dir: bool,

    /// Size in bytes (0 for directories)
    #[serde(default)]
    pub size: u64,

    /// File mode (permissions)
    #[serde(default)]
    pub mode: u32,

    /// Last modification time
    #[serde(default, alias = "mod_time")]
    pub modified: Option<DateTime<Utc>>,
}

impl Filesystem {
    /// Create a new filesystem handle for a sprite
    pub(crate) fn new(sprite: Sprite) -> Self {
        Self { sprite, cwd: None }
    }

    /// Create a filesystem handle with a working directory
    pub(crate) fn with_cwd(sprite: Sprite, cwd: String) -> Self {
        Self {
            sprite,
            cwd: Some(cwd),
        }
    }

    /// Change to a new working directory (returns a new Filesystem handle)
    pub fn cd(&self, path: &str) -> Filesystem {
        let new_cwd = if path.starts_with('/') {
            path.to_string()
        } else if let Some(ref cwd) = self.cwd {
            format!("{}/{}", cwd.trim_end_matches('/'), path)
        } else {
            format!("/{path}")
        };

        Filesystem {
            sprite: self.sprite.clone(),
            cwd: Some(new_cwd),
        }
    }

    /// Resolve a path relative to the current working directory
    fn resolve_path(&self, path: &str) -> String {
        if path.starts_with('/') {
            path.to_string()
        } else if let Some(ref cwd) = self.cwd {
            format!("{}/{}", cwd.trim_end_matches('/'), path)
        } else {
            format!("/{path}")
        }
    }

    /// Build URL for filesystem operations
    fn fs_url(&self, path: &str) -> String {
        let resolved = self.resolve_path(path);
        // URL encode the path but preserve forward slashes
        let encoded = resolved
            .split('/')
            .map(|segment| urlencoding::encode(segment).into_owned())
            .collect::<Vec<_>>()
            .join("/");
        self.sprite
            .client()
            .url(&format!("/sprites/{}/fs{}", self.sprite.name(), encoded))
    }

    /// Read a file's contents
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use sprites::SpritesClient;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let client = SpritesClient::new("token");
    /// let sprite = client.sprite("my-sprite");
    ///
    /// let data = sprite.filesystem().read_file("/etc/hostname").await?;
    /// println!("Hostname: {}", String::from_utf8_lossy(&data));
    /// # Ok(())
    /// # }
    /// ```
    pub async fn read_file(&self, path: &str) -> Result<Vec<u8>> {
        let url = self.fs_url(path);

        let response = self
            .sprite
            .client()
            .http()
            .get(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if status == reqwest::StatusCode::NOT_FOUND {
            return Err(Error::not_found(path));
        }
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let bytes = response.bytes().await?;
        Ok(bytes.to_vec())
    }

    /// Read a file as a string
    pub async fn read_to_string(&self, path: &str) -> Result<String> {
        let data = self.read_file(path).await?;
        Ok(String::from_utf8_lossy(&data).to_string())
    }

    /// Write data to a file
    ///
    /// Creates the file if it doesn't exist, overwrites if it does.
    pub async fn write_file(&self, path: &str, data: &[u8]) -> Result<()> {
        let url = self.fs_url(path);

        let response = self
            .sprite
            .client()
            .http()
            .put(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .header("Content-Type", "application/octet-stream")
            .body(data.to_vec())
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Write data to a file with specific permissions
    pub async fn write_file_with_mode(&self, path: &str, data: &[u8], mode: u32) -> Result<()> {
        // First write the file
        self.write_file(path, data).await?;
        // Then set permissions
        self.chmod(path, mode).await
    }

    /// Read directory contents
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use sprites::SpritesClient;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let client = SpritesClient::new("token");
    /// let sprite = client.sprite("my-sprite");
    ///
    /// let entries = sprite.filesystem().read_dir("/home").await?;
    /// for entry in entries {
    ///     let kind = if entry.is_dir { "dir" } else { "file" };
    ///     println!("{} ({})", entry.name, kind);
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub async fn read_dir(&self, path: &str) -> Result<Vec<DirEntry>> {
        let url = format!("{}?list=true", self.fs_url(path));

        let response = self
            .sprite
            .client()
            .http()
            .get(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if status == reqwest::StatusCode::NOT_FOUND {
            return Err(Error::not_found(path));
        }
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let entries: Vec<DirEntry> = response.json().await?;
        Ok(entries)
    }

    /// Create a directory
    pub async fn mkdir(&self, path: &str) -> Result<()> {
        let url = format!("{}?mkdir=true", self.fs_url(path));

        let response = self
            .sprite
            .client()
            .http()
            .post(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Create a directory and all parent directories
    pub async fn mkdir_all(&self, path: &str) -> Result<()> {
        let url = format!("{}?mkdir=true&parents=true", self.fs_url(path));

        let response = self
            .sprite
            .client()
            .http()
            .post(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Remove a file or empty directory
    pub async fn remove(&self, path: &str) -> Result<()> {
        let url = self.fs_url(path);

        let response = self
            .sprite
            .client()
            .http()
            .delete(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if status == reqwest::StatusCode::NOT_FOUND {
            return Err(Error::not_found(path));
        }
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Remove a file or directory recursively
    pub async fn remove_all(&self, path: &str) -> Result<()> {
        let url = format!("{}?recursive=true", self.fs_url(path));

        let response = self
            .sprite
            .client()
            .http()
            .delete(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if status == reqwest::StatusCode::NOT_FOUND {
            return Err(Error::not_found(path));
        }
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Rename/move a file or directory
    pub async fn rename(&self, from: &str, to: &str) -> Result<()> {
        let from_path = self.resolve_path(from);
        let to_path = self.resolve_path(to);

        let url = self.sprite.client().url(&format!(
            "/sprites/{}/fs?rename={}&to={}",
            self.sprite.name(),
            urlencoding::encode(&from_path),
            urlencoding::encode(&to_path)
        ));

        let response = self
            .sprite
            .client()
            .http()
            .post(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Copy a file
    pub async fn copy(&self, from: &str, to: &str) -> Result<()> {
        let from_path = self.resolve_path(from);
        let to_path = self.resolve_path(to);

        let url = self.sprite.client().url(&format!(
            "/sprites/{}/fs?copy={}&to={}",
            self.sprite.name(),
            urlencoding::encode(&from_path),
            urlencoding::encode(&to_path)
        ));

        let response = self
            .sprite
            .client()
            .http()
            .post(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Change file permissions
    pub async fn chmod(&self, path: &str, mode: u32) -> Result<()> {
        let url = format!("{}?chmod={:o}", self.fs_url(path), mode);

        let response = self
            .sprite
            .client()
            .http()
            .post(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Get file information (stat)
    pub async fn stat(&self, path: &str) -> Result<FileInfo> {
        let url = format!("{}?stat=true", self.fs_url(path));

        let response = self
            .sprite
            .client()
            .http()
            .get(&url)
            .header("Authorization", self.sprite.client().auth_header())
            .send()
            .await?;

        let status = response.status();
        if status == reqwest::StatusCode::NOT_FOUND {
            return Err(Error::not_found(path));
        }
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let info: FileInfo = response.json().await?;
        Ok(info)
    }

    /// Check if a file or directory exists
    pub async fn exists(&self, path: &str) -> Result<bool> {
        match self.stat(path).await {
            Ok(_) => Ok(true),
            Err(Error::NotFound(_)) => Ok(false),
            Err(e) => Err(e),
        }
    }
}

// URL encoding helper
mod urlencoding {
    pub fn encode(s: &str) -> std::borrow::Cow<'_, str> {
        let mut needs_encoding = false;
        for c in s.chars() {
            match c {
                'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.' | '~' => {}
                _ => {
                    needs_encoding = true;
                    break;
                }
            }
        }

        if !needs_encoding {
            return std::borrow::Cow::Borrowed(s);
        }

        let mut result = String::new();
        for c in s.chars() {
            match c {
                'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.' | '~' => result.push(c),
                _ => {
                    for byte in c.to_string().as_bytes() {
                        result.push_str(&format!("%{byte:02X}"));
                    }
                }
            }
        }
        std::borrow::Cow::Owned(result)
    }
}