1use crate::ChannelId;
  2use anyhow::Result;
  3use client::Client;
  4use gpui::{AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, Task};
  5use rpc::{proto, TypedEnvelope};
  6use std::sync::Arc;
  7use util::ResultExt;
  8
  9// Open the channel document
 10// ChannelDocumentView { ChannelDocument, Editor } -> On clone, clones internal ChannelDocument handle, instantiates new editor
 11// Produces a view which is: (ChannelDocument, Editor), ChannelDocument manages subscriptions
 12// ChannelDocuments -> Buffers -> Editor with that buffer
 13
 14// ChannelDocuments {
 15//     ChannleBuffers: HashMap<bufferId, ModelHandle<language::Buffer>>
 16// }
 17
 18type BufferId = u64;
 19
 20pub struct ChannelBuffer {
 21    channel_id: ChannelId,
 22    buffer_id: BufferId,
 23    buffer: ModelHandle<language::Buffer>,
 24    client: Arc<Client>,
 25}
 26
 27impl Entity for ChannelBuffer {
 28    type Event = ();
 29}
 30
 31impl ChannelBuffer {
 32    pub fn for_channel(
 33        channel_id: ChannelId,
 34        client: Arc<Client>,
 35        cx: &mut AppContext,
 36    ) -> Task<Result<ModelHandle<Self>>> {
 37        cx.spawn(|mut cx| async move {
 38            let response = client
 39                .request(proto::OpenChannelBuffer { channel_id })
 40                .await?;
 41
 42            let base_text = response.base_text;
 43            let operations = response
 44                .operations
 45                .into_iter()
 46                .map(language::proto::deserialize_operation)
 47                .collect::<Result<Vec<_>, _>>()?;
 48            let buffer_id = response.buffer_id;
 49
 50            let buffer = cx.add_model(|cx| language::Buffer::new(0, base_text, cx));
 51            buffer.update(&mut cx, |buffer, cx| buffer.apply_ops(operations, cx))?;
 52
 53            anyhow::Ok(cx.add_model(|cx| {
 54                cx.subscribe(&buffer, Self::on_buffer_update).detach();
 55                client.add_model_message_handler(Self::handle_update_channel_buffer);
 56                Self {
 57                    buffer_id,
 58                    buffer,
 59                    client,
 60                    channel_id,
 61                }
 62            }))
 63        })
 64    }
 65
 66    async fn handle_update_channel_buffer(
 67        this: ModelHandle<Self>,
 68        update_channel_buffer: TypedEnvelope<proto::UpdateChannelBuffer>,
 69        _: Arc<Client>,
 70        mut cx: AsyncAppContext,
 71    ) -> Result<()> {
 72        let ops = update_channel_buffer
 73            .payload
 74            .operations
 75            .into_iter()
 76            .map(language::proto::deserialize_operation)
 77            .collect::<Result<Vec<_>, _>>()?;
 78
 79        this.update(&mut cx, |this, cx| {
 80            this.buffer
 81                .update(cx, |buffer, cx| buffer.apply_ops(ops, cx))
 82        })?;
 83
 84        Ok(())
 85    }
 86
 87    fn on_buffer_update(
 88        &mut self,
 89        _: ModelHandle<language::Buffer>,
 90        event: &language::Event,
 91        _: &mut ModelContext<Self>,
 92    ) {
 93        if let language::Event::Operation(operation) = event {
 94            let operation = language::proto::serialize_operation(operation);
 95            self.client
 96                .send(proto::UpdateChannelBuffer {
 97                    buffer_id: self.buffer_id,
 98                    operations: vec![operation],
 99                })
100                .log_err();
101        }
102    }
103
104    pub fn buffer(&self) -> ModelHandle<language::Buffer> {
105        self.buffer.clone()
106    }
107}