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

use crate::utils::hg_path::HgPathBuf;

use crate::Revision;

use crate::NULL_REVISION;

use im_rc::ordmap::Entry;

use im_rc::ordmap::OrdMap;

use im_rc::OrdSet;

use std::cmp::Ordering;

use std::collections::HashMap;

use std::convert::TryInto;

pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;

type PathToken = usize;

#[derive(Clone, Debug)]

struct CopySource {

    /// revision at which the copy information was added

    rev: Revision,

    /// the copy source, (Set to None in case of deletion of the associated

    /// key)

    path: Option<PathToken>,

    /// a set of previous `CopySource.rev` value directly or indirectly

    /// overwritten by this one.

    overwritten: OrdSet<Revision>,

}

impl CopySource {

    /// create a new CopySource

    ///

    /// Use this when no previous copy source existed.

    fn new(rev: Revision, path: Option<PathToken>) -> Self {

        Self {

            rev,

            path,

            overwritten: OrdSet::new(),

        }

    }

    /// create a new CopySource from merging two others

    ///

    /// Use this when merging two InternalPathCopies requires active merging of

    /// some entries.

    fn new_from_merge(rev: Revision, winner: &Self, loser: &Self) -> Self {

        let mut overwritten = OrdSet::new();

        overwritten.extend(winner.overwritten.iter().copied());

        overwritten.extend(loser.overwritten.iter().copied());

        overwritten.insert(winner.rev);

        overwritten.insert(loser.rev);

        Self {

            rev,

            path: winner.path,

            overwritten: overwritten,

        }

    }

    /// Update the value of a pre-existing CopySource

    ///

    /// Use this when recording copy information from  parent → child edges

    fn overwrite(&mut self, rev: Revision, path: Option<PathToken>) {

        self.overwritten.insert(self.rev);

        self.rev = rev;

        self.path = path;

    }

    /// Mark pre-existing copy information as "dropped" by a file deletion

    ///

    /// Use this when recording copy information from  parent → child edges

    fn mark_delete(&mut self, rev: Revision) {

        self.overwritten.insert(self.rev);

        self.rev = rev;

        self.path = None;

    }

    /// Mark pre-existing copy information as "dropped" by a file deletion

    ///

    /// Use this when recording copy information from  parent → child edges

    fn mark_delete_with_pair(&mut self, rev: Revision, other: &Self) {

        self.overwritten.insert(self.rev);

        if other.rev != rev {

            self.overwritten.insert(other.rev);

        }

        self.overwritten.extend(other.overwritten.iter().copied());

        self.rev = rev;

        self.path = None;

    }

    fn is_overwritten_by(&self, other: &Self) -> bool {

        other.overwritten.contains(&self.rev)

    }

}

// For the same "dest", content generated for a given revision will always be

// the same.

impl PartialEq for CopySource {

    fn eq(&self, other: &Self) -> bool {

        #[cfg(debug_assertions)]

        {

            if self.rev == other.rev {

                debug_assert!(self.path == other.path);

                debug_assert!(self.overwritten == other.overwritten);

            }

        }

        self.rev == other.rev

    }

}

/// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)

type InternalPathCopies = OrdMap<PathToken, CopySource>;

/// represent the files affected by a changesets

///

/// This hold a subset of mercurial.metadata.ChangingFiles as we do not need

/// all the data categories tracked by it.

/// This hold a subset of mercurial.metadata.ChangingFiles as we do not need

/// all the data categories tracked by it.

pub struct ChangedFiles<'a> {

    nb_items: u32,

    index: &'a [u8],

    data: &'a [u8],

}

/// Represent active changes that affect the copy tracing.

enum Action<'a> {

    /// The parent ? children edge is removing a file

    ///

    /// (actually, this could be the edge from the other parent, but it does

    /// not matters)

    Removed(&'a HgPath),

    /// The parent ? children edge introduce copy information between (dest,

    /// source)

    CopiedFromP1(&'a HgPath, &'a HgPath),

    CopiedFromP2(&'a HgPath, &'a HgPath),

}

/// This express the possible "special" case we can get in a merge

///

/// See mercurial/metadata.py for details on these values.

#[derive(PartialEq)]

enum MergeCase {

    /// Merged: file had history on both side that needed to be merged

    Merged,

    /// Salvaged: file was candidate for deletion, but survived the merge

    Salvaged,

    /// Normal: Not one of the two cases above

    Normal,

}

type FileChange<'a> = (u8, &'a HgPath, &'a HgPath);

const EMPTY: &[u8] = b"";

const COPY_MASK: u8 = 3;

const P1_COPY: u8 = 2;

const P2_COPY: u8 = 3;

const ACTION_MASK: u8 = 28;

const REMOVED: u8 = 12;

const MERGED: u8 = 8;

const SALVAGED: u8 = 16;

impl<'a> ChangedFiles<'a> {

    const INDEX_START: usize = 4;

    const ENTRY_SIZE: u32 = 9;

    const FILENAME_START: u32 = 1;

    const COPY_SOURCE_START: u32 = 5;

    pub fn new(data: &'a [u8]) -> Self {

        assert!(

            data.len() >= 4,

            "data size ({}) is too small to contain the header (4)",

            data.len()

        );

        let nb_items_raw: [u8; 4] = (&data[0..=3])

            .try_into()

            .expect("failed to turn 4 bytes into 4 bytes");

        let nb_items = u32::from_be_bytes(nb_items_raw);

        let index_size = (nb_items * Self::ENTRY_SIZE) as usize;

        let index_end = Self::INDEX_START + index_size;

        assert!(

            data.len() >= index_end,

            "data size ({}) is too small to fit the index_data ({})",

            data.len(),

            index_end

        );

        let ret = ChangedFiles {

            nb_items,

            index: &data[Self::INDEX_START..index_end],

            data: &data[index_end..],

        };

        let max_data = ret.filename_end(nb_items - 1) as usize;

        assert!(

            ret.data.len() >= max_data,

            "data size ({}) is too small to fit all data ({})",

            data.len(),

            index_end + max_data

        );

        ret

    }

    pub fn new_empty() -> Self {

        ChangedFiles {

            nb_items: 0,

            index: EMPTY,

            data: EMPTY,

        }

    }

    /// internal function to return an individual entry at a given index

    fn entry(&'a self, idx: u32) -> FileChange<'a> {

        if idx >= self.nb_items {

            panic!(

                "index for entry is higher that the number of file {} >= {}",

                idx, self.nb_items

            )

        }

        let flags = self.flags(idx);

        let filename = self.filename(idx);

        let copy_idx = self.copy_idx(idx);

        let copy_source = self.filename(copy_idx);

        (flags, filename, copy_source)

    }

    /// internal function to return the filename of the entry at a given index

    fn filename(&self, idx: u32) -> &HgPath {

        let filename_start;

        if idx == 0 {

            filename_start = 0;

        } else {

            filename_start = self.filename_end(idx - 1)

        }

        let filename_end = self.filename_end(idx);

        let filename_start = filename_start as usize;

        let filename_end = filename_end as usize;

        HgPath::new(&self.data[filename_start..filename_end])

    }

    /// internal function to return the flag field of the entry at a given

    /// index

    fn flags(&self, idx: u32) -> u8 {

        let idx = idx as usize;

        self.index[idx * (Self::ENTRY_SIZE as usize)]

    }

    /// internal function to return the end of a filename part at a given index

    fn filename_end(&self, idx: u32) -> u32 {

        let start = (idx * Self::ENTRY_SIZE) + Self::FILENAME_START;

        let end = (idx * Self::ENTRY_SIZE) + Self::COPY_SOURCE_START;

        let start = start as usize;

        let end = end as usize;

        let raw = (&self.index[start..end])

            .try_into()

            .expect("failed to turn 4 bytes into 4 bytes");

        u32::from_be_bytes(raw)

    }

    /// internal function to return index of the copy source of the entry at a

    /// given index

    fn copy_idx(&self, idx: u32) -> u32 {

        let start = (idx * Self::ENTRY_SIZE) + Self::COPY_SOURCE_START;

        let end = (idx + 1) * Self::ENTRY_SIZE;

        let start = start as usize;

        let end = end as usize;

        let raw = (&self.index[start..end])

            .try_into()

            .expect("failed to turn 4 bytes into 4 bytes");

        u32::from_be_bytes(raw)

    }

    /// Return an iterator over all the `Action` in this instance.

    fn iter_actions(&self) -> ActionsIterator {

        ActionsIterator {

            changes: &self,

            current: 0,

        }

    }

    /// return the MergeCase value associated with a filename

    fn get_merge_case(&self, path: &HgPath) -> MergeCase {

        if self.nb_items == 0 {

            return MergeCase::Normal;

        }

        let mut low_part = 0;

        let mut high_part = self.nb_items;

        while low_part < high_part {

            let cursor = (low_part + high_part - 1) / 2;

            let (flags, filename, _source) = self.entry(cursor);

            match path.cmp(filename) {

                Ordering::Less => low_part = cursor + 1,

                Ordering::Greater => high_part = cursor,

                Ordering::Equal => {

                    return match flags & ACTION_MASK {

                        MERGED => MergeCase::Merged,

                        SALVAGED => MergeCase::Salvaged,

                        _ => MergeCase::Normal,

                    };

                }

            }

        }

        MergeCase::Normal

    }

}

struct ActionsIterator<'a> {

    changes: &'a ChangedFiles<'a>,

    current: u32,

}

impl<'a> Iterator for ActionsIterator<'a> {

    type Item = Action<'a>;

    fn next(&mut self) -> Option<Action<'a>> {

        while self.current < self.changes.nb_items {

            let (flags, file, source) = self.changes.entry(self.current);

            self.current += 1;

            if (flags & ACTION_MASK) == REMOVED {

                return Some(Action::Removed(file));

            }

            let copy = flags & COPY_MASK;

            if copy == P1_COPY {

                return Some(Action::CopiedFromP1(file, source));

            } else if copy == P2_COPY {

                return Some(Action::CopiedFromP2(file, source));

            }

        }

        return None;

    }

}

/// A small "tokenizer" responsible of turning full HgPath into lighter

/// PathToken

///

/// Dealing with small object, like integer is much faster, so HgPath input are

/// turned into integer "PathToken" and converted back in the end.

#[derive(Clone, Debug, Default)]

struct TwoWayPathMap {

    token: HashMap<HgPathBuf, PathToken>,

    path: Vec<HgPathBuf>,

}