use anyhow::{anyhow, Result};
use assistant_tooling::{LanguageModelTool, ProjectContext, ToolView};
use editor::Editor;
use gpui::{prelude::*, Model, Task, View, WeakView};
use project::Project;
use schemars::JsonSchema;
use serde::Deserialize;
use ui::prelude::*;
use util::ResultExt;
use workspace::Workspace;

pub struct CreateBufferTool {
    workspace: WeakView<Workspace>,
    project: Model<Project>,
}

impl CreateBufferTool {
    pub fn new(workspace: WeakView<Workspace>, project: Model<Project>) -> Self {
        Self { workspace, project }
    }
}

#[derive(Debug, Clone, Deserialize, JsonSchema)]
pub struct CreateBufferInput {
    /// The contents of the buffer.
    text: String,

    /// The name of the language to use for the buffer.
    ///
    /// This should be a human-readable name, like "Rust", "JavaScript", or "Python".
    language: String,
}

impl LanguageModelTool for CreateBufferTool {
    type View = CreateBufferView;

    fn name(&self) -> String {
        "create_file".to_string()
    }

    fn description(&self) -> String {
        "Create a new untitled file in the current codebase. Side effect: opens it in a new pane/tab for the user to edit.".to_string()
    }

    fn view(&self, cx: &mut WindowContext) -> View<Self::View> {
        cx.new_view(|_cx| CreateBufferView {
            workspace: self.workspace.clone(),
            project: self.project.clone(),
            input: None,
            error: None,
        })
    }
}

pub struct CreateBufferView {
    workspace: WeakView<Workspace>,
    project: Model<Project>,
    input: Option<CreateBufferInput>,
    error: Option<anyhow::Error>,
}

impl Render for CreateBufferView {
    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
        ui::Label::new("Opening a buffer")
    }
}

impl ToolView for CreateBufferView {
    type Input = CreateBufferInput;

    type SerializedState = ();

    fn generate(&self, _project: &mut ProjectContext, _cx: &mut ViewContext<Self>) -> String {
        let Some(input) = self.input.as_ref() else {
            return "No input".to_string();
        };

        match &self.error {
            None => format!("Created a new {} buffer", input.language),
            Some(err) => format!("Failed to create buffer: {err:?}"),
        }
    }

    fn set_input(&mut self, input: Self::Input, cx: &mut ViewContext<Self>) {
        self.input = Some(input);
        cx.notify();
    }

    fn execute(&mut self, cx: &mut ViewContext<Self>) -> Task<Result<()>> {
        cx.spawn({
            let workspace = self.workspace.clone();
            let project = self.project.clone();
            let input = self.input.clone();
            |_this, mut cx| async move {
                let input = input.ok_or_else(|| anyhow!("no input"))?;

                let text = input.text.clone();
                let language_name = input.language.clone();
                let language = cx
                    .update(|cx| {
                        project
                            .read(cx)
                            .languages()
                            .language_for_name(&language_name)
                    })?
                    .await?;

                let buffer = cx
                    .update(|cx| project.update(cx, |project, cx| project.create_buffer(cx)))?
                    .await?;

                buffer.update(&mut cx, |buffer, cx| {
                    buffer.edit([(0..0, text)], None, cx);
                    buffer.set_language(Some(language), cx)
                })?;

                workspace
                    .update(&mut cx, |workspace, cx| {
                        workspace.add_item_to_active_pane(
                            Box::new(
                                cx.new_view(|cx| Editor::for_buffer(buffer, Some(project), cx)),
                            ),
                            None,
                            cx,
                        );
                    })
                    .log_err();

                Ok(())
            }
        })
    }

    fn serialize(&self, _cx: &mut ViewContext<Self>) -> Self::SerializedState {
        ()
    }

    fn deserialize(
        &mut self,
        _output: Self::SerializedState,
        _cx: &mut ViewContext<Self>,
    ) -> Result<()> {
        Ok(())
    }
}