use std::{

    any::{Any, TypeId},

    cmp::Ordering,

    fmt::{Debug, Display},

    hash::Hasher,

    sync::Arc,

};

use crate::{symbol::Symbol, FaultKind, PoppedValues, Value, ValueKind};

/// A type that can be used in the virtual machine using [`Value::dynamic`].

pub trait DynamicValue: Send + Sync + Debug + 'static {

    /// Returns true if the value contained is truthy. See

    /// [`Value::is_truthy()`] for examples of what this means for primitive

    /// types.

    fn is_truthy(&self) -> bool;

    /// Returns a unique string identifying this type. This returned string will

    /// be wrapped in [`ValueKind::Dynamic`] when [`Value::kind()`] is invoked

    /// on a dynamic value.

    ///

    /// This value does not influence the virtual machine's behavior. The

    /// virtual machine uses this string only when creating error messages.

    fn kind(&self) -> Symbol;

    /// Returns this value as an `i64`, if possible.

    ///

    /// Implementhing this function enables this type to be used in integer

    /// operations such as bitwise operations.

    #[must_use]

    /// Converts this value to the given kind, if possible.

    ///

    /// If this function returns None, the virtual machine will return a fault

    /// from the conversion operation.

    #[must_use]

    #[allow(unused_variables)]

    /// Returns true if self and other are considered equal. Returns false if

    /// self and other are able to be compared but are not equal. Returns None

    /// if the values are unable to be compared.

    ///

    /// When evaluating `left = right` with dynamic values, if

    /// `left.partial_eq(right)` returns None, `right.partial_eq(left)` will be

    /// attempted before returning false.

    #[allow(unused_variables)]

    /// Returns the relative ordering of `self` and `other`, if a comparison is

    /// able to be made. If the types cannot be compared, this function should

    /// return None.

    ///

    /// When evaluating a comparison such as `left < right` with dynamic values,

    /// if `left.partial_cmp(right)` returns None,

    /// `right.partial_cmp(left).map(Ordering::reverse)` will be attempted

    /// before returning false.

    #[allow(unused_variables)]

    /// Attempts to compute the result adding self and other.

    ///

    /// While addition is normally an associative operation, `is_reverse` allows

    /// determining if `self` is the left operand or the right operand to the

    /// operation.

    ///

    /// If `is_reverse` is false, the operation being requested is `self` +

    /// `other`. If `is_reverse` is true, the operation being requested is

    /// `other` + `self`.

    #[allow(unused_variables)]

    /// Attempts to compute the result subtracting self and other.

    ///

    /// If `is_reverse` is false, the operation being requested is `self` -

    /// `other`. If `is_reverse` is true, the operation being requested is

    /// `other` - `self`.

    #[allow(unused_variables)]

    /// Attempts to compute the result multiplying self and other.

    ///

    /// While multiplication is normally an associative operation, `is_reverse`

    /// allows

    /// determining if `self` is the left operand or the right operand to the

    /// operation.

    ///

    /// If `is_reverse` is false, the operation being requested is `self` *

    /// `other`. If `is_reverse` is true, the operation being requested is

    /// `other` * `self`.

    #[allow(unused_variables)]

    /// Attempts to compute the result dividing self and other.

    ///

    /// If `is_reverse` is false, the operation being requested is `self` /

    /// `other`. If `is_reverse` is true, the operation being requested is

    /// `other` / `self`.

    #[allow(unused_variables)]

    /// Calls a function by `name` with `args`.

    #[allow(unused_variables)]

    /// Returns this value as represented in source, if possible.

    /// Hashes the contents of this value. Returns true if this operation is

    /// supported.

    ///

    /// To allow the [`Value`] type to implement [`Hash`] but contain values

    /// that don't implement [`Hash`], this is not a trait that is required to

    /// implement.

    ///

    /// This allows safe collection types to be written, which check before key

    /// insertion that the value can be hashed and returns an error rather than

    /// panicking in the call to hash.

    #[allow(unused_variables)]

}

/// A Rust value that has been wrapped for use in the virtual machine.

pub struct Dynamic(

    // The reason for `Arc<Box<dyn UnboxableDynamicValue>>` instead of `Arc<dyn

    // UnboxableDynamicValue>` is the size. `Arc<dyn>` uses a fat pointer which

    // results in 16-bytes being used. By boxing the `dyn` value first, the Arc

    // pointer becomes a normal pointer resulting in this type being only 8

    // bytes.

    Arc<Box<dyn UnboxableDynamicValue>>,

);

impl Dynamic {

    /// Returns a new instance, wrapping `value`.

    ///

    /// This function causes two allocations: [`Arc::new()`] and [`Box::new()`].

    /// While `Arc<dyn T>` could be used for only one allocation, it uses a "fat

    /// pointer" which is double the size of a standard pointer. By using

    /// `Arc<Box<dyn T>>`, the `Box<dyn T>` becomes the fat pointer and the

    /// `Arc` remains a normal pointer. The net effect is that the [`Value`]

    /// enum is able to stay smaller due to this extra allocation.

    /// Returns the result of [`DynamicValue::kind()`] for the wrapped value.

    #[must_use]

    /// Returns the [`TypeId`] of the wrapped type.

    #[must_use]

    /// Returns a reference to the contained value, if the contained type is

    /// `T`.

    #[must_use]

    /// Attempts to unwrap the value. If there is more than one reference to

    /// this value, or `T` does not match the contained type, `Err(self)` will

    /// be returned.

            // We can now destruct self safely without worrying about needing to

            // return an error.

                }

            }

        } else {

        }

    /// Returns the contained value if `T` is the contained type. If the value

    /// contains another type, `Err(self)` will be returned. Otherwise, the

    /// inner value will be returned.

    ///

    /// Because dynamic values are cheaply cloned by wrapping the value in an

    /// [`Arc`], this method will return a clone if there are any other

    /// instances that point to the same contained value. If this is the final

    /// instance of this value, the contained value will be returned without

    /// additional allocations.

            // We can now destruct self safely without worrying about needing to

            // return an error.

                }

            }

        } else {

        }

    /// Returns the result of [`DynamicValue::is_truthy()`] for the wrapped

    /// value.

    #[must_use]

    /// Returns the result of [`DynamicValue::as_i64()`] for the wrapped value.

    #[must_use]

    /// Returns the result of [`DynamicValue::convert()`] for the wrapped value.

    #[must_use]

    /// Returns the inverse of [`DynamicValue::is_truthy()`] for the wrapped

    /// value.

    #[must_use]

    /// Returns the result of [`DynamicValue::partial_eq()`] for the wrapped

    /// value.

    #[must_use]

    /// Returns the result of [`DynamicValue::partial_cmp()`] for the wrapped

    /// value.

    #[must_use]

    /// Returns the result of [`DynamicValue::checked_add()`] for the wrapped

    /// value.

    /// Returns the result of [`DynamicValue::checked_sub()`] for the wrapped

    /// value.

    /// Returns the result of [`DynamicValue::checked_mul()`] for the wrapped

    /// value.

    /// Returns the result of [`DynamicValue::checked_div()`] for the wrapped

    /// value.

    /// Invokes [`DynamicValue::call`] with the given parameters.

    /// Returns the result of [`DynamicValue::to_source()`] for the wrapped

    /// value.

    #[must_use]

    /// Returns the result of [`DynamicValue::hash()`] for the wrapped

    /// value.

}

impl Display for Dynamic {

        }

}

trait UnboxableDynamicValue: Debug + Send + Sync {

    fn type_id(&self) -> TypeId;

    fn as_any(&self) -> &dyn Any;

    fn as_any_mut(&mut self) -> &mut dyn Any;

    fn as_opt_any_mut(&mut self) -> &mut dyn Any;

    fn is_truthy(&self) -> bool;

    fn as_i64(&self) -> Option<i64>;

    fn convert(&self, kind: &Symbol) -> Option<Value>;

    fn kind(&self) -> Symbol;

    fn partial_eq(&self, other: &Value) -> Option<bool>;

    fn partial_cmp(&self, other: &Value) -> Option<Ordering>;

    fn checked_add(&self, other: &Value, is_reverse: bool) -> Result<Option<Value>, FaultKind>;

    fn checked_sub(&self, other: &Value, is_reverse: bool) -> Result<Option<Value>, FaultKind>;

    fn checked_mul(&self, other: &Value, is_reverse: bool) -> Result<Option<Value>, FaultKind>;

    fn checked_div(&self, other: &Value, is_reverse: bool) -> Result<Option<Value>, FaultKind>;

    fn to_source(&self) -> Option<String>;

    fn hash(&self, state: &mut dyn Hasher) -> bool;

    fn call(&self, name: &Symbol, arguments: PoppedValues<'_>) -> Result<Value, FaultKind>;

}

struct DynamicValueData<T> {

    value: Option<T>,

}

impl<T> DynamicValueData<T> {

    #[inline]

    #[inline]

}

impl<T> UnboxableDynamicValue for DynamicValueData<T>

where

    T: DynamicValue + Any + Debug,

{

}

impl<T> Debug for DynamicValueData<T>

where

    T: Debug,

{

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        } else {

        }

}

impl<T> Display for DynamicValueData<T>

where

    T: Display,

{

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        } else {

        }

}

        },

    }