//! Where a Device panel's devices are: on this machine, through the device
//! service, or on the device a remote thread runs on, through its remote
//! connection. Calls block; make them from a background thread.

use std::{
    collections::HashMap,
    sync::{
        Arc, Mutex,
        atomic::{AtomicU64, Ordering},
    },
    time::Duration,
};

use base64::Engine as _;
use gpui_kit::App;
use serde_json::Value;

use super::DeviceWatch;
use crate::device::{self, Action, AxElement, Detail, DeviceSession, HostStatus, State, stream::HubTarget};
use crate::remote::{ClientMessage, DeviceCall, client::ClientSender, device_proxy};

/// How long a call to another device may take; booting takes the longest.
const CALL_TIMEOUT: Duration = Duration::from_secs(240);

/// Another device's devices, reached through its remote connection.
pub struct RemoteDevices {
    pub env: String,
    /// The device's name, shown where this machine would say "This machine".
    pub name: String,
    sender: ClientSender,
    hub: HubTarget,
    pending: Mutex<HashMap<u64, smol::channel::Sender<Result<Value, String>>>>,
    next: AtomicU64,
}

impl RemoteDevices {
    /// `address` and `key` are the connection's, which the device's stream
    /// proxy answers on too.
    pub fn new(env: String, name: String, sender: ClientSender, address: &str, key: String) -> Self {
        let hub = HubTarget { address: crate::remote::with_port(address), prefix: device_proxy::PREFIX.into(), key: Some(key) };
        Self { env, name, sender, hub, pending: Mutex::default(), next: AtomicU64::new(1) }
    }

    /// Asks the device to send its device state now and on every change.
    pub fn watch(&self) {
        self.sender.send(&ClientMessage::Device { request: 0, call: DeviceCall::Watch });
    }

    /// Hands a reply to the call waiting for it.
    pub fn resolve(&self, request: u64, result: Result<Value, String>) {
        let waiting = self.pending.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).remove(&request);
        if let Some(waiting) = waiting {
            let _ = waiting.try_send(result);
        }
    }

    fn call(&self, call: DeviceCall) -> Result<Value, String> {
        let request = self.next.fetch_add(1, Ordering::Relaxed);
        let (tx, rx) = smol::channel::bounded(1);
        self.pending.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).insert(request, tx);
        self.sender.send(&ClientMessage::Device { request, call });
        let answer = smol::block_on(async {
            smol::future::or(async { rx.recv().await.ok() }, async {
                smol::Timer::after(CALL_TIMEOUT).await;
                None
            })
            .await
        });
        self.pending.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).remove(&request);
        answer.unwrap_or_else(|| {
            Err(format!("{} didn't answer. Its Vectrum Code may be too old for devices, or the connection dropped.", self.name))
        })
    }

    fn call_as<T: serde::de::DeserializeOwned>(&self, call: DeviceCall) -> Result<T, String> {
        serde_json::from_value(self.call(call)?).map_err(|err| format!("Unreadable answer from {}: {err}", self.name))
    }
}

/// A Device panel's devices.
#[derive(Clone)]
pub enum Backend {
    Local,
    Remote(Arc<RemoteDevices>),
}

fn text(err: anyhow::Error) -> String {
    format!("{err:#}")
}

impl Backend {
    /// The devices as last heard of. Another device's read as starting up
    /// until it has said.
    pub fn state(&self, cx: &App) -> State {
        let watch = cx.global::<DeviceWatch>();
        match self {
            Backend::Local => watch.state.clone(),
            Backend::Remote(remote) => watch.remote.get(&remote.env).cloned().unwrap_or_else(|| State {
                enabled: true,
                onboarding_completed: true,
                host_status: HostStatus::Starting,
                ..State::default()
            }),
        }
    }

    /// Where the device hub's streams are, if it runs.
    pub fn hub(&self) -> Option<HubTarget> {
        match self {
            Backend::Local => device::service().hub_origin().map(|origin| HubTarget::local(&origin)),
            Backend::Remote(remote) => Some(remote.hub.clone()),
        }
    }

    pub fn list(&self) {
        match self {
            Backend::Local => {
                device::service().list();
            }
            Backend::Remote(remote) => {
                let _ = remote.call(DeviceCall::List);
            }
        }
    }

    pub fn retry(&self) {
        match self {
            Backend::Local => {
                device::service().retry();
            }
            Backend::Remote(remote) => {
                let _ = remote.call(DeviceCall::Retry);
            }
        }
    }

    pub fn configure(&self, enabled: Option<bool>, agent_access: Option<bool>, onboarding: Option<bool>) -> Result<(), String> {
        match self {
            Backend::Local => device::service().configure(enabled, agent_access, onboarding).map(|_| ()).map_err(text),
            Backend::Remote(remote) => remote.call(DeviceCall::Configure { enabled, agent_access, onboarding }).map(|_| ()),
        }
    }

    pub fn open(&self, thread: &str, device: &str, boot: bool) -> Result<DeviceSession, String> {
        match self {
            Backend::Local => device::service().open(thread, device, boot).map_err(text),
            Backend::Remote(remote) => {
                remote.call_as(DeviceCall::Open { thread: thread.into(), device: device.into(), boot })
            }
        }
    }

    pub fn close(&self, thread: &str, device: Option<&str>, shutdown: bool) -> Result<(), String> {
        match self {
            Backend::Local => device::service().close(thread, device, shutdown).map_err(text),
            Backend::Remote(remote) => remote
                .call(DeviceCall::Close { thread: thread.into(), device: device.map(str::to_string), shutdown })
                .map(|_| ()),
        }
    }

    pub fn detail(&self, device: &str) -> Result<Detail, String> {
        match self {
            Backend::Local => device::service().detail(device).map_err(text),
            Backend::Remote(remote) => remote.call_as(DeviceCall::Detail { device: device.into() }),
        }
    }

    pub fn action(&self, device: &str, action: &Action) -> Result<Detail, String> {
        match self {
            Backend::Local => device::service().action(device, action).map_err(text),
            Backend::Remote(remote) => remote.call_as(DeviceCall::Action { device: device.into(), action: action.clone() }),
        }
    }

    pub fn screenshot(&self, device: &str) -> Result<Vec<u8>, String> {
        match self {
            Backend::Local => device::service().screenshot(device).map(|(_, png)| png).map_err(text),
            Backend::Remote(remote) => {
                let data: String = remote.call_as(DeviceCall::Screenshot { device: device.into() })?;
                base64::engine::general_purpose::STANDARD.decode(data).map_err(|err| err.to_string())
            }
        }
    }

    pub fn accessibility(&self, device: &str) -> Result<Vec<AxElement>, String> {
        match self {
            Backend::Local => device::service().accessibility(device).map_err(text),
            Backend::Remote(remote) => remote.call_as(DeviceCall::Accessibility { device: device.into() }),
        }
    }
}

/// Answers a client's device call on the host. Blocks.
pub fn answer(call: DeviceCall) -> Result<Value, String> {
    let service = device::service();
    let json = |value: Result<Value, serde_json::Error>| value.map_err(|err| err.to_string());
    match call {
        DeviceCall::Watch => json(serde_json::to_value(service.state())),
        DeviceCall::List => json(serde_json::to_value(service.list())),
        DeviceCall::Retry => json(serde_json::to_value(service.retry())),
        DeviceCall::Configure { enabled, agent_access, onboarding } => {
            json(serde_json::to_value(service.configure(enabled, agent_access, onboarding).map_err(text)?))
        }
        DeviceCall::Open { thread, device, boot } => json(serde_json::to_value(service.open(&thread, &device, boot).map_err(text)?)),
        DeviceCall::Close { thread, device, shutdown } => {
            service.close(&thread, device.as_deref(), shutdown).map_err(text)?;
            Ok(Value::Null)
        }
        DeviceCall::Detail { device } => json(serde_json::to_value(service.detail(&device).map_err(text)?)),
        DeviceCall::Action { device, action } => json(serde_json::to_value(service.action(&device, &action).map_err(text)?)),
        DeviceCall::Screenshot { device } => {
            let (_, png) = service.screenshot(&device).map_err(text)?;
            Ok(Value::String(base64::engine::general_purpose::STANDARD.encode(png)))
        }
        DeviceCall::Accessibility { device } => json(serde_json::to_value(service.accessibility(&device).map_err(text)?)),
    }
}