use ely_domain::{BrowserTab, TabId};
use gpui::{AnyElement, Bounds, Context, Pixels, Point};

use crate::services::servo_sidecar::{ServoSidecarError, SidecarSnapshot};

use super::{
    ElyShell,
    web_surface_frame::WebSurfaceFrame,
    web_surface_geometry::{WebSurfaceClickPoint, WebSurfaceScrollOffset, WebSurfaceSize},
    web_surface_state::{WebSurfaceRequest, WebSurfaceState},
    web_surface_view::{
        render_failed_web_surface, render_loading_web_surface, render_ready_web_surface,
    },
};

struct PendingWebSurfaceFrame {
    tab_id: TabId,
    requested_url: String,
    size: WebSurfaceSize,
    scroll_offset: WebSurfaceScrollOffset,
    click_point: Option<WebSurfaceClickPoint>,
    typed_text: Option<String>,
}

impl ElyShell {
    pub(super) fn render_external_web_canvas(
        &mut self,
        tab: &BrowserTab,
        cx: &mut Context<Self>,
    ) -> AnyElement {
        self.ensure_external_web_frame(tab, cx);

        let state_entity = cx.entity().clone();
        match self.web_surfaces.state(tab.id()) {
            Some(WebSurfaceState::Ready(frame)) => {
                render_ready_web_surface(frame, tab, state_entity)
            }
            Some(WebSurfaceState::Failed { message, .. }) => {
                render_failed_web_surface(tab, message.as_str(), state_entity)
            }
            Some(WebSurfaceState::Loading { previous_frame: Some(frame), .. }) => {
                render_ready_web_surface(frame, tab, state_entity)
            }
            Some(WebSurfaceState::Loading { previous_frame: None, .. }) | None => {
                render_loading_web_surface(tab, state_entity)
            }
        }
    }

    fn ensure_external_web_frame(&mut self, tab: &BrowserTab, cx: &mut Context<Self>) {
        let Some(request) = self.web_surfaces.prepare_request(tab) else {
            return;
        };

        let WebSurfaceRequest {
            tab_id,
            requested_url,
            size,
            scroll_offset,
            click_point,
            typed_text,
            client,
            snapshot_request,
        } = request;
        let pending_frame = PendingWebSurfaceFrame {
            tab_id,
            requested_url,
            size,
            scroll_offset,
            click_point,
            typed_text,
        };
        cx.spawn(async move |shell, cx| {
            let result = cx
                .background_executor()
                .spawn(async move { client.snapshot(snapshot_request) })
                .await;

            _ = shell.update(cx, |shell, cx| {
                shell.handle_external_web_frame_result(pending_frame, result);
                cx.notify();
            });
        })
        .detach();
    }

    fn handle_external_web_frame_result(
        &mut self,
        pending_frame: PendingWebSurfaceFrame,
        result: Result<SidecarSnapshot, ServoSidecarError>,
    ) {
        let PendingWebSurfaceFrame {
            tab_id,
            requested_url,
            size,
            scroll_offset,
            click_point,
            typed_text,
        } = pending_frame;
        if !self.web_surfaces.is_loading(
            &tab_id,
            requested_url.as_str(),
            size,
            scroll_offset,
            click_point,
            typed_text.as_deref(),
        ) {
            return;
        }

        let state = match result {
            Ok(snapshot) => match WebSurfaceFrame::from_snapshot(
                requested_url.clone(),
                scroll_offset,
                click_point,
                typed_text.clone(),
                snapshot,
            ) {
                Ok(frame) => WebSurfaceState::Ready(frame),
                Err(error) => WebSurfaceState::Failed {
                    requested_url,
                    size,
                    scroll_offset,
                    click_point,
                    typed_text,
                    message: error.to_string(),
                },
            },
            Err(error) => WebSurfaceState::Failed {
                requested_url,
                size,
                scroll_offset,
                click_point,
                typed_text,
                message: error.to_string(),
            },
        };
        self.web_surfaces.finish(tab_id, state);
    }

    pub(super) fn record_external_web_viewport(
        &mut self,
        tab_id: TabId,
        bounds: Bounds<Pixels>,
        cx: &mut Context<Self>,
    ) {
        if self.web_surfaces.record_viewport_size(&tab_id, bounds) {
            cx.notify();
        }
    }

    pub(super) fn scroll_external_web_viewport(
        &mut self,
        tab_id: TabId,
        requested_url: String,
        delta: gpui::Point<Pixels>,
        cx: &mut Context<Self>,
    ) {
        if self.web_surfaces.record_scroll_delta(&tab_id, requested_url.as_str(), delta) {
            cx.notify();
        }
    }

    pub(super) fn click_external_web_viewport(
        &mut self,
        tab_id: TabId,
        requested_url: String,
        position: Point<Pixels>,
        window: &mut gpui::Window,
        cx: &mut Context<Self>,
    ) {
        self.focus_handle.focus(window);
        if self.web_surfaces.record_click_point(&tab_id, requested_url.as_str(), position) {
            cx.notify();
        }
    }

    pub(super) fn type_text_in_external_web_viewport(
        &mut self,
        tab_id: TabId,
        requested_url: String,
        text: &str,
        cx: &mut Context<Self>,
    ) -> bool {
        if self.web_surfaces.record_typed_text(&tab_id, requested_url.as_str(), text) {
            cx.notify();
            return true;
        }

        false
    }
}