#![allow(clippy::type_complexity)] // Aha, Type Gymnastics!

use mingling_picker_macros::internal_repeat;

internal_repeat!(1..=32 => {
    #[doc(hidden)]
    pub struct PickerResult$<(T$,+), Route> {
        /// The route selected by the picker, if any.
        /// If this is `Some`, the picker chose to follow a route instead of selecting values,
        /// and all value fields (`v1`, `v2`, ...) will be `None`.
        ///
        /// Note: "route" here refers to an alternative path/choice, not a network route.
        pub route: Option<Route>,

        (
            #[doc = concat!("The optional value for the ", $, "th type parameter.")]
            pub v$: Option<T$>,
        +)
    }
});

internal_repeat!(1..=32 => {
    impl<(T$,+), Route> PickerResult$<(T$,+), Route> {
        /// Unwraps the result, panicking if a route was selected.
        ///
        /// # Panics
        ///
        /// Panics if `self.route` is `Some(...)`.
        pub fn unwrap(self) -> ((T$,+)) {
            ((self.v$.unwrap(),+))
        }

        /// Returns the individual option values without checking the route.
        pub fn unpack(self) -> ((Option<T$>,+)) {
            ((self.v$,+))
        }

        /// Converts to a `Result`, returning `Err(route)` if a route was selected,
        /// or `Ok(values)` otherwise.
        pub fn to_result(self) -> Result<((T$,+)), Route> {
            if let Some(r) = self.route {
                return Err(r);
            }
            Ok(self.unwrap())
        }

        /// Converts to an `Option`, returning `None` if a route was selected,
        /// or `Some(values)` otherwise.
        pub fn to_option(self) -> Option<((T$,+))> {
            if let Some(_) = self.route {
                return None;
            }
            Some(self.unwrap())
        }
    }
});