use pyo3::prelude::*;

use pyo3::types::{PyList, PySet};

use hg::revlog::RevlogIndex;

use hg::{BaseRevision, Revision, UncheckedRevision};

use crate::exceptions::{rev_not_in_index, GraphError};

use crate::utils::proxy_index_extract;

/// Revision as exposed to/from the Python layer.

///

/// We need this indirection because of the orphan rule, meaning we can't

/// implement a foreign trait (like [`cpython::ToPyObject`])

/// for a foreign type (like [`hg::UncheckedRevision`]).

///

/// This also acts as a deterrent against blindly trusting Python to send

/// us valid revision numbers.

#[derive(

    Debug,

    Copy,

    Clone,

    PartialEq,

    Eq,

    PartialOrd,

    Ord,

    Hash,

    derive_more::From,

    IntoPyObject,

    FromPyObject,

)]

pub struct PyRevision(pub BaseRevision);

impl From<Revision> for PyRevision {

    fn from(r: Revision) -> Self {

        PyRevision(r.0)

    }

}

impl From<PyRevision> for UncheckedRevision {

    fn from(val: PyRevision) -> Self {

        val.0.into()

    }

}

pub fn check_revision(

    index: &impl RevlogIndex,

    rev: impl Into<UncheckedRevision>,

) -> PyResult<Revision> {

    let rev = rev.into();

    index

        .check_revision(rev)

        .ok_or_else(|| rev_not_in_index(rev))

}

/// Utility function to convert a Python iterable into various collections

///

/// We need this in particular

/// - because of the checked upgrade from [`PyRevision`] to [`Revision`].

/// - to feed to various methods of inner objects with `impl

///   IntoIterator<Item=Revision>` arguments, because a `PyErr` can arise at

///   each step of iteration, whereas these methods expect iterables over

///   `Revision`, not over some `Result<Revision, PyErr>`

pub fn rev_pyiter_collect<C, I>(

    revs: &Bound<'_, PyAny>,

    index: &I,

) -> PyResult<C>

where

    C: FromIterator<Revision>,

    I: RevlogIndex,

{

    rev_pyiter_collect_or_else(revs, index, |r| {

        PyErr::new::<GraphError, _>(("InvalidRevision", r.0))

    })

}

pub fn rev_pyiter_collect_with_py_index<C>(

    revs: &Bound<'_, PyAny>,

    proxy_index: &Bound<'_, PyAny>,

) -> PyResult<C>

where

    C: FromIterator<Revision>,

{

    // Safety: we don't leak the "faked" reference out of `UnsafePyLeaked`

    let borrowed_idx = unsafe { proxy_index_extract(proxy_index)? };

    rev_pyiter_collect(revs, borrowed_idx)

}

/// Same as [`rev_pyiter_collect`], giving control on returned errors

pub fn rev_pyiter_collect_or_else<C, I>(

    revs: &Bound<'_, PyAny>,

    index: &I,

    invalid_rev_error: impl FnOnce(PyRevision) -> PyErr + Copy,

) -> PyResult<C>

where

    C: FromIterator<Revision>,

    I: RevlogIndex,

{

    revs.try_iter()?

        .map(|r| {

            r.and_then(|o| match o.extract::<PyRevision>() {

                Ok(r) => index

                    .check_revision(UncheckedRevision(r.0))

                    .ok_or_else(|| invalid_rev_error(r)),

                Err(e) => Err(e),

            })

        })

        .collect()

}

pub fn revs_py_list<U>(

    py: Python<'_>,

    revs: impl IntoIterator<Item = Revision, IntoIter = U>,

) -> PyResult<Py<PyList>>

where

    U: ExactSizeIterator<Item = Revision>,

{

    Ok(PyList::new(py, revs.into_iter().map(PyRevision::from))?.unbind())

}

pub fn revs_py_set<U>(

    py: Python<'_>,

    revs: impl IntoIterator<Item = Revision, IntoIter = U>,

) -> PyResult<Py<PySet>>

where

    U: ExactSizeIterator<Item = Revision>,

{

    Ok(PySet::new(py, revs.into_iter().map(PyRevision::from))?.unbind())

}