use anyhow::{anyhow, Result};
use gpui::{AppContext, Model, Task, WeakModel};
use project::{Fs, Project, ProjectPath, Worktree};
use std::{cmp::Ordering, fmt::Write as _, ops::Range, sync::Arc};
use sum_tree::TreeMap;

pub struct ProjectContext {
    files: TreeMap<ProjectPath, PathState>,
    project: WeakModel<Project>,
    fs: Arc<dyn Fs>,
}

#[derive(Debug, Clone)]
enum PathState {
    PathOnly,
    EntireFile,
    Excerpts { ranges: Vec<Range<usize>> },
}

impl ProjectContext {
    pub fn new(project: WeakModel<Project>, fs: Arc<dyn Fs>) -> Self {
        Self {
            files: TreeMap::default(),
            fs,
            project,
        }
    }

    pub fn add_path(&mut self, project_path: ProjectPath) {
        if self.files.get(&project_path).is_none() {
            self.files.insert(project_path, PathState::PathOnly);
        }
    }

    pub fn add_excerpts(&mut self, project_path: ProjectPath, new_ranges: &[Range<usize>]) {
        let previous_state = self
            .files
            .get(&project_path)
            .unwrap_or(&PathState::PathOnly);

        let mut ranges = match previous_state {
            PathState::EntireFile => return,
            PathState::PathOnly => Vec::new(),
            PathState::Excerpts { ranges } => ranges.to_vec(),
        };

        for new_range in new_ranges {
            let ix = ranges.binary_search_by(|probe| {
                if probe.end < new_range.start {
                    Ordering::Less
                } else if probe.start > new_range.end {
                    Ordering::Greater
                } else {
                    Ordering::Equal
                }
            });

            match ix {
                Ok(mut ix) => {
                    let existing = &mut ranges[ix];
                    existing.start = existing.start.min(new_range.start);
                    existing.end = existing.end.max(new_range.end);
                    while ix + 1 < ranges.len() && ranges[ix + 1].start <= ranges[ix].end {
                        ranges[ix].end = ranges[ix].end.max(ranges[ix + 1].end);
                        ranges.remove(ix + 1);
                    }
                    while ix > 0 && ranges[ix - 1].end >= ranges[ix].start {
                        ranges[ix].start = ranges[ix].start.min(ranges[ix - 1].start);
                        ranges.remove(ix - 1);
                        ix -= 1;
                    }
                }
                Err(ix) => {
                    ranges.insert(ix, new_range.clone());
                }
            }
        }

        self.files
            .insert(project_path, PathState::Excerpts { ranges });
    }

    pub fn add_file(&mut self, project_path: ProjectPath) {
        self.files.insert(project_path, PathState::EntireFile);
    }

    pub fn generate_system_message(&self, cx: &mut AppContext) -> Task<Result<String>> {
        let project = self
            .project
            .upgrade()
            .ok_or_else(|| anyhow!("project dropped"));
        let files = self.files.clone();
        let fs = self.fs.clone();
        cx.spawn(|cx| async move {
            let project = project?;
            let mut result = "project structure:\n".to_string();

            let mut last_worktree: Option<Model<Worktree>> = None;
            for (project_path, path_state) in files.iter() {
                if let Some(worktree) = &last_worktree {
                    if worktree.read_with(&cx, |tree, _| tree.id())? != project_path.worktree_id {
                        last_worktree = None;
                    }
                }

                let worktree;
                if let Some(last_worktree) = &last_worktree {
                    worktree = last_worktree.clone();
                } else if let Some(tree) = project.read_with(&cx, |project, cx| {
                    project.worktree_for_id(project_path.worktree_id, cx)
                })? {
                    worktree = tree;
                    last_worktree = Some(worktree.clone());
                    let worktree_name =
                        worktree.read_with(&cx, |tree, _cx| tree.root_name().to_string())?;
                    writeln!(&mut result, "# {}", worktree_name).unwrap();
                } else {
                    continue;
                }

                let worktree_abs_path = worktree.read_with(&cx, |tree, _cx| tree.abs_path())?;
                let path = &project_path.path;
                writeln!(&mut result, "## {}", path.display()).unwrap();

                match path_state {
                    PathState::PathOnly => {}
                    PathState::EntireFile => {
                        let text = fs.load(&worktree_abs_path.join(&path)).await?;
                        writeln!(&mut result, "~~~\n{text}\n~~~").unwrap();
                    }
                    PathState::Excerpts { ranges } => {
                        let text = fs.load(&worktree_abs_path.join(&path)).await?;

                        writeln!(&mut result, "~~~").unwrap();

                        // Assumption: ranges are in order, not overlapping
                        let mut prev_range_end = 0;
                        for range in ranges {
                            if range.start > prev_range_end {
                                writeln!(&mut result, "...").unwrap();
                                prev_range_end = range.end;
                            }

                            let mut start = range.start;
                            let mut end = range.end.min(text.len());
                            while !text.is_char_boundary(start) {
                                start += 1;
                            }
                            while !text.is_char_boundary(end) {
                                end -= 1;
                            }
                            result.push_str(&text[start..end]);
                            if !result.ends_with('\n') {
                                result.push('\n');
                            }
                        }

                        if prev_range_end < text.len() {
                            writeln!(&mut result, "...").unwrap();
                        }

                        writeln!(&mut result, "~~~").unwrap();
                    }
                }
            }
            Ok(result)
        })
    }
}

#[cfg(test)]
mod tests {
    use std::path::Path;

    use super::*;
    use gpui::TestAppContext;
    use project::FakeFs;
    use serde_json::json;
    use settings::SettingsStore;

    use unindent::Unindent as _;

    #[gpui::test]
    async fn test_system_message_generation(cx: &mut TestAppContext) {
        init_test(cx);

        let file_3_contents = r#"
            fn test1() {}
            fn test2() {}
            fn test3() {}
        "#
        .unindent();

        let fs = FakeFs::new(cx.executor());
        fs.insert_tree(
            "/code",
            json!({
                "root1": {
                    "lib": {
                        "file1.rs": "mod example;",
                        "file2.rs": "",
                    },
                    "test": {
                        "file3.rs": file_3_contents,
                    }
                },
                "root2": {
                    "src": {
                        "main.rs": ""
                    }
                }
            }),
        )
        .await;

        let project = Project::test(
            fs.clone(),
            ["/code/root1".as_ref(), "/code/root2".as_ref()],
            cx,
        )
        .await;

        let worktree_ids = project.read_with(cx, |project, cx| {
            project
                .worktrees()
                .map(|worktree| worktree.read(cx).id())
                .collect::<Vec<_>>()
        });

        let mut ax = ProjectContext::new(project.downgrade(), fs);

        ax.add_file(ProjectPath {
            worktree_id: worktree_ids[0],
            path: Path::new("lib/file1.rs").into(),
        });

        let message = cx
            .update(|cx| ax.generate_system_message(cx))
            .await
            .unwrap();
        assert_eq!(
            r#"
            project structure:
            # root1
            ## lib/file1.rs
            ~~~
            mod example;
            ~~~
            "#
            .unindent(),
            message
        );

        ax.add_excerpts(
            ProjectPath {
                worktree_id: worktree_ids[0],
                path: Path::new("test/file3.rs").into(),
            },
            &[
                file_3_contents.find("fn test2").unwrap()
                    ..file_3_contents.find("fn test3").unwrap(),
            ],
        );

        let message = cx
            .update(|cx| ax.generate_system_message(cx))
            .await
            .unwrap();
        assert_eq!(
            r#"
            project structure:
            # root1
            ## lib/file1.rs
            ~~~
            mod example;
            ~~~
            ## test/file3.rs
            ~~~
            ...
            fn test2() {}
            ...
            ~~~
            "#
            .unindent(),
            message
        );
    }

    fn init_test(cx: &mut TestAppContext) {
        cx.update(|cx| {
            let settings_store = SettingsStore::test(cx);
            cx.set_global(settings_store);
            Project::init_settings(cx);
        });
    }
}