// hg_path.rs

//

// Copyright 2019 Raphaël Gomès <rgomes@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 crate::utils::SliceExt;

use std::borrow::Borrow;

use std::borrow::Cow;

use std::convert::TryFrom;

use std::ffi::{OsStr, OsString};

use std::fmt;

use std::ops::Deref;

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

#[derive(Debug, Eq, PartialEq)]

pub enum HgPathError {

    /// Bytes from the invalid `HgPath`

    LeadingSlash(Vec<u8>),

    ConsecutiveSlashes {

        bytes: Vec<u8>,

        second_slash_index: usize,

    },

    ContainsNullByte {

        bytes: Vec<u8>,

        null_byte_index: usize,

    },

    /// Bytes

    DecodeError(Vec<u8>),

    /// The rest come from audit errors

    EndsWithSlash(HgPathBuf),

    ContainsIllegalComponent(HgPathBuf),

    /// Path is inside the `.hg` folder

    InsideDotHg(HgPathBuf),

    IsInsideNestedRepo {

        path: HgPathBuf,

        nested_repo: HgPathBuf,

    },

    TraversesSymbolicLink {

        path: HgPathBuf,

        symlink: HgPathBuf,

    },

    NotFsCompliant(HgPathBuf),

    /// `path` is the smallest invalid path

    NotUnderRoot {

        path: PathBuf,

        root: PathBuf,

    },

}

impl fmt::Display for HgPathError {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        match self {

            HgPathError::LeadingSlash(bytes) => {

                write!(f, "Invalid HgPath '{:?}': has a leading slash.", bytes)

            }

            HgPathError::ConsecutiveSlashes {

                bytes,

                second_slash_index: pos,

            } => write!(

                f,

                "Invalid HgPath '{:?}': consecutive slashes at pos {}.",

                bytes, pos

            ),

            HgPathError::ContainsNullByte {

                bytes,

                null_byte_index: pos,

            } => write!(

                f,

                "Invalid HgPath '{:?}': contains null byte at pos {}.",

                bytes, pos

            ),

            HgPathError::DecodeError(bytes) => write!(

                f,

                "Invalid HgPath '{:?}': could not be decoded.",

                bytes

            ),

            HgPathError::EndsWithSlash(path) => {

                write!(f, "Audit failed for '{}': ends with a slash.", path)

            }

            HgPathError::ContainsIllegalComponent(path) => write!(

                f,

                "Audit failed for '{}': contains an illegal component.",

                path

            ),

            HgPathError::InsideDotHg(path) => write!(

                f,

                "Audit failed for '{}': is inside the '.hg' folder.",

                path

            ),

            HgPathError::IsInsideNestedRepo {

                path,

                nested_repo: nested,

            } => {

                write!(f,

                "Audit failed for '{}': is inside a nested repository '{}'.",

                path, nested

            )

            }

            HgPathError::TraversesSymbolicLink { path, symlink } => write!(

                f,

                "Audit failed for '{}': traverses symbolic link '{}'.",

                path, symlink

            ),

            HgPathError::NotFsCompliant(path) => write!(

                f,

                "Audit failed for '{}': cannot be turned into a \

                 filesystem path.",

                path

            ),

            HgPathError::NotUnderRoot { path, root } => write!(

                f,

                "Audit failed for '{}': not under root {}.",

                path.display(),

                root.display()

            ),

        }

    }

}

impl From<HgPathError> for std::io::Error {

    fn from(e: HgPathError) -> Self {

        std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())

    }

}

/// This is a repository-relative path (or canonical path):

///     - no null characters

///     - `/` separates directories

///     - no consecutive slashes

///     - no leading slash,

///     - no `.` nor `..` of special meaning

///     - stored in repository and shared across platforms

///

/// Note: there is no guarantee of any `HgPath` being well-formed at any point

/// in its lifetime for performance reasons and to ease ergonomics. It is

/// however checked using the `check_state` method before any file-system

/// operation.

///

/// This allows us to be encoding-transparent as much as possible, until really

/// needed; `HgPath` can be transformed into a platform-specific path (`OsStr`

/// or `Path`) whenever more complex operations are needed:

/// On Unix, it's just byte-to-byte conversion. On Windows, it has to be

/// decoded from MBCS to WTF-8. If WindowsUTF8Plan is implemented, the source

/// character encoding will be determined on a per-repository basis.

#[derive(Eq, Ord, PartialEq, PartialOrd, Hash)]

pub struct HgPath {

    inner: [u8],

}

impl HgPath {

    pub fn new<S: AsRef<[u8]> + ?Sized>(s: &S) -> &Self {

        unsafe { &*(s.as_ref() as *const [u8] as *const Self) }

    }

    pub fn is_empty(&self) -> bool {

        self.inner.is_empty()

    }

    pub fn len(&self) -> usize {

        self.inner.len()

    }

    fn to_hg_path_buf(&self) -> HgPathBuf {

        HgPathBuf {

            inner: self.inner.to_owned(),

        }

    }

    pub fn bytes(&self) -> std::slice::Iter<u8> {

        self.inner.iter()

    }

    pub fn to_ascii_uppercase(&self) -> HgPathBuf {

        HgPathBuf::from(self.inner.to_ascii_uppercase())

    }

    pub fn to_ascii_lowercase(&self) -> HgPathBuf {

        HgPathBuf::from(self.inner.to_ascii_lowercase())

    }

    pub fn as_bytes(&self) -> &[u8] {

        &self.inner

    }

    pub fn contains(&self, other: u8) -> bool {

        self.inner.contains(&other)

    }

    pub fn starts_with(&self, needle: impl AsRef<Self>) -> bool {

        self.inner.starts_with(needle.as_ref().as_bytes())

    }

    pub fn trim_trailing_slash(&self) -> &Self {

        Self::new(if self.inner.last() == Some(&b'/') {

            &self.inner[..self.inner.len() - 1]

        } else {

            &self.inner[..]

        })

    }

    /// Returns a tuple of slices `(base, filename)` resulting from the split

    /// at the rightmost `/`, if any.

    ///

    /// # Examples:

    ///

    /// ```

    /// use hg::utils::hg_path::HgPath;

    ///

    /// let path = HgPath::new(b"cool/hg/path").split_filename();

    /// assert_eq!(path, (HgPath::new(b"cool/hg"), HgPath::new(b"path")));

    ///

    /// let path = HgPath::new(b"pathwithoutsep").split_filename();

    /// assert_eq!(path, (HgPath::new(b""), HgPath::new(b"pathwithoutsep")));

    /// ```

    pub fn split_filename(&self) -> (&Self, &Self) {

        match &self.inner.iter().rposition(|c| *c == b'/') {

            None => (HgPath::new(""), &self),

            Some(size) => (

                HgPath::new(&self.inner[..*size]),

                HgPath::new(&self.inner[*size + 1..]),

            ),

        }

    }

    pub fn join(&self, path: &HgPath) -> HgPathBuf {

        let mut buf = self.to_owned();

        buf.push(path);

        buf

    }

    pub fn components(&self) -> impl Iterator<Item = &HgPath> {

        self.inner.split(|&byte| byte == b'/').map(HgPath::new)

    }

    /// Returns the first (that is "root-most") slash-separated component of

    /// the path, and the rest after the first slash if there is one.

    pub fn split_first_component(&self) -> (&HgPath, Option<&HgPath>) {

        match self.inner.split_2(b'/') {

            Some((a, b)) => (HgPath::new(a), Some(HgPath::new(b))),

            None => (self, None),

        }

    }

    pub fn parent(&self) -> &Self {

        let inner = self.as_bytes();

        HgPath::new(match inner.iter().rposition(|b| *b == b'/') {

            Some(pos) => &inner[..pos],

            None => &[],

        })

    }

    /// Given a base directory, returns the slice of `self` relative to the

    /// base directory. If `base` is not a directory (does not end with a

    /// `b'/'`), returns `None`.

    pub fn relative_to(&self, base: impl AsRef<Self>) -> Option<&Self> {

        let base = base.as_ref();

        if base.is_empty() {

            return Some(self);

        }

        let is_dir = base.as_bytes().ends_with(b"/");

        if is_dir && self.starts_with(base) {

            Some(Self::new(&self.inner[base.len()..]))

        } else {

            None

        }

    }

    #[cfg(windows)]

    /// Copied from the Python stdlib's `os.path.splitdrive` implementation.

    ///

    /// Split a pathname into drive/UNC sharepoint and relative path

    /// specifiers. Returns a 2-tuple (drive_or_unc, path); either part may

    /// be empty.

    ///

    /// If you assign

    ///  result = split_drive(p)

    /// It is always true that:

    ///  result[0] + result[1] == p

    ///

    /// If the path contained a drive letter, drive_or_unc will contain

    /// everything up to and including the colon.

    /// e.g. split_drive("c:/dir") returns ("c:", "/dir")

    ///

    /// If the path contained a UNC path, the drive_or_unc will contain the

    /// host name and share up to but not including the fourth directory

    /// separator character.

    /// e.g. split_drive("//host/computer/dir") returns ("//host/computer",

    /// "/dir")

    ///

    /// Paths cannot contain both a drive letter and a UNC path.

    pub fn split_drive<'a>(&self) -> (&HgPath, &HgPath) {

        let bytes = self.as_bytes();

        let is_sep = |b| std::path::is_separator(b as char);

        if self.len() < 2 {

            (HgPath::new(b""), &self)

        } else if is_sep(bytes[0])

            && is_sep(bytes[1])

            && (self.len() == 2 || !is_sep(bytes[2]))

        {

            // Is a UNC path:

            // vvvvvvvvvvvvvvvvvvvv drive letter or UNC path

            // \\machine\mountpoint\directory\etc\...

            //           directory ^^^^^^^^^^^^^^^

            let machine_end_index = bytes[2..].iter().position(|b| is_sep(*b));

            let mountpoint_start_index = if let Some(i) = machine_end_index {

                i + 2

            } else {

                return (HgPath::new(b""), &self);

            };

            match bytes[mountpoint_start_index + 1..]

                .iter()

                .position(|b| is_sep(*b))

            {

                // A UNC path can't have two slashes in a row

                // (after the initial two)

                Some(0) => (HgPath::new(b""), &self),

                Some(i) => {

                    let (a, b) =

                        bytes.split_at(mountpoint_start_index + 1 + i);

                    (HgPath::new(a), HgPath::new(b))

                }

                None => (&self, HgPath::new(b"")),

            }

        } else if bytes[1] == b':' {

            // Drive path c:\directory

            let (a, b) = bytes.split_at(2);

            (HgPath::new(a), HgPath::new(b))

        } else {

            (HgPath::new(b""), &self)

        }

    }

    #[cfg(unix)]

    /// Split a pathname into drive and path. On Posix, drive is always empty.

    pub fn split_drive(&self) -> (&HgPath, &HgPath) {

        (HgPath::new(b""), &self)

    }

    /// Checks for errors in the path, short-circuiting at the first one.

    /// This generates fine-grained errors useful for debugging.

    /// To simply check if the path is valid during tests, use `is_valid`.

    pub fn check_state(&self) -> Result<(), HgPathError> {

        if self.is_empty() {

            return Ok(());

        }

        let bytes = self.as_bytes();

        let mut previous_byte = None;

        if bytes[0] == b'/' {

            return Err(HgPathError::LeadingSlash(bytes.to_vec()));

        }

        for (index, byte) in bytes.iter().enumerate() {

            match byte {

                0 => {

                    return Err(HgPathError::ContainsNullByte {

                        bytes: bytes.to_vec(),

                        null_byte_index: index,