// dirstate_map.rs

//

// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>

//

// This software may be used and distributed according to the terms of the

// GNU General Public License version 2 or any later version.

//! Bindings for the `hg::dirstate::dirstate_map` file provided by the

//! `hg-core` package.

use std::cell::{RefCell, RefMut};

use std::convert::TryInto;

use cpython::{

    exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,

    PyNone, PyObject, PyResult, PySet, PyString, Python, PythonObject,

    ToPyObject, UnsafePyLeaked,

};

use crate::{

    dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},

    dirstate::item::DirstateItem,

    dirstate::non_normal_entries::{

        NonNormalEntries, NonNormalEntriesIterator,

    },

    pybytes_deref::PyBytesDeref,

};

use hg::{

    dirstate::parsers::Timestamp,

    dirstate::MTIME_UNSET,

    dirstate::SIZE_NON_NORMAL,

    dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap,

    dirstate_tree::dispatch::DirstateMapMethods,

    dirstate_tree::on_disk::DirstateV2ParseError,

    dirstate_tree::owning::OwningDirstateMap,

    revlog::Node,

    utils::files::normalize_case,

    utils::hg_path::{HgPath, HgPathBuf},

    DirstateEntry, DirstateError, DirstateMap as RustDirstateMap,

    DirstateParents, EntryState, StateMapIter,

};

// TODO

//     This object needs to share references to multiple members of its Rust

//     inner struct, namely `copy_map`, `dirs` and `all_dirs`.

//     Right now `CopyMap` is done, but it needs to have an explicit reference

//     to `RustDirstateMap` which itself needs to have an encapsulation for

//     every method in `CopyMap` (copymapcopy, etc.).

//     This is ugly and hard to maintain.

//     The same logic applies to `dirs` and `all_dirs`, however the `Dirs`

//     `py_class!` is already implemented and does not mention

//     `RustDirstateMap`, rightfully so.

//     All attributes also have to have a separate refcount data attribute for

//     leaks, with all methods that go along for reference sharing.

py_class!(pub class DirstateMap |py| {

    @shared data inner: Box<dyn DirstateMapMethods + Send>;

    /// Returns a `(dirstate_map, parents)` tuple

    @staticmethod

    def new_v1(

        use_dirstate_tree: bool,

        on_disk: PyBytes,

    ) -> PyResult<PyObject> {

        let (inner, parents) = if use_dirstate_tree {

            let on_disk = PyBytesDeref::new(py, on_disk);

            let mut map = OwningDirstateMap::new_empty(on_disk);

            let (on_disk, map_placeholder) = map.get_mut_pair();

            let (actual_map, parents) = TreeDirstateMap::new_v1(on_disk)

                .map_err(|e| dirstate_error(py, e))?;

            *map_placeholder = actual_map;

            (Box::new(map) as _, parents)

        } else {

            let bytes = on_disk.data(py);

            let mut map = RustDirstateMap::default();

            let parents = map.read(bytes).map_err(|e| dirstate_error(py, e))?;

            (Box::new(map) as _, parents)

        };

        let map = Self::create_instance(py, inner)?;

        let parents = parents.map(|p| {

            let p1 = PyBytes::new(py, p.p1.as_bytes());

            let p2 = PyBytes::new(py, p.p2.as_bytes());

            (p1, p2)

        });

        Ok((map, parents).to_py_object(py).into_object())

    }

    /// Returns a DirstateMap

    @staticmethod

    def new_v2(

        on_disk: PyBytes,

        data_size: usize,

        tree_metadata: PyBytes,

    ) -> PyResult<PyObject> {

        let dirstate_error = |e: DirstateError| {

            PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))

        };

        let on_disk = PyBytesDeref::new(py, on_disk);

        let mut map = OwningDirstateMap::new_empty(on_disk);

        let (on_disk, map_placeholder) = map.get_mut_pair();

        *map_placeholder = TreeDirstateMap::new_v2(

            on_disk, data_size, tree_metadata.data(py),

        ).map_err(dirstate_error)?;

        let map = Self::create_instance(py, Box::new(map))?;

        Ok(map.into_object())

    }

    def clear(&self) -> PyResult<PyObject> {

        self.inner(py).borrow_mut().clear();

        Ok(py.None())

    }

    def get(

        &self,

        key: PyObject,

        default: Option<PyObject> = None

    ) -> PyResult<Option<PyObject>> {

        let key = key.extract::<PyBytes>(py)?;

        match self

            .inner(py)

            .borrow()

            .get(HgPath::new(key.data(py)))

            .map_err(|e| v2_error(py, e))?

        {

            Some(entry) => {

                Ok(Some(DirstateItem::new_as_pyobject(py, entry)?))

            },

            None => Ok(default)

        }

    }

    def set_dirstate_item(

        &self,

        path: PyObject,

        item: DirstateItem

    ) -> PyResult<PyObject> {

        let f = path.extract::<PyBytes>(py)?;

        let filename = HgPath::new(f.data(py));

        self.inner(py)

            .borrow_mut()

            .set_entry(filename, item.get_entry(py))

            .map_err(|e| v2_error(py, e))?;

        Ok(py.None())

    }

    def addfile(

        &self,

        f: PyObject,

        mode: PyObject,

        size: PyObject,

        mtime: PyObject,

        added: PyObject,

        merged: PyObject,

        from_p2: PyObject,

        possibly_dirty: PyObject,

    ) -> PyResult<PyObject> {

        let f = f.extract::<PyBytes>(py)?;

        let filename = HgPath::new(f.data(py));

        let mode = if mode.is_none(py) {

            // fallback default value

            0

        } else {

            mode.extract(py)?

        };

        let size = if size.is_none(py) {

            // fallback default value

            SIZE_NON_NORMAL

        } else {

            size.extract(py)?

        };

        let mtime = if mtime.is_none(py) {

            // fallback default value

            MTIME_UNSET

        } else {

            mtime.extract(py)?

        };

        let entry = DirstateEntry::new_for_add_file(mode, size, mtime);

        let added = added.extract::<PyBool>(py)?.is_true();

        let merged = merged.extract::<PyBool>(py)?.is_true();

        let from_p2 = from_p2.extract::<PyBool>(py)?.is_true();

        let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true();

        self.inner(py).borrow_mut().add_file(

            filename,

            entry,

            added,

            merged,

            from_p2,

            possibly_dirty

        ).and(Ok(py.None())).or_else(|e: DirstateError| {

            Err(PyErr::new::<exc::ValueError, _>(py, e.to_string()))

        })

    }

    def removefile(

        &self,

        f: PyObject,

        in_merge: PyObject

    ) -> PyResult<PyObject> {

        self.inner(py).borrow_mut()

            .remove_file(

                HgPath::new(f.extract::<PyBytes>(py)?.data(py)),

                in_merge.extract::<PyBool>(py)?.is_true(),

            )

            .or_else(|_| {

                Err(PyErr::new::<exc::OSError, _>(

                    py,

                    "Dirstate error".to_string(),

                ))

            })?;

        Ok(py.None())

    }

        &self,

        f: PyBytes,

    ) -> PyResult<PyNone> {

        self.inner(py)

            .borrow_mut()

            .map_err(|e |dirstate_error(py, e))?;

        Ok(PyNone)

    }

    def clearambiguoustimes(

        &self,

        files: PyObject,

        now: PyObject

    ) -> PyResult<PyObject> {

        let files: PyResult<Vec<HgPathBuf>> = files

            .iter(py)?

            .map(|filename| {

                Ok(HgPathBuf::from_bytes(

                    filename?.extract::<PyBytes>(py)?.data(py),

                ))

            })

            .collect();

        self.inner(py)

            .borrow_mut()

            .clear_ambiguous_times(files?, now.extract(py)?)

            .map_err(|e| v2_error(py, e))?;

        Ok(py.None())

    }

    def other_parent_entries(&self) -> PyResult<PyObject> {

        let mut inner_shared = self.inner(py).borrow_mut();

        let set = PySet::empty(py)?;

        for path in inner_shared.iter_other_parent_paths() {

            let path = path.map_err(|e| v2_error(py, e))?;

            set.add(py, PyBytes::new(py, path.as_bytes()))?;

        }

        Ok(set.into_object())

    }

    def non_normal_entries(&self) -> PyResult<NonNormalEntries> {

        NonNormalEntries::from_inner(py, self.clone_ref(py))

    }

    def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {

        let key = key.extract::<PyBytes>(py)?;

        self.inner(py)

            .borrow_mut()

            .non_normal_entries_contains(HgPath::new(key.data(py)))

            .map_err(|e| v2_error(py, e))

    }

    def non_normal_entries_display(&self) -> PyResult<PyString> {

        let mut inner = self.inner(py).borrow_mut();

        let paths = inner

            .iter_non_normal_paths()

            .collect::<Result<Vec<_>, _>>()

            .map_err(|e| v2_error(py, e))?;

        let formatted = format!("NonNormalEntries: {}", hg::utils::join_display(paths, ", "));

        Ok(PyString::new(py, &formatted))

    }

    def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {

        let key = key.extract::<PyBytes>(py)?;

        let key = key.data(py);

        let was_present = self

            .inner(py)

            .borrow_mut()

            .non_normal_entries_remove(HgPath::new(key));

        if !was_present {

            let msg = String::from_utf8_lossy(key);

            Err(PyErr::new::<exc::KeyError, _>(py, msg))

        } else {

            Ok(py.None())

        }

    }

    def non_normal_entries_discard(&self, key: PyObject) -> PyResult<PyObject>

    {

        let key = key.extract::<PyBytes>(py)?;

        self

            .inner(py)

            .borrow_mut()

            .non_normal_entries_remove(HgPath::new(key.data(py)));

        Ok(py.None())

    }

    def non_normal_entries_add(&self, key: PyObject) -> PyResult<PyObject> {

        let key = key.extract::<PyBytes>(py)?;

        self

            .inner(py)

            .borrow_mut()

            .non_normal_entries_add(HgPath::new(key.data(py)));

        Ok(py.None())

    }

    def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> {

        let mut inner = self.inner(py).borrow_mut();

        let ret = PyList::new(py, &[]);

        for filename in inner.non_normal_or_other_parent_paths() {

            let filename = filename.map_err(|e| v2_error(py, e))?;

            let as_pystring = PyBytes::new(py, filename.as_bytes());

            ret.append(py, as_pystring.into_object());

        }

        Ok(ret)

    }

    def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> {

        // Make sure the sets are defined before we no longer have a mutable