working_copy, ChannelMutTxnT, ChannelTxnT, Hash, HashSet, MutTxnT,
    MutTxnTExt, TxnT, TxnTExt,

    working_copy, ChannelMutTxnT, ChannelTxnT, Encoding, Hash, HashSet,
    MutTxnT, MutTxnTExt, TxnT, TxnTExt,

pub const MAX_LEN_BASE64_DISPLAY: usize = 4096;

        contents: Vec<u8>,

        contents: Contents,

}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum Contents {
    Decoded(String),
    /// Short byte sequence of unknown encoding encoded with base64 for display.
    /// Must be shorter than [`MAX_LEN_BASE64_DISPLAY`]
    ShortBase64(String),
    UnknownEncoding(Vec<u8>),

                encoding: _,

                encoding,

                let contents =

                let raw_contents =

                let contents = try_decode_contents(raw_contents, encoding);

fn try_decode_contents(raw: Vec<u8>, encoding: &Option<Encoding>) -> Contents {
    match encoding {
        Some(encoding) => {
            let decoded = encoding.decode(&raw);
            Contents::Decoded(decoded.to_string())
        }
        None => {
            if raw.len() <= MAX_LEN_BASE64_DISPLAY {
                let encoded =
                    format!("b{}", data_encoding::BASE64.encode(&raw));
                Contents::ShortBase64(encoded)
            } else {
                Contents::UnknownEncoding(raw)
            }
        }
    }
}

pub mod cursor;

mod cursor;

use libflowers_client::{cursor, identity, repo};

use libflowers_client::repo::MAX_LEN_BASE64_DISPLAY;
use libflowers_client::{identity, repo};

use iced::widget::{
    self, button, column, horizontal_rule, row, scrollable, text, text_editor,
};

use iced::widget::{self, button, column, row, scrollable, text, text_editor};

use std::collections::BTreeMap;

const SPACING: u16 = 10;

            changed_files_contents: BTreeMap::default(),

    /// Keyed by file name matching `repo::ChangedFiles`
    changed_files_contents: ChangedFilesContents,

const MAX_LEN_BASE64_DISPLAY: usize = 4096;

type ChangedFilesContents = BTreeMap<String, ChangedFileContents>;

/// The order of the vec matches `repo::ChangedFile`
type ChangedFileContents = Vec<Option<FileEditorContent>>;

    ChangedFileContentsAction {
        file: String,
        ix: usize,
        action: text_editor::Action,
    },

                    state.changed_files_contents = BTreeMap::default();

                }
            }
            Task::none()
        }
        Message::ChangedFileContentsAction { file, ix, action } => {
            // Read-only
            if !action.is_edit() {
                if let Some(contents) =
                    state.changed_files_contents.get_mut(&file)
                {
                    if let Some(content) = contents.get_mut(ix) {
                        match content {
                            Some(FileEditorContent::Decoded(content)) => {
                                content.perform(action);
                            }
                            _ => panic!("Unexpected content: {content:?}"),
                        }
                    }

            state.changed_files_contents =
                changed_files_contents(&repo.changed_files);

            state.changed_files_contents =
                changed_files_contents(&changed_files);

        }
    }
}
fn changed_files_contents(
    changed_files: &repo::ChangedFiles,
) -> ChangedFilesContents {
    changed_files
        .iter()
        .map(|(file, diffs)| {
            let contents = diffs
                .iter()
                .map(|diff| match diff {
                    repo::ChangedFileDiff::Move => None,
                    repo::ChangedFileDiff::Del => None,
                    repo::ChangedFileDiff::Undel => None,
                    repo::ChangedFileDiff::Add => None,
                    repo::ChangedFileDiff::SolveNameConflict => None,
                    repo::ChangedFileDiff::UnsolveNameConflict => None,
                    repo::ChangedFileDiff::Edit {
                        line: _,
                        deleted: _,
                        contents,
                    } => Some(contents_to_file_editor_content(contents)),
                    repo::ChangedFileDiff::Replacement => None,
                    repo::ChangedFileDiff::SolveOrderConflict => None,
                    repo::ChangedFileDiff::UnsolveOrderConflict => None,
                    repo::ChangedFileDiff::ResurrectZombines => None,
                    repo::ChangedFileDiff::AddRoot => None,
                    repo::ChangedFileDiff::DelRoot => None,
                })
                .collect();
            (file.clone(), contents)
        })
        .collect()
}
fn contents_to_file_editor_content(
    contents: &repo::Contents,
) -> FileEditorContent {
    match contents {
        repo::Contents::Decoded(content) => {
            FileEditorContent::Decoded(text_editor::Content::with_text(content))

        repo::Contents::ShortBase64(short) => {
            FileEditorContent::ShortBase64(short.clone())
        }
        repo::Contents::UnknownEncoding(_vec) => {
            FileEditorContent::UnknownEncoding
        }

                let changed_file = repo.changed_files.iter().nth(*ix).unwrap();
                let diff = "todo";

                let (file_name, diffs) =
                    repo.changed_files.iter().nth(*ix).unwrap();
                let file_editor_contents =
                    state.changed_files_contents.get(file_name).unwrap();
                let diffs = diffs.iter().enumerate().map(|(ix, diff)| {
                    let file_editor_content =
                        file_editor_contents.get(ix).unwrap();
                    view_diff(diff, file_editor_content, file_name, ix)
                });

                    el(scrollable(text(diff))),

                    el(scrollable(column(diffs).spacing(SPACING))),

                el(horizontal_rule(1)),
                el(text("Untracked:")),
                untracked_files,
                el(horizontal_rule(1)),
                el(text("Changes:")),
                changed_files,
                el(horizontal_rule(1)),

                el(column([el(text("Untracked files:")), untracked_files])),
                el(column([el(text("Changed files:")), changed_files])),

            .width(Length::FillPortion(1))),

            .width(Length::FillPortion(1))
            .spacing(SPACING)),

        ]))

        ])
        .spacing(SPACING))

fn view_diff<'a>(
    diff: &'a repo::ChangedFileDiff,
    content: &'a Option<FileEditorContent>,
    file: &'a String,
    ix: usize,
) -> Element<'a, Message> {
    match content {
        Some(content) => match content {
            FileEditorContent::Decoded(content) => el(text_editor(content)
                .on_action(move |action| Message::ChangedFileContentsAction {
                    file: file.clone(),
                    ix,
                    action,
                })),
            FileEditorContent::ShortBase64(short) => el(text(short)),
            FileEditorContent::UnknownEncoding => el(text(format!("{diff:?}"))),
        },
        None => el(text(format!("{diff:?}"))),
    }
}