hakorune/src/boxes/file/mod.rs

//! FileBox 📁 - ファイルI/O（PathBox/DirBoxとセット）
// Nyashの箱システムによるファイル入出力を提供します。
// 参考: 既存Boxの設計思想

// SSOT provider design (ring‑0/1) — modules are currently placeholders
pub mod box_shim; // Thin delegating shim
pub mod builtin_factory;
pub mod core_ro; // Core read‑only provider
pub mod provider; // trait FileIo / FileCaps / FileError // Builtin FileBox ProviderFactory

use crate::box_trait::{BoolBox, BoxBase, BoxCore, NyashBox, StringBox};
use crate::runtime::provider_lock;
use std::any::Any;
use std::sync::Arc;

use self::provider::FileIo;

pub struct FileBox {
    provider: Option<Arc<dyn FileIo>>,
    path: String,
    base: BoxBase,
}

impl std::fmt::Debug for FileBox {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("FileBox")
            .field("path", &self.path)
            .field("provider", &"<FileIo>")
            .finish()
    }
}

impl Clone for FileBox {
    fn clone(&self) -> Self {
        // Clone by copying provider reference and path
        FileBox {
            provider: self.provider.clone(),
            path: self.path.clone(),
            base: BoxBase::new(),
        }
    }
}

impl FileBox {
    pub fn new() -> Self {
        FileBox {
            provider: provider_lock::get_filebox_provider().cloned(),
            path: String::new(),
            base: BoxBase::new(),
        }
    }

    /// Create FileBox with explicit provider (for builtin fallback)
    pub fn with_provider(provider: Arc<dyn FileIo>) -> Self {
        FileBox {
            provider: Some(provider),
            path: String::new(),
            base: BoxBase::new(),
        }
    }

    pub fn open(path: &str) -> Result<Self, String> {
        let provider = provider_lock::get_filebox_provider()
            .ok_or("FileBox provider not initialized")?
            .clone();

        provider
            .open(path)
            .map_err(|e| format!("Failed to open: {}", e))?;

        Ok(FileBox {
            provider: Some(provider),
            path: path.to_string(),
            base: BoxBase::new(),
        })
    }

    pub fn read_to_string(&self) -> Result<String, String> {
        if let Some(ref provider) = self.provider {
            provider.read().map_err(|e| format!("Read failed: {}", e))
        } else {
            Err("No provider available".to_string())
        }
    }

    pub fn write_all(&self, _buf: &[u8]) -> Result<(), String> {
        // Fail-Fast by capability: consult provider caps
        let caps = self
            .provider
            .as_ref()
            .map(|p| p.caps())
            .or_else(|| provider_lock::get_filebox_caps())
            .unwrap_or_else(|| provider::FileCaps::read_only());
        if !caps.write {
            return Err("Write unsupported by current FileBox provider (read-only)".to_string());
        }
        // Write-capable provider not wired yet
        Err("Write supported by provider but not implemented in this build".to_string())
    }

    /// ファイルの内容を読み取る
    pub fn read(&self) -> Box<dyn NyashBox> {
        match self.read_to_string() {
            Ok(content) => Box::new(StringBox::new(&content)),
            Err(e) => Box::new(StringBox::new(&format!("Error reading file: {}", e))),
        }
    }

    /// ファイルに内容を書き込む
    pub fn write(&self, _content: Box<dyn NyashBox>) -> Box<dyn NyashBox> {
        let caps = self
            .provider
            .as_ref()
            .map(|p| p.caps())
            .or_else(|| provider_lock::get_filebox_caps())
            .unwrap_or_else(|| provider::FileCaps::read_only());
        if !caps.write {
            return Box::new(StringBox::new(
                "Error: write unsupported by provider (read-only)",
            ));
        }
        Box::new(StringBox::new(
            "Error: write supported but not implemented in this build",
        ))
    }

    /// ファイルが存在するかチェック
    pub fn exists(&self) -> Box<dyn NyashBox> {
        use std::path::Path;
        Box::new(BoolBox::new(Path::new(&self.path).exists()))
    }

    /// ファイルを削除
    pub fn delete(&self) -> Box<dyn NyashBox> {
        let caps = self
            .provider
            .as_ref()
            .map(|p| p.caps())
            .or_else(|| provider_lock::get_filebox_caps())
            .unwrap_or_else(|| provider::FileCaps::read_only());
        if !caps.write {
            return Box::new(StringBox::new(
                "Error: delete unsupported by provider (read-only)",
            ));
        }
        Box::new(StringBox::new(
            "Error: delete supported but not implemented in this build",
        ))
    }

    /// ファイルをコピー
    pub fn copy(&self, _dest: &str) -> Box<dyn NyashBox> {
        let caps = self
            .provider
            .as_ref()
            .map(|p| p.caps())
            .or_else(|| provider_lock::get_filebox_caps())
            .unwrap_or_else(|| provider::FileCaps::read_only());
        if !caps.write {
            return Box::new(StringBox::new(
                "Error: copy unsupported by provider (read-only)",
            ));
        }
        Box::new(StringBox::new(
            "Error: copy supported but not implemented in this build",
        ))
    }
}

impl BoxCore for FileBox {
    fn box_id(&self) -> u64 {
        self.base.id
    }

    fn parent_type_id(&self) -> Option<std::any::TypeId> {
        self.base.parent_type_id
    }

    fn fmt_box(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "FileBox({})", self.path)
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}

impl NyashBox for FileBox {
    fn clone_box(&self) -> Box<dyn NyashBox> {
        // Clone by copying provider and path reference
        Box::new(self.clone())
    }

    /// 仮実装: clone_boxと同じ（後で修正）
    fn share_box(&self) -> Box<dyn NyashBox> {
        self.clone_box()
    }

    fn to_string_box(&self) -> StringBox {
        StringBox::new(format!("FileBox({})", self.path))
    }

    fn type_name(&self) -> &'static str {
        "FileBox"
    }

    fn equals(&self, other: &dyn NyashBox) -> BoolBox {
        if let Some(other_file) = other.as_any().downcast_ref::<FileBox>() {
            BoolBox::new(self.path == other_file.path)
        } else {
            BoolBox::new(false)
        }
    }
}

impl std::fmt::Display for FileBox {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.fmt_box(f)
    }
}