// list_tracked_files.rs

//

// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>

//

// This software may be used and distributed according to the terms of the

// GNU General Public License version 2 or any later version.

use super::find_root;

use crate::dirstate::parsers::parse_dirstate;

use crate::utils::hg_path::HgPath;

use crate::{DirstateParseError, EntryState};

use rayon::prelude::*;

use std::convert::From;

use std::fmt;

use std::fs;

use std::io;

use std::path::PathBuf;

/// Kind of error encoutered by ListTrackedFiles

#[derive(Debug)]

pub enum ListTrackedFilesErrorKind {

    ParseError(DirstateParseError),

}

/// A ListTrackedFiles error

#[derive(Debug)]

pub struct ListTrackedFilesError {

    /// Kind of error encoutered by ListTrackedFiles

    pub kind: ListTrackedFilesErrorKind,

}

impl std::error::Error for ListTrackedFilesError {}

impl fmt::Display for ListTrackedFilesError {

    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {

        unimplemented!()

    }

}

impl From<ListTrackedFilesErrorKind> for ListTrackedFilesError {

    fn from(kind: ListTrackedFilesErrorKind) -> Self {

        ListTrackedFilesError { kind }

    }

}

/// List files under Mercurial control in the working directory

pub struct ListTrackedFiles {

    root: PathBuf,

}

impl ListTrackedFiles {

    pub fn new() -> Result<Self, find_root::FindRootError> {

        let root = find_root::FindRoot::new().run()?;

        Ok(ListTrackedFiles { root })

    }

    /// Load the tracked files data from disk

    pub fn load(&self) -> Result<ListDirstateTrackedFiles, io::Error> {

        let dirstate = &self.root.join(".hg/dirstate");

        let content = fs::read(&dirstate)?;

        Ok(ListDirstateTrackedFiles { content })

    }

}

/// List files under Mercurial control in the working directory

/// by reading the dirstate

pub struct ListDirstateTrackedFiles {

    content: Vec<u8>,

}

impl ListDirstateTrackedFiles {

    pub fn run(&self) -> Result<Vec<&HgPath>, ListTrackedFilesError> {

        let (_, entries, _) = parse_dirstate(&self.content)

            .map_err(ListTrackedFilesErrorKind::ParseError)?;

        let mut files: Vec<&HgPath> = entries

            .into_iter()

            .filter_map(|(path, entry)| match entry.state {

                EntryState::Removed => None,

                _ => Some(path),

            })

            .collect();

        files.par_sort_unstable();

        Ok(files)

    }

}