use libpijul::changestore;

use libpijul::{TxnTExt, changestore};

use crate::file_system::changes::unrecorded::UnrecordedChangesError;

use crate::file_system::changes::{FileCredits, FileCreditsError};
use crate::file_system::open_file::contents::FileContents;

use crate::file_system::working_copy::EditorWorkingCopy;

use crate::file_system::working_copy::{
    EditorWorkingCopy, UpdateOpenFileContentsError, UpdateOpenFileCreditsError,
};

    OpenFile(#[from] OpenFileError<C>),

    OpenFile(#[from] OpenFileError<C, W>),

    #[error(transparent)]
    FileCredits(#[from] FileCreditsError<C, W>),

pub enum UpdateOpenFileError<C: std::error::Error + 'static> {

pub enum UpdateOpenFileError<C: std::error::Error + 'static, W: std::error::Error + 'static> {
    #[error("Unable to begin transaction: {0}")]
    BeginTransaction(#[from] BeginTransactionError),

    UnrecordedChanges(#[from] UnrecordedChangesError<C>),
    #[error("No file open at {0}")]
    NoMatchingFile(Utf8PathBuf),
    #[error("Unable to begin transaction: {0:#?}")]
    BeginTransaction(#[from] BeginTransactionError),

    UpdateContents(#[from] UpdateOpenFileContentsError),
    #[error(transparent)]
    UpdateCredits(#[from] UpdateOpenFileCreditsError<C, W>),

        let open_file = OpenFile::open(
            path.clone(),
            file_contents,
            metadata,
            &transaction,
            &channel,
            &self.change_store,
            &self.working_copy,
        )?;

        let open_file = OpenFile {
            contents: FileContents::new(path.clone(), metadata, file_contents, &self.working_copy),
            credits: None,
        };

            .map_err(|_error| CreateOpenFileError::AlreadyOpen(path))?;

            .map_err(|_error| CreateOpenFileError::AlreadyOpen(path.clone()))?;
        let is_tracked = transaction
            .read()
            .is_tracked(path.as_str())
            .map_err(|error| OpenFileError::CheckIfTracked {
                path: path.clone(),
                error,
            })?;

        // Generate the credits if applicable
        // Since `FileCredits::new()` reads the file state from the working copy,
        // it must be done _after_ inserting the `FileContents` first.
        let file_credits = match is_tracked {
            true => Some(FileCredits::new(
                &path,
                &self.working_copy.open_files.get(&path).unwrap().contents,
                &transaction,
                &channel,
                &self.change_store,
                &self.working_copy,
            )?),
            false => None,
        };
        self.working_copy.open_files.get_mut(&path).unwrap().credits = file_credits;

    ) -> Result<(), UpdateOpenFileError<C::Error>> {
        let open_file = self
            .working_copy
            .open_files
            .get_mut(path)
            .ok_or_else(|| UpdateOpenFileError::NoMatchingFile(path.to_path_buf()))?;

    ) -> Result<(), UpdateOpenFileError<C::Error, W::Error>> {

        open_file.update(

        // Since the credits depend on file state already stored in the working copy,
        // update its contents _before_ updating the credits.
        self.working_copy.update_open_file_contents(
            path,

        )?;
        self.working_copy.update_open_file_credits(
            path,

use libpijul::ArcTxn;
use libpijul::ChannelRef;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::sanakirja::MutTxn;

use crate::file_system::changes::unrecorded::UnrecordedChangesError;
use crate::file_system::changes::unrecorded::UnrecordedState;

#[derive(Debug, thiserror::Error)]
pub enum UpdateOpenFileContentsError {
    #[error("No file open at {0}")]
    NoMatchingFile(Utf8PathBuf),
}

#[derive(Debug, thiserror::Error)]
pub enum UpdateOpenFileCreditsError<C: std::error::Error + 'static, W: std::error::Error + 'static>
{
    #[error("No file open at {0}")]
    NoMatchingFile(Utf8PathBuf),
    #[error(transparent)]
    UnrecordedChanges(#[from] UnrecordedChangesError<C, W>),
}

    pub fn update_open_file_contents(
        &mut self,
        path: &Utf8Path,
        character_offset: usize,
        characters_replaced: usize,
        replacement_text: &str,
    ) -> Result<(), UpdateOpenFileContentsError> {
        let open_file = self
            .open_files
            .get_mut(path)
            .ok_or_else(|| UpdateOpenFileContentsError::NoMatchingFile(path.to_path_buf()))?;
        if characters_replaced > 0 {
            open_file
                .contents
                .text
                .remove(character_offset..(character_offset + characters_replaced));
        }
        if !replacement_text.is_empty() {
            open_file
                .contents
                .text
                .insert(character_offset, replacement_text);
        }
        Ok(())
    }
    pub fn update_open_file_credits<C>(
        &mut self,
        path: &Utf8Path,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<(), UpdateOpenFileCreditsError<C::Error, W::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        if !self.open_files.contains_key(path) {
            return Err(UpdateOpenFileCreditsError::NoMatchingFile(
                path.to_path_buf(),
            ));
        }
        let unrecorded_state = match self.open_files.get(path).unwrap().credits.is_some() {
            true => Some(UnrecordedState::new(
                path,
                transaction,
                channel,
                change_store,
                self,
            )?),
            false => None,
        };
        if let Some(file_credits) = &mut self.open_files.get_mut(path).unwrap().credits {
            file_credits.unrecorded_state = unrecorded_state.unwrap();
        }
        let open_file = self.open_files.get_mut(path).unwrap();
        if let Some(file_credits) = &mut open_file.credits {
            file_credits.spans = file_credits.recompute_spans(&open_file.contents);
        }
        Ok(())
    }

use libpijul::ArcTxn;
use libpijul::ChannelRef;
use libpijul::TxnTExt;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::InodeMetadata;
use libpijul::pristine::sanakirja::MutTxn;

use libpijul::working_copy::WorkingCopyRead;

use crate::file_system::changes::CreditSource;
use crate::file_system::changes::FileCredits;
use crate::file_system::changes::FileCreditsError;
use crate::file_system::changes::Span;

use crate::file_system::changes::{CreditSource, FileCredits, FileCreditsError, Span};

pub enum OpenFileError<C: std::error::Error + 'static> {

pub enum OpenFileError<C: std::error::Error + 'static, W: std::error::Error + 'static> {

    FileChanges(#[from] UnrecordedChangesError<C>),

    FileChanges(#[from] UnrecordedChangesError<C, W>),

    TrackedFile(#[from] FileCreditsError<C>),

    TrackedFile(#[from] FileCreditsError<C, W>),

    // TODO: use more structured representation for tracked vs untracked files

    pub fn open<C, W>(
        path: Utf8PathBuf,
        file_contents: String,
        metadata: InodeMetadata,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
        working_copy: &W,
    ) -> Result<Self, OpenFileError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
        W: WorkingCopyRead,
    {
        let contents = FileContents::new(path.clone(), metadata, file_contents, working_copy);
        let credits = if transaction
            .read()
            .is_tracked(path.as_str())
            .map_err(|error| OpenFileError::CheckIfTracked { path, error })?
        {
            Some(FileCredits::new(
                &contents,
                transaction,
                channel,
                change_store,
            )?)
        } else {
            None
        };
        Ok(Self { contents, credits })
    }
    pub fn update<C>(
        &mut self,
        character_offset: usize,
        characters_replaced: usize,
        replacement_text: &str,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<(), UnrecordedChangesError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        if characters_replaced > 0 {
            self.contents
                .text
                .remove(character_offset..(character_offset + characters_replaced));
        }
        if !replacement_text.is_empty() {
            self.contents
                .text
                .insert(character_offset, replacement_text);
        }
        if let Some(credits) = &mut self.credits {
            // TODO: only re-compute spans that were affected
            credits.recompute_spans(&self.contents, transaction, channel, change_store)?;
        }
        Ok(())
    }

#[derive(Debug, thiserror::Error)]
pub enum FileContentsError {
    #[error("Invalid path: expected {expected_path:?}, got {incorrect_path:?}")]
    InvalidPath {
        expected_path: Utf8PathBuf,
        incorrect_path: Utf8PathBuf,
    },
}

    // TODO: path shouldn't be stored here
    pub path: Utf8PathBuf,

            path,

// TODO: implement `WorkingCopyRead` for `EditorWorkingCopy` instead?
impl WorkingCopyRead for FileContents {
    type Error = FileContentsError;
    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, Self::Error> {
        if file != self.path.as_str() {
            return Err(FileContentsError::InvalidPath {
                expected_path: self.path.clone(),
                incorrect_path: Utf8PathBuf::from(file),
            });
        }
        Ok(self.metadata)
    }
    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), Self::Error> {
        if file != self.path.as_str() {
            return Err(FileContentsError::InvalidPath {
                expected_path: self.path.clone(),
                incorrect_path: Utf8PathBuf::from(file),
            });
        }
        buffer.extend(self.text.bytes());
        Ok(())
    }
    fn modified_time(&self, file: &str) -> Result<std::time::SystemTime, Self::Error> {
        if file != self.path.as_str() {
            return Err(FileContentsError::InvalidPath {
                expected_path: self.path.clone(),
                incorrect_path: Utf8PathBuf::from(file),
            });
        }
        Ok(self.modified_time.into())
    }
}

use camino::Utf8Path;

use libpijul::working_copy::WorkingCopyRead;

use crate::file_system::open_file::contents::{FileContents, FileContentsError};

pub enum UnrecordedChangesError<C: std::error::Error + 'static> {

pub enum UnrecordedChangesError<C: std::error::Error + 'static, W: std::error::Error + 'static> {

    Record(#[from] libpijul::record::RecordError<C, FileContentsError, MutTxn<()>>),

    Record(#[from] libpijul::record::RecordError<C, W, MutTxn<()>>),

pub struct UnrecordedChanges {

pub struct UnrecordedState {

impl UnrecordedChanges {
    pub fn new<C>(
        file: &FileContents,

impl UnrecordedState {
    pub fn new<C, W>(
        path: &Utf8Path,

    ) -> Result<Self, UnrecordedChangesError<C::Error>>

        // TODO: don't require a full working copy, use a `WorkingCopyRead` implementation that
        // only gives information on the current file. This is currently blocked on
        // `RecordBuilder::record()` seeming to ignore the full-file prefix and generating
        // invalid deletion hunks when the shim returns an error on unrelated files.
        working_copy: &W,
    ) -> Result<Self, UnrecordedChangesError<C::Error, W::Error>>

        W: WorkingCopyRead + Clone + Send + Sync + 'static,

            file,

            working_copy,

            file.path.as_str(),

            path.as_str(),

use camino::Utf8Path;

use libpijul::working_copy::WorkingCopyRead;

pub enum FileCreditsError<C: std::error::Error + 'static> {

pub enum FileCreditsError<C: std::error::Error + 'static, W: std::error::Error + 'static> {

    UntrackedChanges(#[from] UnrecordedChangesError<C>),

    UntrackedChanges(#[from] UnrecordedChangesError<C, W>),

    pub unrecorded_state: unrecorded::UnrecordedState,

    pub fn new<C>(
        file: &FileContents,

    pub fn new<C, W>(
        path: &Utf8Path,
        file_contents: &FileContents,

    ) -> Result<Self, FileCreditsError<C::Error>>

        working_copy: &W,
    ) -> Result<Self, FileCreditsError<C::Error, W::Error>>

        W: WorkingCopyRead + Clone + Send + Sync + 'static,

        let state = recorded::RecordedState::new(&file.path, transaction, channel, change_store)?;

        let recorded_state =
            recorded::RecordedState::new(path, transaction, channel, change_store)?;
        let unrecorded_state = unrecorded::UnrecordedState::new(
            path,
            transaction,
            channel,
            change_store,
            working_copy,
        )?;

            recorded_state: state,

            recorded_state,
            unrecorded_state,

        tracked_file.recompute_spans(file, transaction, channel, change_store)?;

        tracked_file.spans = tracked_file.recompute_spans(file_contents);

    pub fn recompute_spans<C>(
        &mut self,
        file: &FileContents,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<(), UnrecordedChangesError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        let untracked_changes =
            unrecorded::UnrecordedChanges::new(file, transaction, channel, change_store)?;

    pub fn recompute_spans(&self, file: &FileContents) -> Vec<Span<CreditSource>> {

        let mut untracked_spans = untracked_changes.spans.iter().peekable();

        let mut untracked_spans = self.unrecorded_state.spans.iter().peekable();

        self.spans = merged_spans;
        Ok(())

        merged_spans