use std::process::Stdio;

use anyhow::Context;
use tokio::io::AsyncWriteExt;

use crate::state::State;

#[derive(Default)]
pub struct LocalCopier {}

impl LocalCopier {
    pub fn new() -> Self {
        Self {}
    }

    pub async fn copy(&self, input: &[u8]) -> anyhow::Result<()> {
        // FIXME: hardcode for macos
        let mut copy_process = tokio::process::Command::new("pbcopy")
            .stdin(Stdio::piped())
            .spawn()?;

        if let Some(mut stdin_handle) = copy_process.stdin.take() {
            stdin_handle
                .write_all(input)
                .await
                .context("failed to write input to copy process")?;
            stdin_handle
                .flush()
                .await
                .context("failed to flush to program")?;
        }

        let status = copy_process.wait().await?;
        tracing::info!("copy process ended with status: {:?}", status);

        Ok(())
    }
}

pub trait LocalCopierState {
    fn local_copier(&self) -> LocalCopier;
}

impl LocalCopierState for State {
    fn local_copier(&self) -> LocalCopier {
        LocalCopier::new()
    }
}