use crate::dirstate_tree::on_disk::DirstateV2ParseError;

use crate::errors::HgError;

use bitflags::bitflags;

use std::convert::{TryFrom, TryInto};

use std::fs;

use std::io;

use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Copy, Clone, Debug, Eq, PartialEq)]

pub enum EntryState {

    Normal,

    Added,

    Removed,

    Merged,

}

/// `size` and `mtime.seconds` are truncated to 31 bits.

///

/// TODO: double-check status algorithm correctness for files

/// larger than 2 GiB or modified after 2038.

#[derive(Debug, Copy, Clone)]

pub struct DirstateEntry {

    pub(crate) flags: Flags,

    mode_size: Option<(u32, u32)>,

    mtime: Option<TruncatedTimestamp>,

}

bitflags! {

    pub(crate) struct Flags: u8 {

        const WDIR_TRACKED = 1 << 0;

        const P1_TRACKED = 1 << 1;

        const P2_INFO = 1 << 2;

        const HAS_FALLBACK_EXEC = 1 << 3;

        const FALLBACK_EXEC = 1 << 4;

        const HAS_FALLBACK_SYMLINK = 1 << 5;

        const FALLBACK_SYMLINK = 1 << 6;

    }

}

/// A Unix timestamp with nanoseconds precision

#[derive(Debug, Copy, Clone)]

pub struct TruncatedTimestamp {

    truncated_seconds: u32,

    /// Always in the `0 .. 1_000_000_000` range.

    nanoseconds: u32,

    /// TODO this should be in DirstateEntry, but the current code needs

    /// refactoring to use DirstateEntry instead of TruncatedTimestamp for

    /// comparison.

    pub second_ambiguous: bool,

}

impl TruncatedTimestamp {

    /// Constructs from a timestamp potentially outside of the supported range,

    /// and truncate the seconds components to its lower 31 bits.

    ///

    /// Panics if the nanoseconds components is not in the expected range.

    pub fn new_truncate(

        seconds: i64,

        nanoseconds: u32,

        second_ambiguous: bool,

    ) -> Self {

        assert!(nanoseconds < NSEC_PER_SEC);

        Self {

            truncated_seconds: seconds as u32 & RANGE_MASK_31BIT,

            nanoseconds,

            second_ambiguous,

        }

    }

    /// Construct from components. Returns an error if they are not in the

    /// expcted range.

    pub fn from_already_truncated(

        truncated_seconds: u32,

        nanoseconds: u32,

        second_ambiguous: bool,

    ) -> Result<Self, DirstateV2ParseError> {

        if truncated_seconds & !RANGE_MASK_31BIT == 0

            && nanoseconds < NSEC_PER_SEC

        {

            Ok(Self {

                truncated_seconds,

                nanoseconds,

                second_ambiguous,

            })

        } else {

            Err(DirstateV2ParseError)

        }

    }

    /// Returns a `TruncatedTimestamp` for the modification time of `metadata`.

    ///

    /// Propagates errors from `std` on platforms where modification time

    /// is not available at all.

    pub fn for_mtime_of(metadata: &fs::Metadata) -> io::Result<Self> {

        #[cfg(unix)]

        {

            use std::os::unix::fs::MetadataExt;

            let seconds = metadata.mtime();

            // i64 -> u32 with value always in the `0 .. NSEC_PER_SEC` range

            let nanoseconds = metadata.mtime_nsec().try_into().unwrap();

            Ok(Self::new_truncate(seconds, nanoseconds, false))

        }

        #[cfg(not(unix))]

        {

            metadata.modified().map(Self::from)

        }

    }

    /// Like `for_mtime_of`, but may return `None` or a value with

    /// `second_ambiguous` set if the mtime is not "reliable".

    ///

    /// A modification time is reliable if it is older than `boundary` (or

    /// sufficiently in the future).

    ///

    /// Otherwise a concurrent modification might happens with the same mtime.

    pub fn for_reliable_mtime_of(

        metadata: &fs::Metadata,

        boundary: &Self,

    ) -> io::Result<Option<Self>> {

        let mut mtime = Self::for_mtime_of(metadata)?;

        // If the mtime of the ambiguous file is younger (or equal) to the

        // starting point of the `status` walk, we cannot garantee that

        // another, racy, write will not happen right after with the same mtime

        // and we cannot cache the information.

        //

        // However if the mtime is far away in the future, this is likely some

        // mismatch between the current clock and previous file system

        // operation. So mtime more than one days in the future are considered

        // fine.

        let reliable = if mtime.truncated_seconds == boundary.truncated_seconds

        {

            mtime.second_ambiguous = true;

            mtime.nanoseconds != 0

                && boundary.nanoseconds != 0

                && mtime.nanoseconds < boundary.nanoseconds

        } else {

            // `truncated_seconds` is less than 2**31,

            // so this does not overflow `u32`:

            let one_day_later = boundary.truncated_seconds + 24 * 3600;

            mtime.truncated_seconds < boundary.truncated_seconds

                || mtime.truncated_seconds > one_day_later

        };

        if reliable {

            Ok(Some(mtime))

        } else {

            Ok(None)

        }

    }

    /// The lower 31 bits of the number of seconds since the epoch.

    pub fn truncated_seconds(&self) -> u32 {

        self.truncated_seconds

    }

    /// The sub-second component of this timestamp, in nanoseconds.

    /// Always in the `0 .. 1_000_000_000` range.

    ///

    /// This timestamp is after `(seconds, 0)` by this many nanoseconds.

    pub fn nanoseconds(&self) -> u32 {

        self.nanoseconds

    }

    /// Returns whether two timestamps are equal modulo 2**31 seconds.

    ///

    /// If this returns `true`, the original values converted from `SystemTime`

    /// or given to `new_truncate` were very likely equal. A false positive is

    /// possible if they were exactly a multiple of 2**31 seconds apart (around

    /// 68 years). This is deemed very unlikely to happen by chance, especially

    /// on filesystems that support sub-second precision.

    ///

    /// If someone is manipulating the modification times of some files to

    /// intentionally make `hg status` return incorrect results, not truncating

    /// wouldn’t help much since they can set exactly the expected timestamp.

    ///

    /// Sub-second precision is ignored if it is zero in either value.

    /// Some APIs simply return zero when more precision is not available.

    /// When comparing values from different sources, if only one is truncated

    /// in that way, doing a simple comparison would cause many false

    /// negatives.

    pub fn likely_equal(self, other: Self) -> bool {

        if self.truncated_seconds != other.truncated_seconds {

            false

        } else if self.nanoseconds == 0 || other.nanoseconds == 0 {

            if self.second_ambiguous {

                false

            } else {

                true

            }

        } else {

            self.nanoseconds == other.nanoseconds

        }

    }

    pub fn likely_equal_to_mtime_of(

        self,

        metadata: &fs::Metadata,

    ) -> io::Result<bool> {

        Ok(self.likely_equal(Self::for_mtime_of(metadata)?))

    }

}

impl From<SystemTime> for TruncatedTimestamp {

    fn from(system_time: SystemTime) -> Self {

        // On Unix, `SystemTime` is a wrapper for the `timespec` C struct:

        // https://www.gnu.org/software/libc/manual/html_node/Time-Types.html#index-struct-timespec

        // We want to effectively access its fields, but the Rust standard

        // library does not expose them. The best we can do is:

        let seconds;

        let nanoseconds;

        match system_time.duration_since(UNIX_EPOCH) {

            Ok(duration) => {

                seconds = duration.as_secs() as i64;

                nanoseconds = duration.subsec_nanos();

            }

            Err(error) => {

                // `system_time` is before `UNIX_EPOCH`.

                // We need to undo this algorithm:

                // https://github.com/rust-lang/rust/blob/6bed1f0bc3cc50c10aab26d5f94b16a00776b8a5/library/std/src/sys/unix/time.rs#L40-L41

                let negative = error.duration();

                let negative_secs = negative.as_secs() as i64;

                let negative_nanos = negative.subsec_nanos();

                if negative_nanos == 0 {

                    seconds = -negative_secs;

                    nanoseconds = 0;

                } else {

                    // For example if `system_time` was 4.3 seconds before

                    // the Unix epoch we get a Duration that represents

                    // `(-4, -0.3)` but we want `(-5, +0.7)`:

                    seconds = -1 - negative_secs;

                    nanoseconds = NSEC_PER_SEC - negative_nanos;

                }

            }

        };

        Self::new_truncate(seconds, nanoseconds, false)

    }

}

const NSEC_PER_SEC: u32 = 1_000_000_000;

pub const RANGE_MASK_31BIT: u32 = 0x7FFF_FFFF;

pub const MTIME_UNSET: i32 = -1;

/// A `DirstateEntry` with a size of `-2` means that it was merged from the

/// other parent. This allows revert to pick the right status back during a

/// merge.

pub const SIZE_FROM_OTHER_PARENT: i32 = -2;

/// A special value used for internal representation of special case in

/// dirstate v1 format.

pub const SIZE_NON_NORMAL: i32 = -1;

impl DirstateEntry {

    pub fn from_v2_data(

        wdir_tracked: bool,

        p1_tracked: bool,

        p2_info: bool,

        mode_size: Option<(u32, u32)>,

        mtime: Option<TruncatedTimestamp>,

        fallback_exec: Option<bool>,

        fallback_symlink: Option<bool>,

    ) -> Self {

        if let Some((mode, size)) = mode_size {

            // TODO: return an error for out of range values?

            assert!(mode & !RANGE_MASK_31BIT == 0);

            assert!(size & !RANGE_MASK_31BIT == 0);

        }

        let mut flags = Flags::empty();

        flags.set(Flags::WDIR_TRACKED, wdir_tracked);

        flags.set(Flags::P1_TRACKED, p1_tracked);

        flags.set(Flags::P2_INFO, p2_info);

        if let Some(exec) = fallback_exec {

            flags.insert(Flags::HAS_FALLBACK_EXEC);

            if exec {

                flags.insert(Flags::FALLBACK_EXEC);

            }

        }

        if let Some(exec) = fallback_symlink {

            flags.insert(Flags::HAS_FALLBACK_SYMLINK);

            if exec {

                flags.insert(Flags::FALLBACK_SYMLINK);

            }

        }

        Self {

            flags,

            mode_size,

            mtime,

        }

    }

    pub fn from_v1_data(

        state: EntryState,

        mode: i32,

        size: i32,

        mtime: i32,

    ) -> Self {

        match state {

            EntryState::Normal => {

                if size == SIZE_FROM_OTHER_PARENT {

                    Self {

                        // might be missing P1_TRACKED

                        flags: Flags::WDIR_TRACKED | Flags::P2_INFO,

                        mode_size: None,

                        mtime: None,

                    }

                } else if size == SIZE_NON_NORMAL {

                    Self {

                        flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,

                        mode_size: None,

                        mtime: None,

                    }

                } else if mtime == MTIME_UNSET {

                    // TODO: return an error for negative values?

                    let mode = u32::try_from(mode).unwrap();

                    let size = u32::try_from(size).unwrap();

                    Self {

                        flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,

                        mode_size: Some((mode, size)),

                        mtime: None,

                    }

                } else {

                    // TODO: return an error for negative values?

                    let mode = u32::try_from(mode).unwrap();

                    let size = u32::try_from(size).unwrap();

                    let mtime = u32::try_from(mtime).unwrap();

                    let mtime = TruncatedTimestamp::from_already_truncated(

                        mtime, 0, false,

                    )

                    .unwrap();

                    Self {

                        flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,

                        mode_size: Some((mode, size)),

                        mtime: Some(mtime),

                    }

                }

            }

            EntryState::Added => Self {

                flags: Flags::WDIR_TRACKED,

                mode_size: None,

                mtime: None,

            },

            EntryState::Removed => Self {

                flags: if size == SIZE_NON_NORMAL {

                    Flags::P1_TRACKED | Flags::P2_INFO

                } else if size == SIZE_FROM_OTHER_PARENT {

                    // We don’t know if P1_TRACKED should be set (file history)

                    Flags::P2_INFO

                } else {

                    Flags::P1_TRACKED

                },

                mode_size: None,

                mtime: None,

            },

            EntryState::Merged => Self {

                flags: Flags::WDIR_TRACKED

                    | Flags::P1_TRACKED // might not be true because of rename ?

                    | Flags::P2_INFO, // might not be true because of rename ?

                mode_size: None,