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, STORED_NODE_ID_BYTES};

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

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

use crate::{Graph, GraphError, RevlogError, RevlogIndex, UncheckedRevision};

pub const INDEX_ENTRY_SIZE: usize = 64;

pub const COMPRESSION_MODE_INLINE: u8 = 2;

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

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

    /// 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 {

    pub fn new(bytes: Box<dyn Deref<Target = [u8]> + Send>) -> Self {

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

    }

}

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]

        }

    }

}

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,

}

#[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,

}

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]),

        }

    }

}

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>,

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

            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: IndexData::new(bytes),

                    offsets: RwLock::new(Some(offsets)),

                    uses_generaldelta,

                    is_inline: true,

                })

            } else {

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

            }

        } else {

            Ok(Self {

                bytes: IndexData::new(bytes),

                offsets: RwLock::new(None),

                uses_generaldelta,

                is_inline: false,

            })

        }

    }

    pub fn uses_generaldelta(&self) -> bool {

        self.uses_generaldelta

    }

    /// Value of the inline flag.

    pub fn is_inline(&self) -> bool {

        self.is_inline

    }

    /// 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.get_offsets() {

            offsets.len()

        } else {

            self.bytes.len() / INDEX_ENTRY_SIZE

        }

    }

    pub fn get_offsets(&self) -> RwLockReadGuard<Option<Vec<usize>>> {

        if self.is_inline() {