1use anyhow::Result;
 2use gpui::{App, ClipboardItem, Context, Entity, Task, Window, div, prelude::*};
 3use language::Buffer;
 4use markdown_preview::{
 5    markdown_elements::ParsedMarkdown, markdown_parser::parse_markdown,
 6    markdown_renderer::render_markdown_block,
 7};
 8use ui::v_flex;
 9
10use crate::outputs::OutputContent;
11
12pub struct MarkdownView {
13    raw_text: String,
14    contents: Option<ParsedMarkdown>,
15    parsing_markdown_task: Option<Task<Result<()>>>,
16}
17
18impl MarkdownView {
19    pub fn from(text: String, cx: &mut Context<Self>) -> Self {
20        let parsed = {
21            let text = text.clone();
22            cx.background_spawn(async move { parse_markdown(&text.clone(), None, None).await })
23        };
24        let task = cx.spawn(async move |markdown_view, cx| {
25            let content = parsed.await;
26
27            markdown_view.update(cx, |markdown, cx| {
28                markdown.parsing_markdown_task.take();
29                markdown.contents = Some(content);
30                cx.notify();
31            })
32        });
33
34        Self {
35            raw_text: text.clone(),
36            contents: None,
37            parsing_markdown_task: Some(task),
38        }
39    }
40}
41
42impl OutputContent for MarkdownView {
43    fn clipboard_content(&self, _window: &Window, _cx: &App) -> Option<ClipboardItem> {
44        Some(ClipboardItem::new_string(self.raw_text.clone()))
45    }
46
47    fn has_clipboard_content(&self, _window: &Window, _cx: &App) -> bool {
48        true
49    }
50
51    fn has_buffer_content(&self, _window: &Window, _cx: &App) -> bool {
52        true
53    }
54
55    fn buffer_content(&mut self, _: &mut Window, cx: &mut App) -> Option<Entity<Buffer>> {
56        let buffer = cx.new(|cx| {
57            // TODO: Bring in the language registry so we can set the language to markdown
58            let mut buffer = Buffer::local(self.raw_text.clone(), cx)
59                .with_language(language::PLAIN_TEXT.clone(), cx);
60            buffer.set_capability(language::Capability::ReadOnly, cx);
61            buffer
62        });
63        Some(buffer)
64    }
65}
66
67impl Render for MarkdownView {
68    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
69        let Some(parsed) = self.contents.as_ref() else {
70            return div().into_any_element();
71        };
72
73        let mut markdown_render_context =
74            markdown_preview::markdown_renderer::RenderContext::new(None, window, cx);
75
76        v_flex()
77            .gap_3()
78            .py_4()
79            .children(parsed.children.iter().map(|child| {
80                div().relative().child(
81                    div()
82                        .relative()
83                        .child(render_markdown_block(child, &mut markdown_render_context)),
84                )
85            }))
86            .into_any_element()
87    }
88}