threadsafe_function! {
    "scm": scm {
        "createSourceControl":
            create_source_control(
                String,
                String,
                Option<crate::vscode_sys::reference::UriRef>
            ) -> crate::vscode_sys::reference::SourceControlRef;
    }
}

    Uri,

object_reference!(UriRef: Uri);

        let added_workspace_uri = added_workspace.get_uri()?;
        let added_uri = added_workspace_uri.to_string()?;
        event_loop::send(Event::OpenWorkspaceFolder { uri: added_uri });

    event_loop::start();

    event_loop::start(env)?;

        let workspace_uri = workspace_folder.get_uri()?;
        let uri = workspace_uri.to_string()?;
        event_loop::send(Event::OpenWorkspaceFolder { uri });

use napi::bindgen_prelude::FnArgs;
use crate::vscode_sys;
pub struct ThreadsafeFunctions {
    create_source_control: vscode_sys::threadsafe_function::scm::create_source_control::Prototype,
}
impl ThreadsafeFunctions {
    pub fn get(env: &napi::Env) -> Result<Self, napi::Error> {
        Ok(Self {
            create_source_control:
                vscode_sys::threadsafe_function::scm::create_source_control::get(env)?,
        })
    }
    pub async fn create_source_control(
        &self,
        id: String,
        name: String,
        uri: &str,
    ) -> Result<vscode_sys::reference::SourceControlRef, napi::Error> {
        let arguments = FnArgs::from((id, name, None));
        self.create_source_control.call_async(arguments).await
    }
}

mod threadsafe_functions;

mod threadsafe_function;

pub enum Event {}

pub enum Event {
    OpenWorkspaceFolder { uri: String },
}

async fn event_loop(mut receiver: UnboundedReceiver<Event>) {

async fn event_loop(
    threadsafe_functions: threadsafe_function::ThreadsafeFunctions,
    mut receiver: UnboundedReceiver<Event>,
) {

        for event in &event_buffer {
            match event {
                Event::OpenWorkspaceFolder { uri } => {
                    // TODO: handle multiple repositories per workspace
                    // TODO: properly handle URIs
                    let source_control_ref = match threadsafe_functions
                        .create_source_control(String::from("pijul"), String::from("Pijul"), uri)
                        .await
                    {
                        Ok(source_control_ref) => source_control_ref,
                        Err(error) => {
                            tracing::error!(message = "Unable to create source control", ?error);
                            continue;
                        }
                    };
                }
            }
        }

#[tracing::instrument]
pub fn start() {

#[tracing::instrument(skip_all)]
pub fn start(env: &napi::Env) -> Result<(), napi::Error> {
    let threadsafe_functions = threadsafe_function::ThreadsafeFunctions::get(env)?;

        tracing::error!("Event sender has already been initialized");

        return Err(napi::Error::from_reason(
            "Event sender has already been initialized",
        ));

    std::thread::spawn(|| event_loop(receiver));

    std::thread::spawn(|| event_loop(threadsafe_functions, receiver));
    Ok(())