use std::collections::hash_map::RandomState;

use std::collections::{HashMap, HashSet};

use std::fmt::Debug;

use std::ops::Deref;

use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};

use byteorder::{BigEndian, ByteOrder};

use bytes_cast::{unaligned, BytesCast};

use super::REVIDX_KNOWN_FLAGS;

use crate::errors::HgError;

use crate::node::{NODE_BYTES_LENGTH, NULL_NODE, STORED_NODE_ID_BYTES};

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

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

use crate::{

    dagops, BaseRevision, FastHashMap, Graph, GraphError, RevlogError,

    RevlogIndex, UncheckedRevision,

};

pub const INDEX_ENTRY_SIZE: usize = 64;

pub const COMPRESSION_MODE_INLINE: u8 = 2;

#[derive(Debug)]

pub struct IndexHeader {

    pub(super) 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 {

        self.flags & 1 != 0

    }

    /// Corresponds to FLAG_GENERALDELTA in python

    pub fn uses_generaldelta(self) -> bool {

        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.

        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 {

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

    }

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

        if index_bytes.is_empty() {

            return Ok(None);

        }

        if index_bytes.len() < 4 {

            return Err(HgError::corrupted(

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

            ));

        }

        Ok(Some(IndexHeader {

            header_bytes: {

                let bytes: [u8; 4] =

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

                bytes

            },

        }))

    }

}

/// Abstracts the access to the index bytes since they can be spread between

/// the immutable (bytes) part and the mutable (added) part if any appends

/// happened. This makes it transparent for the callers.

struct IndexData {

    /// Immutable bytes, most likely taken from disk

    /// Used when stripping index contents, keeps track of the start of the

    /// first stripped revision, which is used to give a slice of the

    /// `bytes` field.

    truncation: Option<usize>,

    /// Bytes that were added after reading the index

    added: Vec<u8>,

}

impl IndexData {

        Self {

            bytes,

            truncation: None,

            added: vec![],

        }

    }

    pub fn len(&self) -> usize {

        match self.truncation {

            Some(truncation) => truncation + self.added.len(),

            None => self.bytes.len() + self.added.len(),

        }

    }

    fn remove(

        &mut self,

        rev: Revision,

        offsets: Option<&[usize]>,

    ) -> Result<(), RevlogError> {

        let rev = rev.0 as usize;

        let truncation = if let Some(offsets) = offsets {

            offsets[rev]

        } else {

            rev * INDEX_ENTRY_SIZE

        };

        if truncation < self.bytes.len() {

            self.truncation = Some(truncation);

            self.added.clear();

        } else {

            self.added.truncate(truncation - self.bytes.len());

        }

        Ok(())

    }

    fn is_new(&self) -> bool {

        self.bytes.is_empty()

    }

}

impl std::ops::Index<std::ops::Range<usize>> for IndexData {

    type Output = [u8];

    fn index(&self, index: std::ops::Range<usize>) -> &Self::Output {

        let start = index.start;

        let end = index.end;

        let immutable_len = match self.truncation {

            Some(truncation) => truncation,

            None => self.bytes.len(),

        };

        if start < immutable_len {

            if end > immutable_len {

                panic!("index data cannot span existing and added ranges");

            }

            &self.bytes[index]

        } else {

            &self.added[start - immutable_len..end - immutable_len]

        }

    }

}

#[derive(Debug, PartialEq, Eq)]

pub struct RevisionDataParams {

    pub flags: u16,

    pub data_offset: u64,

    pub data_compressed_length: i32,

    pub data_uncompressed_length: i32,

    pub data_delta_base: i32,

    pub link_rev: i32,

    pub parent_rev_1: i32,

    pub parent_rev_2: i32,

    pub node_id: [u8; NODE_BYTES_LENGTH],

    pub _sidedata_offset: u64,

    pub _sidedata_compressed_length: i32,

    pub data_compression_mode: u8,

    pub _sidedata_compression_mode: u8,

    pub _rank: i32,

}

impl Default for RevisionDataParams {

    fn default() -> Self {

        Self {

            flags: 0,

            data_offset: 0,

            data_compressed_length: 0,

            data_uncompressed_length: 0,

            data_delta_base: -1,

            link_rev: -1,

            parent_rev_1: -1,

            parent_rev_2: -1,

            node_id: [0; NODE_BYTES_LENGTH],

            _sidedata_offset: 0,

            _sidedata_compressed_length: 0,

            data_compression_mode: COMPRESSION_MODE_INLINE,

            _sidedata_compression_mode: COMPRESSION_MODE_INLINE,

            _rank: -1,

        }

    }

}

#[derive(BytesCast)]

#[repr(C)]

pub struct RevisionDataV1 {

    data_offset_or_flags: unaligned::U64Be,

    data_compressed_length: unaligned::I32Be,

    data_uncompressed_length: unaligned::I32Be,

    data_delta_base: unaligned::I32Be,

    link_rev: unaligned::I32Be,

    parent_rev_1: unaligned::I32Be,

    parent_rev_2: unaligned::I32Be,

    node_id: [u8; STORED_NODE_ID_BYTES],

}

fn _static_assert_size_of_revision_data_v1() {

    let _ = std::mem::transmute::<RevisionDataV1, [u8; 64]>;

}

impl RevisionDataParams {

    pub fn validate(&self) -> Result<(), RevlogError> {

        if self.flags & !REVIDX_KNOWN_FLAGS != 0 {

            return Err(RevlogError::corrupted(format!(

                "unknown revlog index flags: {}",

                self.flags

            )));

        }

        if self.data_compression_mode != COMPRESSION_MODE_INLINE {

            return Err(RevlogError::corrupted(format!(

                "invalid data compression mode: {}",

                self.data_compression_mode

            )));

        }

        // FIXME isn't this only for v2 or changelog v2?

        if self._sidedata_compression_mode != COMPRESSION_MODE_INLINE {

            return Err(RevlogError::corrupted(format!(

                "invalid sidedata compression mode: {}",

                self._sidedata_compression_mode

            )));

        }

        Ok(())

    }

    pub fn into_v1(self) -> RevisionDataV1 {

        let data_offset_or_flags = self.data_offset << 16 | self.flags as u64;

        let mut node_id = [0; STORED_NODE_ID_BYTES];

        node_id[..NODE_BYTES_LENGTH].copy_from_slice(&self.node_id);

        RevisionDataV1 {

            data_offset_or_flags: data_offset_or_flags.into(),

            data_compressed_length: self.data_compressed_length.into(),

            data_uncompressed_length: self.data_uncompressed_length.into(),

            data_delta_base: self.data_delta_base.into(),

            link_rev: self.link_rev.into(),

            parent_rev_1: self.parent_rev_1.into(),

            parent_rev_2: self.parent_rev_2.into(),

            node_id,

        }

    }

}

/// A Revlog index

pub struct Index {

    bytes: IndexData,

    /// Offsets of starts of index blocks.

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

    offsets: RwLock<Option<Vec<usize>>>,

    uses_generaldelta: bool,

    is_inline: bool,

    /// Cache of the head revisions in this index, kept in sync. Should

    /// be accessed via the [`Self::head_revs`] method.

    head_revs: Vec<Revision>,

    /// Cache of the last filtered revisions in this index, used to make sure

    /// we haven't changed filters when returning the cached `head_revs`.

    filtered_revs: HashSet<Revision>,

}

impl Debug for Index {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        f.debug_struct("Index")

            .field("offsets", &self.offsets)

            .field("uses_generaldelta", &self.uses_generaldelta)

            .finish()

    }

}

impl Graph for Index {

    fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {

        let err = || GraphError::ParentOutOfRange(rev);

        match self.get_entry(rev) {

            Some(entry) => {

                // The C implementation checks that the parents are valid

                // before returning

                Ok([

                    self.check_revision(entry.p1()).ok_or_else(err)?,

                    self.check_revision(entry.p2()).ok_or_else(err)?,

                ])

            }

            None => Ok([NULL_REVISION, NULL_REVISION]),

        }

    }

}

/// A cache suitable for find_snapshots

///

/// Logically equivalent to a mapping whose keys are [`BaseRevision`] and

/// values sets of [`BaseRevision`]

///

/// TODO the dubious part is insisting that errors must be RevlogError

/// we would probably need to sprinkle some magic here, such as an associated

/// type that would be Into<RevlogError> but even that would not be

/// satisfactory, as errors potentially have nothing to do with the revlog.

pub trait SnapshotsCache {

    fn insert_for(

        &mut self,

        rev: BaseRevision,

        value: BaseRevision,

    ) -> Result<(), RevlogError>;

}

impl SnapshotsCache for FastHashMap<BaseRevision, HashSet<BaseRevision>> {

    fn insert_for(

        &mut self,

        rev: BaseRevision,

        value: BaseRevision,

    ) -> Result<(), RevlogError> {

        let all_values = self.entry(rev).or_insert_with(HashSet::new);

        all_values.insert(value);

        Ok(())

    }

}

impl Index {

    /// Create an index from bytes.

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

    pub fn new(

        default_header: IndexHeader,

    ) -> Result<Self, HgError> {

        let header =

            IndexHeader::parse(bytes.as_ref())?.unwrap_or(default_header);

        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() {