use crate::errors::{HgError, HgResultExt, IoErrorContext, IoResultExt};

use crate::exit_codes;

use crate::fncache::FnCache;

use crate::revlog::path_encode::path_encode;

use crate::utils::files::{get_bytes_from_path, get_path_from_bytes};

use dyn_clone::DynClone;

use format_bytes::format_bytes;

use memmap2::{Mmap, MmapOptions};

use rand::distributions::{Alphanumeric, DistString};

use std::fs::{File, Metadata, OpenOptions};

use std::io::{ErrorKind, Read, Seek, Write};

use std::os::fd::AsRawFd;

use std::os::unix::fs::{MetadataExt, PermissionsExt};

use std::path::{Path, PathBuf};

#[cfg(test)]

use std::sync::atomic::AtomicUsize;

#[cfg(test)]

use std::sync::atomic::Ordering;

use std::sync::OnceLock;

/// Filesystem access abstraction for the contents of a given "base" diretory

#[derive(Clone)]

pub struct VfsImpl {

    pub(crate) base: PathBuf,

    pub readonly: bool,

    pub mode: Option<u32>,

}

struct FileNotFound(std::io::Error, PathBuf);

/// Store the umask for the whole process since it's expensive to get.

static UMASK: OnceLock<u32> = OnceLock::new();

fn get_umask() -> u32 {

    *UMASK.get_or_init(|| unsafe {

        // TODO is there any way of getting the umask without temporarily

        // setting it? Doesn't this affect all threads in this tiny window?

        let mask = libc::umask(0);

        libc::umask(mask);

        #[allow(clippy::useless_conversion)]

        (mask & 0o777).into()

    })

}

/// Return the (unix) mode with which we will create/fix files

fn get_mode(base: impl AsRef<Path>) -> Option<u32> {

    match base.as_ref().metadata() {

        Ok(meta) => {

            // files in .hg/ will be created using this mode

            let mode = meta.mode();

            // avoid some useless chmods

            if (0o777 & !get_umask()) == (0o777 & mode) {

                None

            } else {

                Some(mode)

            }

        }

        Err(_) => None,

    }

}

impl VfsImpl {

    pub fn new(base: PathBuf, readonly: bool) -> Self {

        let mode = get_mode(&base);

        Self {

            base,

            readonly,

            mode,

        }

    }

    // XXX these methods are probably redundant with VFS trait?

    pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {

        self.base.join(relative_path)

    }

    pub fn symlink_metadata(

        &self,

        relative_path: impl AsRef<Path>,

    ) -> Result<std::fs::Metadata, HgError> {

        let path = self.join(relative_path);

        std::fs::symlink_metadata(&path).when_reading_file(&path)

    }

    pub fn read_link(

        &self,

        relative_path: impl AsRef<Path>,

    ) -> Result<PathBuf, HgError> {

        let path = self.join(relative_path);

        std::fs::read_link(&path).when_reading_file(&path)

    }

    pub fn read(

        &self,

        relative_path: impl AsRef<Path>,

    ) -> Result<Vec<u8>, HgError> {

        let path = self.join(relative_path);

        std::fs::read(&path).when_reading_file(&path)

    }

    /// Returns `Ok(None)` if the file does not exist.

    pub fn try_read(

        &self,

        relative_path: impl AsRef<Path>,

    ) -> Result<Option<Vec<u8>>, HgError> {

        match self.read(relative_path) {

            Err(e) => match &e {

                HgError::IoError { error, .. } => match error.kind() {

                    ErrorKind::NotFound => Ok(None),

                    _ => Err(e),

                },

                _ => Err(e),

            },

            Ok(v) => Ok(Some(v)),

        }

    }

    fn mmap_open_gen(

        &self,

        relative_path: impl AsRef<Path>,

    ) -> Result<Result<Mmap, FileNotFound>, HgError> {

        let path = self.join(relative_path);

        let file = match std::fs::File::open(&path) {

            Err(err) => {

                if let ErrorKind::NotFound = err.kind() {

                    return Ok(Err(FileNotFound(err, path)));

                };

                return (Err(err)).when_reading_file(&path);

            }

            Ok(file) => file,

        };

        // Safety is "enforced" by locks and assuming other processes are

        // well-behaved. If any misbehaving or malicious process does touch

        // the index, it could lead to corruption. This is inherent

        // to file-based `mmap`, though some platforms have some ways of

        // mitigating.

        // TODO linux: set the immutable flag with `chattr(1)`?

        let mmap = unsafe { MmapOptions::new().map(&file) }

            .when_reading_file(&path)?;

        Ok(Ok(mmap))

    }

    pub fn mmap_open_opt(

        &self,

        relative_path: impl AsRef<Path>,

    ) -> Result<Option<Mmap>, HgError> {

        self.mmap_open_gen(relative_path).map(|res| res.ok())

    }

    pub fn mmap_open(

        &self,

        relative_path: impl AsRef<Path>,

    ) -> Result<Mmap, HgError> {

        match self.mmap_open_gen(relative_path)? {

            Err(FileNotFound(err, path)) => Err(err).when_reading_file(&path),

            Ok(res) => Ok(res),

        }

    }

    #[cfg(unix)]

    pub fn create_symlink(

        &self,

        relative_link_path: impl AsRef<Path>,

        target_path: impl AsRef<Path>,

    ) -> Result<(), HgError> {

        let link_path = self.join(relative_link_path);

        std::os::unix::fs::symlink(target_path, &link_path)

            .when_writing_file(&link_path)

    }

    /// Write `contents` into a temporary file, then rename to `relative_path`.

    /// This makes writing to a file "atomic": a reader opening that path will

    /// see either the previous contents of the file or the complete new

    /// content, never a partial write.

    pub fn atomic_write(

        &self,

        relative_path: impl AsRef<Path>,

        contents: &[u8],

    ) -> Result<(), HgError> {

        let mut tmp = tempfile::Builder::new()

            .permissions(std::fs::Permissions::from_mode(0o666))

            .tempfile_in(&self.base)

            .when_writing_file(&self.base)?;

        tmp.write_all(contents)

            .and_then(|()| tmp.flush())

            .when_writing_file(tmp.path())?;

        let path = self.join(relative_path);

        tmp.persist(&path)

            .map_err(|e| e.error)

            .when_writing_file(&path)?;

        Ok(())

    }

}

fn fs_metadata(

    path: impl AsRef<Path>,

) -> Result<Option<std::fs::Metadata>, HgError> {

    let path = path.as_ref();

    match path.metadata() {

        Ok(meta) => Ok(Some(meta)),

        Err(error) => match error.kind() {

            // TODO: when we require a Rust version where `NotADirectory` is

            // stable, invert this logic and return None for it and `NotFound`

            // and propagate any other error.

            ErrorKind::PermissionDenied => Err(error).with_context(|| {

                IoErrorContext::ReadingMetadata(path.to_owned())

            }),

            _ => Ok(None),

        },

    }

}

/// Abstraction over the files handled by a [`Vfs`].

#[derive(Debug)]

pub enum VfsFile {

    Atomic(AtomicFile),

    Normal {

        file: File,

        path: PathBuf,

        /// If `Some`, check (and maybe fix) this file's timestamp ambiguity.

        /// See [`is_filetime_ambiguous`].

        check_ambig: Option<Metadata>,

    },

}

impl VfsFile {

    pub fn normal(file: File, path: PathBuf) -> Self {

        Self::Normal {

            file,

            check_ambig: None,

            path,

        }

    }

    pub fn normal_check_ambig(

        file: File,

        path: PathBuf,

    ) -> Result<Self, HgError> {

        Ok(Self::Normal {

            file,

            check_ambig: Some(path.metadata().when_reading_file(&path)?),

            path,

        })

    }

    pub fn try_clone(&self) -> Result<VfsFile, HgError> {

        Ok(match self {

            VfsFile::Atomic(AtomicFile {

                fp,

                temp_path,

                check_ambig,

                target_name,

                is_open,

            }) => Self::Atomic(AtomicFile {

                fp: fp.try_clone().when_reading_file(temp_path)?,

                temp_path: temp_path.clone(),

                check_ambig: *check_ambig,

                target_name: target_name.clone(),

                is_open: *is_open,

            }),

            VfsFile::Normal {

                file,

                check_ambig,

                path,

            } => Self::Normal {

                file: file.try_clone().when_reading_file(path)?,

                check_ambig: check_ambig.clone(),

                path: path.to_owned(),

            },

        })

    }

    pub fn set_len(&self, len: u64) -> Result<(), std::io::Error> {

        match self {

            VfsFile::Atomic(atomic_file) => atomic_file.fp.set_len(len),

            VfsFile::Normal { file, .. } => file.set_len(len),

        }

    }

    pub fn metadata(&self) -> Result<std::fs::Metadata, std::io::Error> {

        match self {

            VfsFile::Atomic(atomic_file) => atomic_file.fp.metadata(),

            VfsFile::Normal { file, .. } => file.metadata(),

        }

    }

}

impl AsRawFd for VfsFile {

    fn as_raw_fd(&self) -> std::os::unix::prelude::RawFd {

        match self {

            VfsFile::Atomic(atomic_file) => atomic_file.fp.as_raw_fd(),

            VfsFile::Normal { file, .. } => file.as_raw_fd(),

        }

    }

}

impl Seek for VfsFile {

    fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {

        match self {

            VfsFile::Atomic(atomic_file) => atomic_file.seek(pos),

            VfsFile::Normal { file, .. } => file.seek(pos),

        }

    }

}

impl Read for VfsFile {

    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {

        match self {

            VfsFile::Atomic(atomic_file) => atomic_file.fp.read(buf),

            VfsFile::Normal { file, .. } => file.read(buf),

        }

    }

}

impl Write for VfsFile {

    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {

        match self {

            VfsFile::Atomic(atomic_file) => atomic_file.fp.write(buf),

            VfsFile::Normal { file, .. } => file.write(buf),

        }

    }

    fn flush(&mut self) -> std::io::Result<()> {

        match self {

            VfsFile::Atomic(atomic_file) => atomic_file.fp.flush(),

            VfsFile::Normal { file, .. } => file.flush(),

        }

    }

}

impl Drop for VfsFile {

    fn drop(&mut self) {

        if let VfsFile::Normal {

            path,

            check_ambig: Some(old),

            ..

        } = self

        {

            avoid_timestamp_ambiguity(path, old)

        }

    }

}

/// Records the number of times we've fixed a timestamp ambiguity, only

/// applicable for tests.

#[cfg(test)]

static TIMESTAMP_FIXES_CALLS: AtomicUsize = AtomicUsize::new(0);

fn avoid_timestamp_ambiguity(path: &Path, old: &Metadata) {

    if let Ok(new) = path.metadata() {

        let is_ambiguous = is_filetime_ambiguous(&new, old);

        if is_ambiguous {

            let advanced =

                filetime::FileTime::from_unix_time(old.mtime() + 1, 0);

            if filetime::set_file_times(path, advanced, advanced).is_ok() {

                #[cfg(test)]

                {

                    TIMESTAMP_FIXES_CALLS.fetch_add(1, Ordering::Relaxed);

                }

            }

        }

    }

}

/// Examine whether new stat is ambiguous against old one

///

/// `S[N]` below means stat of a file at `N`-th change:

///

/// - `S[n-1].ctime  < S[n].ctime`: can detect change of a file

/// - `S[n-1].ctime == S[n].ctime`

///   - `S[n-1].ctime  < S[n].mtime`: means natural advancing (*1)

///   - `S[n-1].ctime == S[n].mtime`: is ambiguous (*2)

///   - `S[n-1].ctime  > S[n].mtime`: never occurs naturally (don't care)

/// - `S[n-1].ctime  > S[n].ctime`: never occurs naturally (don't care)

///

/// Case (*2) above means that a file was changed twice or more at

/// same time in sec (= `S[n-1].ctime`), and comparison of timestamp

/// is ambiguous.

///

/// Base idea to avoid such ambiguity is "advance mtime 1 sec, if

/// timestamp is ambiguous".

///

/// But advancing mtime only in case (*2) doesn't work as

/// expected, because naturally advanced `S[n].mtime` in case (*1)

/// might be equal to manually advanced `S[n-1 or earlier].mtime`.

///

/// Therefore, all `S[n-1].ctime == S[n].ctime` cases should be

/// treated as ambiguous regardless of mtime, to avoid overlooking

/// by confliction between such mtime.

///

/// Advancing mtime `if isambig(new, old)` ensures `S[n-1].mtime !=

/// S[n].mtime`, even if size of a file isn't changed.

pub fn is_filetime_ambiguous(new: &Metadata, old: &Metadata) -> bool {

    new.ctime() == old.ctime()

}

/// Writable file object that atomically updates a file

///

/// All writes will go to a temporary copy of the original file. Call

/// [`Self::close`] when you are done writing, and [`Self`] will rename

/// the temporary copy to the original name, making the changes

/// visible. If the object is destroyed without being closed, all your

/// writes are discarded.

#[derive(Debug)]

pub struct AtomicFile {

    /// The temporary file to write to

    fp: std::fs::File,

    /// Path of the temp file

    temp_path: PathBuf,

    /// Used when stat'ing the file, is useful only if the target file is

    /// guarded by any lock (e.g. repo.lock or repo.wlock).

    check_ambig: bool,

    /// Path of the target file

    target_name: PathBuf,

    /// Whether the file is open or not

    is_open: bool,

}

impl AtomicFile {

    pub fn new(

        target_path: impl AsRef<Path>,

        empty: bool,

        check_ambig: bool,

    ) -> Result<Self, HgError> {

        let target_path = target_path.as_ref().to_owned();

        let random_id =

            Alphanumeric.sample_string(&mut rand::thread_rng(), 12);

        let filename =

            target_path.file_name().expect("target has no filename");

        let filename = get_bytes_from_path(filename);

        let temp_filename =

            format_bytes!(b".{}-{}~", filename, random_id.as_bytes());

        let temp_path =

            target_path.with_file_name(get_path_from_bytes(&temp_filename));

        if !empty {

            std::fs::copy(&target_path, &temp_path)

                .with_context(|| IoErrorContext::CopyingFile {

                    from: target_path.to_owned(),

                    to: temp_path.to_owned(),

                })

                // If it doesn't exist, create it on open

                .io_not_found_as_none()?;

        }

        let fp = std::fs::OpenOptions::new()

            .write(true)

            .create(true)

            .truncate(empty)

            .open(&temp_path)

            .when_writing_file(&temp_path)?;

        Ok(Self {

            fp,

            temp_path,

            check_ambig,

            target_name: target_path,

            is_open: true,

        })

    }

    pub fn from_file(

        fp: std::fs::File,

        check_ambig: bool,

        temp_name: PathBuf,

        target_name: PathBuf,

    ) -> Self {

        Self {

            fp,

            check_ambig,

            temp_path: temp_name,

            target_name,

            is_open: true,

        }

    }

    /// Write `buf` to the temporary file

    pub fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {

        self.fp.write_all(buf)

    }

    fn target(&self) -> PathBuf {

        self.temp_path

            .parent()

            .expect("should not be at the filesystem root")

            .join(&self.target_name)

    }

    /// Close the temporary file and rename to the target

    pub fn close(mut self) -> Result<(), std::io::Error> {

        self.fp.flush()?;

        let target = self.target();

        if self.check_ambig {

            if let Ok(stat) = target.metadata() {

                std::fs::rename(&self.temp_path, &target)?;