use pijul::{working_copy, Hash, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

use pijul::{
    working_copy, ChannelTxnT, Hash, MutTxnT, MutTxnTExt, TxnT, TxnTExt,
};

    pub state: pijul::Repository,

    pub repo: pijul::Repository,

        &self.state

        &self.repo

    let state = pijul::Repository::find_root(Some(path)).unwrap();
    let diff = diff(&state);
    let untracked_files = untracked_files(&state);

    let repo = pijul::Repository::find_root(Some(path)).unwrap();
    let diff = diff(&repo);
    let untracked_files = untracked_files(&repo);

        state,

        repo,

pub async fn record(state: &State, msg: String) {
    let repo = &state.repo;
    let channel = current_channel(&repo);
    let txn = repo.pristine.arc_txn_begin().unwrap();
    let mut channel = txn.read().load_channel(&channel).unwrap().unwrap();
    let mut extra = Vec::new();
    for h in repo.config.extra_dependencies.iter() {
        let (h, c) = txn.read().hash_from_prefix(h).unwrap();
        if txn
            .read()
            .get_changeset(txn.read().changes(&*channel.read()), &c)
            .unwrap()
            .is_none()
        {
            panic!(
                "Change {:?} (from .pijul/config) is not on channel {:?}",
                h,
                channel.read().name
            )
        }
        extra.push(h)
    }
    let header = todo!();
    let repo_path = CanonicalPathBuf::canonicalize(&repo.path).unwrap();
}

    MadeRecord,

fn update(state: &mut State, message: Message) {

fn update(state: &mut State, message: Message) -> Task<Message> {

            Task::none()

            }

            };
            Task::none()

            }

            };
            Task::none()

            state.cursor.selection = Some(selection)

            state.cursor.selection = Some(selection);
            Task::none()

                repo::add(&mut state.repo.state, path);

                repo::add(&mut state.repo.repo, path);

            Task::none()

                    repo::rm(&mut state.repo.state, path);

                    repo::rm(&mut state.repo.repo, path);

            Task::none()

            Task::none()

            Task::none()

                Task::none()

                let text = record_msg.text();
                if text.chars().all(|c| c.is_whitespace()) {

                let msg = record_msg.text();
                if msg.chars().all(|c| c.is_whitespace()) {

                    Task::none()

                    // TODO: use the text to make a record

                    // TODO: Make a record
                    // Task::future(async move {
                    //     repo::record(&state.repo, msg).await;
                    //     Message::MadeRecord
                    // })
                    todo!()

        Message::MadeRecord => todo!(),