use super::RpcHandler;
use crate::update;
use anyhow::Result;

impl RpcHandler {
    /// Check for available system updates.
    pub(super) async fn handle_update_check(&self) -> Result<serde_json::Value> {
        let state = update::check_for_updates(&self.config.data_dir).await?;

        let update_info = state.available_update.as_ref().map(|u| {
            serde_json::json!({
                "version": u.version,
                "release_date": u.release_date,
                "changelog": u.changelog,
                "components": u.components.len(),
            })
        });

        Ok(serde_json::json!({
            "current_version": state.current_version,
            "last_check": state.last_check,
            "update_available": update_info.is_some(),
            "update": update_info,
        }))
    }

    /// Get update status without checking remote.
    pub(super) async fn handle_update_status(&self) -> Result<serde_json::Value> {
        let state = update::get_status(&self.config.data_dir).await?;

        Ok(serde_json::json!({
            "current_version": state.current_version,
            "last_check": state.last_check,
            "update_available": state.available_update.is_some(),
            "update_in_progress": state.update_in_progress,
            "rollback_available": state.rollback_available,
        }))
    }

    /// Dismiss the update notification.
    pub(super) async fn handle_update_dismiss(&self) -> Result<serde_json::Value> {
        update::dismiss_update(&self.config.data_dir).await?;
        Ok(serde_json::json!({ "ok": true }))
    }

    /// Download the available update to staging.
    pub(super) async fn handle_update_download(&self) -> Result<serde_json::Value> {
        let progress = update::download_update(&self.config.data_dir).await?;
        Ok(serde_json::json!({
            "total_bytes": progress.total_bytes,
            "downloaded_bytes": progress.downloaded_bytes,
            "components_downloaded": progress.components_downloaded,
        }))
    }

    /// Apply the staged update.
    pub(super) async fn handle_update_apply(&self) -> Result<serde_json::Value> {
        update::apply_update(&self.config.data_dir).await?;
        Ok(serde_json::json!({ "applied": true, "restart_required": true }))
    }

    /// Rollback to the previous version.
    pub(super) async fn handle_update_rollback(&self) -> Result<serde_json::Value> {
        update::rollback_update(&self.config.data_dir).await?;
        Ok(serde_json::json!({ "rolled_back": true, "restart_required": true }))
    }

    /// Get the current update schedule.
    pub(super) async fn handle_update_get_schedule(&self) -> Result<serde_json::Value> {
        let schedule = update::get_schedule(&self.config.data_dir).await?;
        Ok(serde_json::json!({ "schedule": schedule }))
    }

    /// Set the update schedule. Params: { schedule: "manual" | "daily_check" | "auto_apply" }
    pub(super) async fn handle_update_set_schedule(
        &self,
        params: &serde_json::Value,
    ) -> Result<serde_json::Value> {
        let schedule_str = params["schedule"]
            .as_str()
            .ok_or_else(|| anyhow::anyhow!("Missing 'schedule' parameter"))?;

        let schedule = match schedule_str {
            "manual" => update::UpdateSchedule::Manual,
            "daily_check" => update::UpdateSchedule::DailyCheck,
            "auto_apply" => update::UpdateSchedule::AutoApply,
            _ => anyhow::bail!("Invalid schedule: '{}'. Use manual, daily_check, or auto_apply", schedule_str),
        };

        update::set_schedule(&self.config.data_dir, schedule).await?;
        Ok(serde_json::json!({ "schedule": schedule }))
    }
}