1use crate::ChannelId;
 2use anyhow::Result;
 3use client::Client;
 4use gpui::{Entity, ModelContext, ModelHandle, Task};
 5use rpc::proto::GetChannelBuffer;
 6use std::sync::Arc;
 7
 8// Open the channel document
 9// ChannelDocumentView { ChannelDocument, Editor } -> On clone, clones internal ChannelDocument handle, instantiates new editor
10// Produces a view which is: (ChannelDocument, Editor), ChannelDocument manages subscriptions
11// ChannelDocuments -> Buffers -> Editor with that buffer
12
13// ChannelDocuments {
14//     ChannleBuffers: HashMap<bufferId, ModelHandle<language::Buffer>>
15// }
16
17pub struct ChannelBuffer {
18    channel_id: ChannelId,
19    buffer: Option<ModelHandle<language::Buffer>>,
20    client: Arc<Client>,
21}
22
23impl Entity for ChannelBuffer {
24    type Event = ();
25}
26
27impl ChannelBuffer {
28    pub fn for_channel(
29        channel_id: ChannelId,
30        client: Arc<Client>,
31        cx: &mut ModelContext<Self>,
32    ) -> Self {
33        Self {
34            channel_id,
35            client,
36            buffer: None,
37        }
38    }
39
40    fn on_buffer_update(
41        &mut self,
42        buffer: ModelHandle<language::Buffer>,
43        event: &language::Event,
44        cx: &mut ModelContext<Self>,
45    ) {
46        //
47    }
48
49    pub fn buffer(
50        &mut self,
51        cx: &mut ModelContext<Self>,
52    ) -> Task<Result<ModelHandle<language::Buffer>>> {
53        if let Some(buffer) = &self.buffer {
54            Task::ready(Ok(buffer.clone()))
55        } else {
56            let channel_id = self.channel_id;
57            let client = self.client.clone();
58            cx.spawn(|this, mut cx| async move {
59                let response = client.request(GetChannelBuffer { channel_id }).await?;
60
61                let base_text = response.base_text;
62                let operations = response
63                    .operations
64                    .into_iter()
65                    .map(language::proto::deserialize_operation)
66                    .collect::<Result<Vec<_>, _>>()?;
67
68                this.update(&mut cx, |this, cx| {
69                    let buffer = cx.add_model(|cx| language::Buffer::new(0, base_text, cx));
70                    buffer.update(cx, |buffer, cx| buffer.apply_ops(operations, cx))?;
71
72                    cx.subscribe(&buffer, Self::on_buffer_update).detach();
73
74                    this.buffer = Some(buffer.clone());
75                    anyhow::Ok(buffer)
76                })
77            })
78        }
79    }
80}