use crate::{example::LanguageServer, examples::ExampleToml};use collections::BTreeMap;use futures::future::LocalBoxFuture;use gpui::SharedString;use smol::future::FutureExt;use std::{fs, path::Path, sync::Arc}; #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]pub struct ExampleId(SharedString); impl<T: Into<SharedString>> From<T> for ExampleId {    fn from(value: T) -> Self {        Self(value.into())    }} #[derive(Clone, Debug)]pub struct ExampleMetadata {    pub id: ExampleId,    pub url: String,    pub revision: String,    pub language_server: Option<LanguageServer>,} #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]pub struct AssertionId(SharedString); impl<T: Into<SharedString>> From<T> for AssertionId {    fn from(value: T) -> Self {        Self(value.into())    }} #[derive(Default)]pub struct ExampleSetup {    assertions: BTreeMap<AssertionId, Vec<Assertion>>,} impl ExampleSetup {    fn assertion(&mut self, id: impl Into<SharedString>) -> AssertionId {        todo!()    }} struct Assertion {    condition: bool,    message: SharedString,} struct ExampleRun {    metadata: ExampleMetadata,    example: Option<Arc<dyn ErasedExample>>,    assertions: BTreeMap<AssertionId, Vec<Assertion>>,} impl ExampleRun {    pub fn assert(        &mut self,        assertion_id: &AssertionId,        condition: bool,        message: impl Into<SharedString>,    ) {        self.assertions            .get_mut(&assertion_id)            .expect("assertion not found")            .push(Assertion {                condition,                message: message.into(),            });    }     pub fn evaluate(&mut self) {        let example = self.example.take().unwrap();        example.evaluate(self);        self.example = Some(example);    }} trait Example: 'static {    fn metadata() -> ExampleMetadata    where        Self: Sized;    fn new(cx: &mut ExampleSetup) -> Self    where        Self: Sized;    async fn evaluate(&self, cx: &mut ExampleRun) -> anyhow::Result<()>;} trait ErasedExample {    fn evaluate<'a>(&'a self, cx: &'a mut ExampleRun) -> LocalBoxFuture<'a, anyhow::Result<()>>;} struct Erased<T>(T); impl<T: Example> ErasedExample for Erased<T> {    fn evaluate<'a>(&'a self, cx: &'a mut ExampleRun) -> LocalBoxFuture<'a, anyhow::Result<()>> {        self.0.evaluate(cx).boxed_local()    }} struct MyExample {    my_assertion: AssertionId,} impl Example for MyExample {    fn metadata() -> ExampleMetadata    where        Self: Sized,    {        ExampleMetadata {            id: "my_example".into(),            url: "".into(),            revision: "".into(),            language_server: None,        }    }     fn new(cx: &mut ExampleSetup) -> Self    where        Self: Sized,    {        Self {            my_assertion: cx.assertion("doesnt_do_stupid_thing"),        }    }     async fn evaluate(&self, cx: &mut ExampleRun) -> anyhow::Result<()> {        cx.assert(&self.my_assertion, true, "true was false");        Ok(())    }} struct TomlExample {    diff_assertions: BTreeMap<AssertionId, SharedString>,    thread_assertions: BTreeMap<AssertionId, SharedString>,} impl ErasedExample for TomlExample {    fn evaluate<'a>(&'a self, cx: &'a mut ExampleRun) -> LocalBoxFuture<'a, anyhow::Result<()>> {        // let sample = cx.sample().await?;         // for (assertion_id, condition) in self.diff_assertions.iter() {        //     let prompt = diff_prompt.render(diff, condition);        //     cx.judge(assertion_id, prompt).await?;        // }         // for (assertion_id, condition) in self.diff_assertions.iter() {        //     cx.judge(assertion_id, condition).await?;        // }         todo!()    }} #[derive(Default)]struct EvalSuite {    example_builders: BTreeMap<ExampleId, Box<dyn Fn() -> ExampleRun>>,} impl EvalSuite {    pub fn examples_to_run(&self, trials: usize) -> BTreeMap<ExampleId, Vec<ExampleRun>> {        let mut examples = BTreeMap::new();        for (example_id, builder) in &self.example_builders {            examples.insert(                example_id.clone(),                (0..trials).map(|_| (builder)()).collect(),            );        }        examples    }     pub fn register<T: Example>(&mut self) {        let metadata = T::metadata();        self.example_builders.insert(            metadata.id.clone(),            Box::new(move || {                let mut cx = ExampleSetup::default();                let example = T::new(&mut cx);                ExampleRun {                    metadata: metadata.clone(),                    example: Some(Arc::new(Erased(example))),                    assertions: cx.assertions,                }            }),        );    }     pub fn register_toml(&mut self, toml_abs_path: &Path) {        let name = toml_abs_path            .file_name()            .unwrap()            .to_string_lossy()            .to_string();        let id = ExampleId(name.into());        let base: ExampleToml =            toml::from_str(&fs::read_to_string(&toml_abs_path).unwrap()).unwrap();         let language_server = if base.require_lsp {            Some(crate::example::LanguageServer {                file_extension: base                    .language_extension                    .expect("Language extension is required when require_lsp = true"),                allow_preexisting_diagnostics: base.allow_preexisting_diagnostics,            })        } else {            None        };         let metadata = ExampleMetadata {            id: id.clone(),            url: base.url,            revision: base.revision,            language_server,        };         self.example_builders.insert(            id,            Box::new(move || {                let mut cx = ExampleSetup::default();                let mut diff_assertions = BTreeMap::new();                let mut thread_assertions = BTreeMap::new();                for (assertion_key, condition) in base.diff_assertions.iter() {                    let assertion_id = cx.assertion(assertion_key);                    diff_assertions.insert(assertion_id, condition.into());                }                for (assertion_key, condition) in base.thread_assertions.iter() {                    let assertion_id = cx.assertion(assertion_key);                    thread_assertions.insert(assertion_id.into(), condition.into());                }                ExampleRun {                    metadata: metadata.clone(),                    example: Some(Arc::new(TomlExample {                        diff_assertions,                        thread_assertions,                    })),                    assertions: cx.assertions,                }            }),        );    }} fn main() {    // let mut suite = EvalSuite::default();    // suite.register::<MyExample>();    // for path in list_files(..) {    //     suite.register_static()    // }     // for (example_id, runs) in suite.examples_to_run(2) {}}