sandbox

// use jj_lib::{
//     backend::{Backend, BackendLoadError, TreeValue},
//     config::StackedConfig,
//     default_index::DefaultIndexStore,
//     default_submodule_store::DefaultSubmoduleStore,
//     git_backend::GitBackend,
//     ref_name::WorkspaceName,
//     repo::{Repo, RepoLoader, StoreFactories},
//     repo_path::{RepoPath, RepoPathBuf},
//     revset::{RevsetExpression, RevsetIteratorExt},
//     settings::UserSettings,
//     simple_op_heads_store::SimpleOpHeadsStore,
//     simple_op_store::SimpleOpStore,
// };
// use tokio::io::AsyncReadExt;

// use std::{path::Path, sync::Arc};

// fn main() {
//     let mut store_factories = StoreFactories::empty();
//     store_factories.add_backend(
//         "git",
//         Box::new(|a, b| {
//             GitBackend::load(a, b)
//                 .map(|git| Box::new(git) as Box<dyn Backend>)
//                 .map_err(|e| BackendLoadError(Box::new(*e)))
//         }),
//     );
//     store_factories.add_op_store(
//         "simple_op_store",
//         Box::new(|_, b, c| Ok(Box::new(SimpleOpStore::load(b, c)))),
//     );
//     store_factories.add_op_heads_store(
//         "simple_op_heads_store",
//         Box::new(|_, b| Ok(Box::new(SimpleOpHeadsStore::load(b)))),
//     );
//     store_factories.add_index_store(
//         "default",
//         Box::new(|_, b| Ok(Box::new(DefaultIndexStore::load(b)))),
//     );
//     store_factories.add_submodule_store(
//         "default",
//         Box::new(|_, b| Ok(Box::new(DefaultSubmoduleStore::load(b)))),
//     );
//     let repo_path = Path::new("/home/jj/sandbox/.jj/repo");
//     let config = StackedConfig::with_defaults();
//     let settings = UserSettings::from_config(config).unwrap();
//     let repo = RepoLoader::init_from_file_system(&settings, repo_path, &store_factories)
//         .unwrap()
//         .load_at_head()
//         .unwrap();

//     let expression = Arc::new(RevsetExpression::All);
//     let revset = expression.evaluate(repo.as_ref() as &dyn Repo).unwrap();

//     let last_commit = revset
//         .iter()
//         .commits(repo.store())
//         .next()
//         .unwrap()
//         .unwrap()
//         .tree();

//     let p: RepoPathBuf =
//         RepoPathBuf::parse_fs_path(Path::new("/home/jj/"), Path::new("/"), "sandbox/.jj/repo")
//             .unwrap();

//     println!("{p:?}");

//     for (path, value) in last_commit.entries() {
//         println!(
//             "parent of the file: {:?} - file name: {:?}",
//             path.parent(),
//             path
//         );

//         for value in value.unwrap() {
//             match value {
//                 Some(TreeValue::File { id, .. }) => {
//                     let mut content =
//                         pollster::block_on(repo.store().read_file(&path, &id)).unwrap();
//                     let mut c = String::new();
//                     pollster::block_on(content.read_to_string(&mut c)).unwrap();
//                     println!("ontent of the file: {c}")
//                 }
//                 _ => {}
//             }
//         }
//     }
// }

// async fn test() {
//     struct Test {}
//     impl Test {
//         async fn compute(&mut self, input: u32) -> u32 {
//             input + 1
//         }
//     }

//     let mut tests = [Test {}, Test {}, Test {}];

//     let mut futures: [_; 3] = [const { core::mem::MaybeUninit::uninit() }; 3];

//     for (i, t) in tests.iter_mut().enumerate() {
//         futures[i].write(t.compute(32 * (i as u32)));
//     }

//     let futures = futures
//         .iter()
//         .map(|fut| (false, false, unsafe { fut.assume_init_read() }));

//     core::future::poll_fn(|cx| {
//         for (done, mut out, fut) in futures {
//             let mut pin = core::pin::pin!(fut);
//             if let core::task::Poll::Ready(v) = pin.poll(cx) {
//                 out.write(v);
//             }
//         }

//         core::task::Poll::<()>::Pending
//     })
//     .await;

//     /*
//     for (done, fut) in futures {
//         let mut pin = core::pin::pin!(fut);
//         core::future::poll_fn(|cx| pin.as_mut().poll(cx)).await;
//     }

//        let mut pinneds = storage
//            .iter_mut()
//            .map(|fut| unsafe { core::pin::Pin::new_unchecked(fut.assume_init_mut()) });

//        for fut in &mut storage {
//            let fut = unsafe { fut.assume_init_mut() };
//            let a = unsafe { core::pin::Pin::new_unchecked(fut) };
//        }
//     */
// }