use std::{ops::RangeInclusive, sync::Arc};

use anyhow::bail;
use client::{Client, ZED_SECRET_CLIENT_TOKEN, ZED_SERVER_URL};
use editor::Editor;
use futures::AsyncReadExt;
use gpui::{
    actions, serde_json, AppContext, Model, PromptLevel, Task, View, ViewContext, VisualContext,
};
use isahc::Request;
use language::Buffer;
use project::Project;
use regex::Regex;
use serde_derive::Serialize;
use util::ResultExt;
use workspace::Workspace;

use crate::system_specs::SystemSpecs;

const FEEDBACK_CHAR_LIMIT: RangeInclusive<usize> = 10..=5000;
const FEEDBACK_SUBMISSION_ERROR_TEXT: &str =
    "Feedback failed to submit, see error log for details.";

actions!(GiveFeedback, SubmitFeedback);

pub fn init(cx: &mut AppContext) {
    cx.observe_new_views(|workspace: &mut Workspace, cx| {
        workspace.register_action(
            move |workspace: &mut Workspace, _: &GiveFeedback, cx: &mut ViewContext<Workspace>| {
                FeedbackEditor::deploy(workspace, cx);
            },
        );
    })
    .detach();
}

#[derive(Serialize)]
struct FeedbackRequestBody<'a> {
    feedback_text: &'a str,
    email: Option<String>,
    metrics_id: Option<Arc<str>>,
    installation_id: Option<Arc<str>>,
    system_specs: SystemSpecs,
    is_staff: bool,
    token: &'a str,
}

#[derive(Clone)]
pub(crate) struct FeedbackEditor {
    system_specs: SystemSpecs,
    editor: View<Editor>,
    project: Model<Project>,
    pub allow_submission: bool,
}

impl FeedbackEditor {
    fn new(
        system_specs: SystemSpecs,
        project: Model<Project>,
        buffer: Model<Buffer>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let editor = cx.build_view(|cx| {
            let mut editor = Editor::for_buffer(buffer, Some(project.clone()), cx);
            editor.set_vertical_scroll_margin(5, cx);
            editor
        });

        cx.subscribe(&editor, |_, _, e, cx| cx.emit(e.clone()))
            .detach();

        Self {
            system_specs: system_specs.clone(),
            editor,
            project,
            allow_submission: true,
        }
    }

    pub fn submit(&mut self, cx: &mut ViewContext<Self>) -> Task<anyhow::Result<()>> {
        if !self.allow_submission {
            return Task::ready(Ok(()));
        }

        let feedback_text = self.editor.read(cx).text(cx);
        let feedback_char_count = feedback_text.chars().count();
        let feedback_text = feedback_text.trim().to_string();

        let error = if feedback_char_count < *FEEDBACK_CHAR_LIMIT.start() {
            Some(format!(
                "Feedback can't be shorter than {} characters.",
                FEEDBACK_CHAR_LIMIT.start()
            ))
        } else if feedback_char_count > *FEEDBACK_CHAR_LIMIT.end() {
            Some(format!(
                "Feedback can't be longer than {} characters.",
                FEEDBACK_CHAR_LIMIT.end()
            ))
        } else {
            None
        };

        if let Some(error) = error {
            cx.prompt(PromptLevel::Critical, &error, &["OK"]);
            return Task::ready(Ok(()));
        }

        let mut answer = cx.prompt(
            PromptLevel::Info,
            "Ready to submit your feedback?",
            &["Yes, Submit!", "No"],
        );

        let client = cx.global::<Arc<Client>>().clone();
        let specs = self.system_specs.clone();

        cx.spawn(|this, mut cx| async move {
            let answer = answer.recv().await;

            if answer == Some(0) {
                this.update(&mut cx, |feedback_editor, cx| {
                    feedback_editor.set_allow_submission(false, cx);
                })
                .log_err();

                match FeedbackEditor::submit_feedback(&feedback_text, client, specs).await {
                    Ok(_) => {
                        this.update(&mut cx, |_, cx| cx.emit(editor::EditorEvent::Closed))
                            .log_err();
                    }

                    Err(error) => {
                        log::error!("{}", error);
                        this.update(&mut cx, |feedback_editor, cx| {
                            cx.prompt(
                                PromptLevel::Critical,
                                FEEDBACK_SUBMISSION_ERROR_TEXT,
                                &["OK"],
                            );
                            feedback_editor.set_allow_submission(true, cx);
                        })
                        .log_err();
                    }
                }
            }
        })
        .detach();

        Task::ready(Ok(()))
    }

    fn set_allow_submission(&mut self, allow_submission: bool, cx: &mut ViewContext<Self>) {
        self.allow_submission = allow_submission;
        cx.notify();
    }

    async fn submit_feedback(
        feedback_text: &str,
        zed_client: Arc<Client>,
        system_specs: SystemSpecs,
    ) -> anyhow::Result<()> {
        let feedback_endpoint = format!("{}/api/feedback", *ZED_SERVER_URL);

        let telemetry = zed_client.telemetry();
        let metrics_id = telemetry.metrics_id();
        let installation_id = telemetry.installation_id();
        let is_staff = telemetry.is_staff();
        let http_client = zed_client.http_client();

        let re = Regex::new(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b").unwrap();

        let emails: Vec<&str> = re
            .captures_iter(feedback_text)
            .map(|capture| capture.get(0).unwrap().as_str())
            .collect();

        let email = emails.first().map(|e| e.to_string());

        let request = FeedbackRequestBody {
            feedback_text: &feedback_text,
            email,
            metrics_id,
            installation_id,
            system_specs,
            is_staff: is_staff.unwrap_or(false),
            token: ZED_SECRET_CLIENT_TOKEN,
        };

        let json_bytes = serde_json::to_vec(&request)?;

        let request = Request::post(feedback_endpoint)
            .header("content-type", "application/json")
            .body(json_bytes.into())?;

        let mut response = http_client.send(request).await?;
        let mut body = String::new();
        response.body_mut().read_to_string(&mut body).await?;

        let response_status = response.status();

        if !response_status.is_success() {
            bail!("Feedback API failed with error: {}", response_status)
        }

        Ok(())
    }
}

impl FeedbackEditor {
    pub fn deploy(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
        let markdown = workspace
            .app_state()
            .languages
            .language_for_name("Markdown");
        cx.spawn(|workspace, mut cx| async move {
            let markdown = markdown.await.log_err();
            workspace
                .update(&mut cx, |workspace, cx| {
                    workspace.with_local_workspace(cx, |workspace, cx| {
                        let project = workspace.project().clone();
                        let buffer = project
                            .update(cx, |project, cx| project.create_buffer("", markdown, cx))
                            .expect("creating buffers on a local workspace always succeeds");
                        let system_specs = SystemSpecs::new(cx);
                        let feedback_editor = cx.build_view(|cx| {
                            FeedbackEditor::new(system_specs, project, buffer, cx)
                        });
                        workspace.add_item(Box::new(feedback_editor), cx);
                    })
                })?
                .await
        })
        .detach_and_log_err(cx);
    }
}

// impl View for FeedbackEditor {
//     fn ui_name() -> &'static str {
//         "FeedbackEditor"
//     }

//     fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
//         ChildView::new(&self.editor, cx).into_any()
//     }

//     fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
//         if cx.is_self_focused() {
//             cx.focus(&self.editor);
//         }
//     }
// }

// impl Entity for FeedbackEditor {
//     type Event = editor::Event;
// }

// impl Item for FeedbackEditor {
//     fn tab_tooltip_text(&self, _: &AppContext) -> Option<Cow<str>> {
//         Some("Send Feedback".into())
//     }

//     fn tab_content<T: 'static>(
//         &self,
//         _: Option<usize>,
//         style: &theme::Tab,
//         _: &AppContext,
//     ) -> AnyElement<T> {
//         Flex::row()
//             .with_child(
//                 Svg::new("icons/feedback.svg")
//                     .with_color(style.label.text.color)
//                     .constrained()
//                     .with_width(style.type_icon_width)
//                     .aligned()
//                     .contained()
//                     .with_margin_right(style.spacing),
//             )
//             .with_child(
//                 Label::new("Send Feedback", style.label.clone())
//                     .aligned()
//                     .contained(),
//             )
//             .into_any()
//     }

//     fn for_each_project_item(&self, cx: &AppContext, f: &mut dyn FnMut(usize, &dyn project::Item)) {
//         self.editor.for_each_project_item(cx, f)
//     }

//     fn is_singleton(&self, _: &AppContext) -> bool {
//         true
//     }

//     fn can_save(&self, _: &AppContext) -> bool {
//         true
//     }

//     fn save(
//         &mut self,
//         _: ModelHandle<Project>,
//         cx: &mut ViewContext<Self>,
//     ) -> Task<anyhow::Result<()>> {
//         self.submit(cx)
//     }

//     fn save_as(
//         &mut self,
//         _: ModelHandle<Project>,
//         _: std::path::PathBuf,
//         cx: &mut ViewContext<Self>,
//     ) -> Task<anyhow::Result<()>> {
//         self.submit(cx)
//     }

//     fn reload(
//         &mut self,
//         _: ModelHandle<Project>,
//         _: &mut ViewContext<Self>,
//     ) -> Task<anyhow::Result<()>> {
//         Task::Ready(Some(Ok(())))
//     }

//     fn clone_on_split(
//         &self,
//         _workspace_id: workspace::WorkspaceId,
//         cx: &mut ViewContext<Self>,
//     ) -> Option<Self>
//     where
//         Self: Sized,
//     {
//         let buffer = self
//             .editor
//             .read(cx)
//             .buffer()
//             .read(cx)
//             .as_singleton()
//             .expect("Feedback buffer is only ever singleton");

//         Some(Self::new(
//             self.system_specs.clone(),
//             self.project.clone(),
//             buffer.clone(),
//             cx,
//         ))
//     }

//     fn as_searchable(&self, handle: &ViewHandle<Self>) -> Option<Box<dyn SearchableItemHandle>> {
//         Some(Box::new(handle.clone()))
//     }

//     fn act_as_type<'a>(
//         &'a self,
//         type_id: TypeId,
//         self_handle: &'a ViewHandle<Self>,
//         _: &'a AppContext,
//     ) -> Option<&'a AnyViewHandle> {
//         if type_id == TypeId::of::<Self>() {
//             Some(self_handle)
//         } else if type_id == TypeId::of::<Editor>() {
//             Some(&self.editor)
//         } else {
//             None
//         }
//     }

//     fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
//         Editor::to_item_events(event)
//     }
// }

// impl SearchableItem for FeedbackEditor {
//     type Match = Range<Anchor>;

//     fn to_search_event(
//         &mut self,
//         event: &Self::Event,
//         cx: &mut ViewContext<Self>,
//     ) -> Option<workspace::searchable::SearchEvent> {
//         self.editor
//             .update(cx, |editor, cx| editor.to_search_event(event, cx))
//     }

//     fn clear_matches(&mut self, cx: &mut ViewContext<Self>) {
//         self.editor
//             .update(cx, |editor, cx| editor.clear_matches(cx))
//     }

//     fn update_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
//         self.editor
//             .update(cx, |editor, cx| editor.update_matches(matches, cx))
//     }

//     fn query_suggestion(&mut self, cx: &mut ViewContext<Self>) -> String {
//         self.editor
//             .update(cx, |editor, cx| editor.query_suggestion(cx))
//     }

//     fn activate_match(
//         &mut self,
//         index: usize,
//         matches: Vec<Self::Match>,
//         cx: &mut ViewContext<Self>,
//     ) {
//         self.editor
//             .update(cx, |editor, cx| editor.activate_match(index, matches, cx))
//     }

//     fn select_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
//         self.editor
//             .update(cx, |e, cx| e.select_matches(matches, cx))
//     }
//     fn replace(&mut self, matches: &Self::Match, query: &SearchQuery, cx: &mut ViewContext<Self>) {
//         self.editor
//             .update(cx, |e, cx| e.replace(matches, query, cx));
//     }
//     fn find_matches(
//         &mut self,
//         query: Arc<project::search::SearchQuery>,
//         cx: &mut ViewContext<Self>,
//     ) -> Task<Vec<Self::Match>> {
//         self.editor
//             .update(cx, |editor, cx| editor.find_matches(query, cx))
//     }

//     fn active_match_index(
//         &mut self,
//         matches: Vec<Self::Match>,
//         cx: &mut ViewContext<Self>,
//     ) -> Option<usize> {
//         self.editor
//             .update(cx, |editor, cx| editor.active_match_index(matches, cx))
//     }
// }