pub mod init;

use std::collections::BTreeMap;

use radicle::identity::RepoId;

use radicle::node::{Handle, Node};

use radicle::storage::ReadStorage;

use tauri::{AppHandle, Emitter, Manager};

use radicle_types::config::Config;

use radicle_types::error::Error;

use radicle_types::traits::Profile;

use radicle_types::AppState;

#[tauri::command]

pub(crate) fn load_profile(app: AppHandle) -> Result<Config, Error> {

    let profile = match radicle::Profile::load() {

        Ok(profile) => Ok::<radicle::Profile, Error>(profile),

        Err(radicle::profile::Error::NotFound(path)) => Err(Error::WithHint {

            err: anyhow::anyhow!("Radicle profile not found in '{}'.", path.display()),

            hint: "To setup your radicle profile, run `rad auth`.",

        }),

        Err(e) => Err(Error::WithHint {

            err: e.into(),

            hint: "Could not load radicle profile",

        }),

    }?;

    let state = AppState { profile };

    app.manage(state.clone());

    Ok(state.config())

}

#[tauri::command]

pub(crate) fn node_status_events(app: AppHandle, ctx: tauri::State<AppState>) -> Result<(), Error> {

    let app_handle = app.clone();

    let node = Node::new(ctx.profile.socket());

    let node_status = node.clone();

    tauri::async_runtime::spawn(async move {

        loop {

            let _ = app_handle.emit("node_running", node_status.is_running());

            tokio::time::sleep(std::time::Duration::from_secs(2)).await;

        }

    });

    Ok(())

}

#[tauri::command]

pub(crate) fn repo_sync_events(app: AppHandle, ctx: tauri::State<AppState>) -> Result<(), Error> {

    let profile = &ctx.profile;

    let repositories = profile.storage.repositories()?;

    let app_handle = app.clone();

    let public_key = profile.public_key;

    let node = Node::new(profile.socket());

    let mut node_seeds = node.clone();

    tauri::async_runtime::spawn(async move {

        loop {

            let mut sync_status =

                BTreeMap::<RepoId, Option<radicle_types::cobs::repo::SyncStatus>>::new();

            for repo in &repositories {

                if let Ok(seeds) = node_seeds.seeds(repo.rid).map(Into::<Vec<_>>::into) {

                    if let Some(status) =

                        seeds

                            .iter()

                            .find_map(|radicle::node::Seed { nid, sync, .. }| {

                                (*nid == public_key).then_some(sync.clone())

                            })

                    {

                        sync_status.insert(repo.rid, status.map(Into::into));

                    } else {

                        // The local node wasn't found in the seed nodes table.

                        sync_status.insert(repo.rid, None);

                    }

                }

            }

            let _ = app_handle.emit("sync_status", sync_status);

            tokio::time::sleep(std::time::Duration::from_secs(10)).await;

        }

    });

    Ok(())

}

#[tauri::command]

pub(crate) fn node_events(app: AppHandle, ctx: tauri::State<AppState>) -> Result<(), Error> {

    let app_handle = app.clone();

    let node = Node::new(ctx.profile.socket());

    tauri::async_runtime::spawn(async move {

        loop {

            if node.is_running() {

                log::debug!("node: spawned node event subscription.");

                while let Ok(events) = node.subscribe(std::time::Duration::MAX) {

                    for event in events.into_iter().flatten() {

                        let _ = app_handle.emit("event", event);

                    }

                }

                log::debug!("node: event subscription loop has exited.");

            }

            tokio::time::sleep(std::time::Duration::from_secs(2)).await;

        }

    });

    Ok(())

}

use radicle::node::NOTIFICATIONS_DB_FILE;

use tauri::{Listener, Manager};

use radicle_types::{domain, AppState};

use commands::{auth, cob, diff, inbox, init, profile, repo, thread};

            let main_window = app.get_webview_window("main").unwrap();

            let handle = app.handle().clone();

            main_window.listen("profile-loaded", move |_| {

                let ctx = handle.state::<AppState>();

                match radicle_types::outbound::sqlite::Sqlite::reader(

                    ctx.profile.node().join(NOTIFICATIONS_DB_FILE),

                ) {

                    Ok(inbox_db) => {

                        let inbox_service = domain::inbox::service::Service::new(inbox_db);

                        handle.manage(inbox_service);

                    Err(err) => log::error!("Not able to create inbox service: {}", err),

                };

                match radicle_types::outbound::sqlite::Sqlite::reader(

                    ctx.profile.cobs().join(COBS_DB_FILE),

                ) {

                    Ok(patch_db) => {

                        let patch_service = domain::patch::service::Service::new(patch_db);

                        handle.manage(patch_service);

                    Err(err) => log::error!("Not able to create patch service: {}", err),

            init::load_profile,

            init::node_status_events,

            init::repo_sync_events,

            init::node_events,

#[derive(Clone)]

  import type { Config } from "@bindings/config/Config";

  import { emit, listen } from "@tauri-apps/api/event";

    // Load profile into state before using it in other commands.

    await invoke<Config>("load_profile");

    if (window.__TAURI_INTERNALS__) {

      await emit("profile-loaded");

    }