use std::convert::TryInto;

use std::ops::Deref;

use byteorder::{BigEndian, ByteOrder};

use crate::errors::HgError;

use crate::revlog::node::Node;

use crate::revlog::{Revision, NULL_REVISION};

pub const INDEX_ENTRY_SIZE: usize = 64;

pub struct IndexHeader {

    header_bytes: [u8; 4],

}

#[derive(Copy, Clone)]

pub struct IndexHeaderFlags {

    flags: u16,

}

/// Corresponds to the high bits of `_format_flags` in python

impl IndexHeaderFlags {

    /// Corresponds to FLAG_INLINE_DATA in python

    pub fn is_inline(self) -> bool {

        return self.flags & 1 != 0;

    }

    /// Corresponds to FLAG_GENERALDELTA in python

    pub fn uses_generaldelta(self) -> bool {

        return self.flags & 2 != 0;

    }

}

/// Corresponds to the INDEX_HEADER structure,

/// which is parsed as a `header` variable in `_loadindex` in `revlog.py`

impl IndexHeader {

    fn format_flags(&self) -> IndexHeaderFlags {

        // No "unknown flags" check here, unlike in python. Maybe there should

        // be.

        return IndexHeaderFlags {

            flags: BigEndian::read_u16(&self.header_bytes[0..2]),

        };

    }

    /// The only revlog version currently supported by rhg.

    const REVLOGV1: u16 = 1;

    /// Corresponds to `_format_version` in Python.

    fn format_version(&self) -> u16 {

        return BigEndian::read_u16(&self.header_bytes[2..4]);

    }

    const EMPTY_INDEX_HEADER: IndexHeader = IndexHeader {

        // We treat an empty file as a valid index with no entries.

        // Here we make an arbitrary choice of what we assume the format of the

        // index to be (V1, using generaldelta).

        // This doesn't matter too much, since we're only doing read-only

        // access. but the value corresponds to the `new_header` variable in

        // `revlog.py`, `_loadindex`

        header_bytes: [0, 3, 0, 1],

    };

    fn parse(index_bytes: &[u8]) -> Result<IndexHeader, HgError> {

        if index_bytes.len() == 0 {

            return Ok(IndexHeader::EMPTY_INDEX_HEADER);

        }

        if index_bytes.len() < 4 {

            return Err(HgError::corrupted(

                "corrupted revlog: can't read the index format header",

            ));

        }

        return Ok(IndexHeader {

            header_bytes: {

                let bytes: [u8; 4] =

                    index_bytes[0..4].try_into().expect("impossible");

                bytes

            },

        });

    }

}

/// A Revlog index

pub struct Index {

    bytes: Box<dyn Deref<Target = [u8]> + Send>,

    /// Offsets of starts of index blocks.

    /// Only needed when the index is interleaved with data.

    offsets: Option<Vec<usize>>,

    uses_generaldelta: bool,

}

impl Index {

    /// Create an index from bytes.

    /// Calculate the start of each entry when is_inline is true.

    pub fn new(

        bytes: Box<dyn Deref<Target = [u8]> + Send>,

    ) -> Result<Self, HgError> {

        let header = IndexHeader::parse(bytes.as_ref())?;

        if header.format_version() != IndexHeader::REVLOGV1 {

            // A proper new version should have had a repo/store

            // requirement.

            return Err(HgError::corrupted("unsupported revlog version"));

        }

        // This is only correct because we know version is REVLOGV1.

        // In v2 we always use generaldelta, while in v0 we never use

        // generaldelta. Similar for [is_inline] (it's only used in v1).

        let uses_generaldelta = header.format_flags().uses_generaldelta();

        if header.format_flags().is_inline() {

            let mut offset: usize = 0;

            let mut offsets = Vec::new();

            while offset + INDEX_ENTRY_SIZE <= bytes.len() {

                offsets.push(offset);

                let end = offset + INDEX_ENTRY_SIZE;

                let entry = IndexEntry {

                    bytes: &bytes[offset..end],

                    offset_override: None,

                };

                offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;

            }

            if offset == bytes.len() {

                Ok(Self {

                    bytes,

                    offsets: Some(offsets),

                    uses_generaldelta,

                })

            } else {

                Err(HgError::corrupted("unexpected inline revlog length")

                    .into())

            }

        } else {

            Ok(Self {

                bytes,

                offsets: None,

                uses_generaldelta,

            })

        }

    }

    pub fn uses_generaldelta(&self) -> bool {

        self.uses_generaldelta

    }

    /// Value of the inline flag.

    pub fn is_inline(&self) -> bool {

        self.offsets.is_some()

    }

    /// Return a slice of bytes if `revlog` is inline. Panic if not.

    pub fn data(&self, start: usize, end: usize) -> &[u8] {

        if !self.is_inline() {

            panic!("tried to access data in the index of a revlog that is not inline");

        }

        &self.bytes[start..end]

    }

    /// Return number of entries of the revlog index.

    pub fn len(&self) -> usize {

        if let Some(offsets) = &self.offsets {

            offsets.len()

        } else {

            self.bytes.len() / INDEX_ENTRY_SIZE

        }

    }

    /// Returns `true` if the `Index` has zero `entries`.

    pub fn is_empty(&self) -> bool {

        self.len() == 0

    }

    /// Return the index entry corresponding to the given revision if it

    /// exists.

    pub fn get_entry(&self, rev: Revision) -> Option<IndexEntry> {

        if rev == NULL_REVISION {

            return None;

        }

        if let Some(offsets) = &self.offsets {

            self.get_entry_inline(rev, offsets)

        } else {

            self.get_entry_separated(rev)

        }

    }

    fn get_entry_inline(

        &self,

        rev: Revision,

        offsets: &[usize],

    ) -> Option<IndexEntry> {

        let start = *offsets.get(rev as usize)?;

        let end = start.checked_add(INDEX_ENTRY_SIZE)?;

        let bytes = &self.bytes[start..end];

        // See IndexEntry for an explanation of this override.

        let offset_override = Some(end);

        Some(IndexEntry {

            bytes,

            offset_override,

        })

    }

    fn get_entry_separated(&self, rev: Revision) -> Option<IndexEntry> {

        let max_rev = self.bytes.len() / INDEX_ENTRY_SIZE;

        if rev as usize >= max_rev {

            return None;

        }

        let start = rev as usize * INDEX_ENTRY_SIZE;

        let end = start + INDEX_ENTRY_SIZE;

        let bytes = &self.bytes[start..end];

        // Override the offset of the first revision as its bytes are used

        // for the index's metadata (saving space because it is always 0)

        let offset_override = if rev == 0 { Some(0) } else { None };

        Some(IndexEntry {

            bytes,

            offset_override,

        })

    }

}

impl super::RevlogIndex for Index {

    fn len(&self) -> usize {

        self.len()

    }

    fn node(&self, rev: Revision) -> Option<&Node> {

        self.get_entry(rev).map(|entry| entry.hash())

    }

}

#[derive(Debug)]

pub struct IndexEntry<'a> {

    bytes: &'a [u8],

    /// Allows to override the offset value of the entry.

    ///

    /// For interleaved index and data, the offset stored in the index

    /// corresponds to the separated data offset.

    /// It has to be overridden with the actual offset in the interleaved

    /// index which is just after the index block.

    ///

    /// For separated index and data, the offset stored in the first index

    /// entry is mixed with the index headers.

    /// It has to be overridden with 0.

    offset_override: Option<usize>,

}

impl<'a> IndexEntry<'a> {

    /// Return the offset of the data.

    pub fn offset(&self) -> usize {

        if let Some(offset_override) = self.offset_override {

            offset_override

        } else {

            let mut bytes = [0; 8];

            bytes[2..8].copy_from_slice(&self.bytes[0..=5]);

            BigEndian::read_u64(&bytes[..]) as usize

        }

    }

    /// Return the compressed length of the data.

    pub fn compressed_len(&self) -> u32 {

        BigEndian::read_u32(&self.bytes[8..=11])

    }

    /// Return the uncompressed length of the data.

    pub fn uncompressed_len(&self) -> i32 {

        BigEndian::read_i32(&self.bytes[12..=15])

    }

    /// Return the revision upon which the data has been derived.

    pub fn base_revision_or_base_of_delta_chain(&self) -> Revision {

        // TODO Maybe return an Option when base_revision == rev?

        //      Requires to add rev to IndexEntry

        BigEndian::read_i32(&self.bytes[16..])

    }

    pub fn p1(&self) -> Revision {

        BigEndian::read_i32(&self.bytes[24..])

    }

    pub fn p2(&self) -> Revision {

        BigEndian::read_i32(&self.bytes[28..])

    }

    /// Return the hash of revision's full text.

    ///

    /// Currently, SHA-1 is used and only the first 20 bytes of this field

    /// are used.

    pub fn hash(&self) -> &'a Node {

        (&self.bytes[32..52]).try_into().unwrap()

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[cfg(test)]

    #[derive(Debug, Copy, Clone)]

    pub struct IndexEntryBuilder {

        is_first: bool,

        is_inline: bool,

        is_general_delta: bool,

        version: u16,

        offset: usize,

        compressed_len: usize,

        uncompressed_len: usize,

        base_revision_or_base_of_delta_chain: Revision,

    }

    #[cfg(test)]

    impl IndexEntryBuilder {

        pub fn new() -> Self {

            Self {

                is_first: false,

                is_inline: false,

                is_general_delta: true,

                version: 2,

                offset: 0,

                compressed_len: 0,

                uncompressed_len: 0,

                base_revision_or_base_of_delta_chain: 0,

            }

        }

        pub fn is_first(&mut self, value: bool) -> &mut Self {

            self.is_first = value;

            self

        }

        pub fn with_inline(&mut self, value: bool) -> &mut Self {

            self.is_inline = value;

            self

        }

        pub fn with_general_delta(&mut self, value: bool) -> &mut Self {

            self.is_general_delta = value;

            self

        }

        pub fn with_version(&mut self, value: u16) -> &mut Self {

            self.version = value;

            self

        }

        pub fn with_offset(&mut self, value: usize) -> &mut Self {

            self.offset = value;

            self

        }

        pub fn with_compressed_len(&mut self, value: usize) -> &mut Self {

            self.compressed_len = value;

            self