//! Types and code to map circuit IDs to circuits.

// NOTE: This is a work in progress and I bet I'll refactor it a lot;

// it needs to stay opaque!

use crate::{Error, Result};

use tor_basic_utils::RngExt;

use tor_cell::chancell::CircId;

use crate::tunnel::circuit::halfcirc::HalfCirc;

use crate::tunnel::circuit::{celltypes::CreateResponse, CircuitRxSender};

use oneshot_fused_workaround as oneshot;

use rand::distr::Distribution;

use rand::Rng;

use std::collections::{hash_map::Entry, HashMap};

use std::ops::{Deref, DerefMut};

/// Which group of circuit IDs are we allowed to allocate in this map?

///

/// If we initiated the channel, we use High circuit ids.  If we're the

/// responder, we use low circuit ids.

#[derive(Copy, Clone)]

pub(super) enum CircIdRange {

    /// Only use circuit IDs with the MSB cleared.

    #[allow(dead_code)] // Relays will need this.

    Low,

    /// Only use circuit IDs with the MSB set.

    High,

    // Historical note: There used to be an "All" range of circuit IDs

    // available to clients only.  We stopped using "All" when we moved to link

    // protocol version 4.

}

impl rand::distr::Distribution<CircId> for CircIdRange {

    /// Return a random circuit ID in the appropriate range.

            // 0 is an invalid value

        };

}

/// An entry in the circuit map.  Right now, we only have "here's the

/// way to send cells to a given circuit", but that's likely to

/// change.

#[derive(Debug)]

pub(super) enum CircEnt {

    /// A circuit that has not yet received a CREATED cell.

    ///

    /// For this circuit, the CREATED* cell or DESTROY cell gets sent

    /// to the oneshot sender to tell the corresponding

    /// PendingClientCirc that the handshake is done.

    ///

    /// Once that's done, the `CircuitRxSender` mpsc sender will be used to send subsequent

    /// cells to the circuit.

    Opening(oneshot::Sender<CreateResponse>, CircuitRxSender),

    /// A circuit that is open and can be given relay cells.

    Open(CircuitRxSender),

    /// A circuit where we have sent a DESTROY, but the other end might

    /// not have gotten a DESTROY yet.

    DestroySent(HalfCirc),

}

/// An "smart pointer" that wraps an exclusive reference

/// of a `CircEnt`.

///

/// When being dropped, this object updates the open or opening entries

/// counter of the `CircMap`.

pub(super) struct MutCircEnt<'a> {

    /// An exclusive reference to the `CircEnt`.

    value: &'a mut CircEnt,

    /// An exclusive reference to the open or opening

    ///  entries counter.

    open_count: &'a mut usize,

    /// True if the entry was open or opening when borrowed.

    was_open: bool,

}

impl<'a> Drop for MutCircEnt<'a> {

        };

}

impl<'a> Deref for MutCircEnt<'a> {

    type Target = CircEnt;

}

impl<'a> DerefMut for MutCircEnt<'a> {

}

/// A map from circuit IDs to circuit entries. Each channel has one.

pub(super) struct CircMap {

    /// Map from circuit IDs to entries

    m: HashMap<CircId, CircEnt>,

    /// Rule for allocating new circuit IDs.

    range: CircIdRange,

    /// Number of open or opening entry in this map.

    open_count: usize,

}

impl CircMap {

    /// Make a new empty CircMap

    /// Add a new pair of elements (corresponding to a PendingClientCirc)

    /// to this map.

    ///

    /// On success return the allocated circuit ID.

        /// How many times do we probe for a random circuit ID before

        /// we assume that the range is fully populated?

        ///

        /// TODO: C tor does 64, but that is probably overkill with 4-byte circuit IDs.

        const N_ATTEMPTS: usize = 16;

        }

    /// Testing only: install an entry in this circuit map without regard

    /// for consistency.

    #[cfg(test)]

    /// Return the entry for `id` in this map, if any.

    /// See whether 'id' is an opening circuit.  If so, mark it "open" and

    /// return a oneshot::Sender that is waiting for its create cell.

        // TODO: there should be a better way to do

        // this. hash_map::Entry seems like it could be better, but

        // there seems to be no way to replace the object in-place as

        // a consuming function of itself.

            } else {

            }

        } else {

        }

    /// Called when we have sent a DESTROY on a circuit.  Configures

    /// a "HalfCirc" object to track how many cells we get on this

    /// circuit, and to prevent us from reusing it immediately.

    /// Extract the value from this map with 'id' if any

    /// Return the total number of open and opening entries in the map

    // TODO: Eventually if we want relay support, we'll need to support

    // circuit IDs chosen by somebody else. But for now, we don't need those.

}

#[cfg(test)]

mod test {

    // @@ begin test lint list maintained by maint/add_warning @@

    #![allow(clippy::bool_assert_comparison)]

    #![allow(clippy::clone_on_copy)]

    #![allow(clippy::dbg_macro)]

    #![allow(clippy::mixed_attributes_style)]

    #![allow(clippy::print_stderr)]

    #![allow(clippy::print_stdout)]

    #![allow(clippy::single_char_pattern)]

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unchecked_duration_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

    //! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

    use super::*;

    use crate::fake_mpsc;

    use tor_basic_utils::test_rng::testing_rng;

    #[test]

    fn circmap_basics() {

        let mut map_low = CircMap::new(CircIdRange::Low);

        let mut map_high = CircMap::new(CircIdRange::High);

        let mut ids_low: Vec<CircId> = Vec::new();

        let mut ids_high: Vec<CircId> = Vec::new();

        let mut rng = testing_rng();

        assert!(map_low.get_mut(CircId::new(77).unwrap()).is_none());

        for _ in 0..128 {

            let (csnd, _) = oneshot::channel();

            let (snd, _) = fake_mpsc(8);

            let id_low = map_low.add_ent(&mut rng, csnd, snd).unwrap();

            assert!(u32::from(id_low) > 0);

            assert!(u32::from(id_low) < 0x80000000);

            assert!(!ids_low.contains(&id_low));

            ids_low.push(id_low);

            assert!(matches!(

                *map_low.get_mut(id_low).unwrap(),

                CircEnt::Opening(_, _)

            ));

            let (csnd, _) = oneshot::channel();

            let (snd, _) = fake_mpsc(8);

            let id_high = map_high.add_ent(&mut rng, csnd, snd).unwrap();

            assert!(u32::from(id_high) >= 0x80000000);

            assert!(!ids_high.contains(&id_high));

            ids_high.push(id_high);

        }

        // Test open / opening entry counting

        assert_eq!(128, map_low.open_ent_count());

        assert_eq!(128, map_high.open_ent_count());

        // Test remove

        assert!(map_low.get_mut(ids_low[0]).is_some());

        map_low.remove(ids_low[0]);

        assert!(map_low.get_mut(ids_low[0]).is_none());

        assert_eq!(127, map_low.open_ent_count());

        // Test DestroySent doesn't count

        map_low.destroy_sent(CircId::new(256).unwrap(), HalfCirc::new(1));

        assert_eq!(127, map_low.open_ent_count());

        // Test advance_from_opening.

        // Good case.

        assert!(map_high.get_mut(ids_high[0]).is_some());

        assert!(matches!(

            *map_high.get_mut(ids_high[0]).unwrap(),

            CircEnt::Opening(_, _)

        ));

        let adv = map_high.advance_from_opening(ids_high[0]);

        assert!(adv.is_ok());

        assert!(matches!(

            *map_high.get_mut(ids_high[0]).unwrap(),

            CircEnt::Open(_)

        ));

        // Can't double-advance.

        let adv = map_high.advance_from_opening(ids_high[0]);

        assert!(adv.is_err());

        // Can't advance an entry that is not there.  We know "77"

        // can't be in map_high, since we only added high circids to

        // it.

        let adv = map_high.advance_from_opening(CircId::new(77).unwrap());

        assert!(adv.is_err());

    }

}