apple-quant-algorithmic 0.1.0

use std::fmt::{Debug, Display};

use num_traits::Zero;
use rust_decimal::Decimal;

use crate::instrument::{AsDecimal, InstrumentSpec};

use super::{DirectionalIntentVolume, DirectionlessVolume, RestingSide, VolumeDelta};

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RestingVolume<IS: InstrumentSpec> {
	pub directionless_volume: DirectionlessVolume<IS>,
	pub resting_side: RestingSide,
}

impl<IS: InstrumentSpec> RestingVolume<IS> {
	pub fn new(
		directionless_volume: DirectionlessVolume<IS>,
		resting_side: RestingSide,
	) -> Self {
		Self {
			directionless_volume,
			resting_side,
		}
	}

	pub fn flip(self) -> Self {
		Self {
			directionless_volume: self.directionless_volume,
			resting_side: self.resting_side.flip(),
		}
	}

	pub fn as_decimal(&self) -> Decimal {
		self.directionless_volume
			.as_decimal()
			* self
				.resting_side
				.as_directional_intent()
				.as_decimal()
	}

	pub fn as_directional_intent_volume(&self) -> DirectionalIntentVolume<IS> {
		(*self).into()
	}

	pub fn as_directionless_volume(&self) -> &DirectionlessVolume<IS> {
		&self.directionless_volume
	}

	pub fn resting_side(&self) -> &RestingSide {
		&self.resting_side
	}

	pub fn as_parts(
		&self
	) -> (
		&DirectionlessVolume<IS>,
		&RestingSide,
	) {
		(
			&self.directionless_volume,
			&self.resting_side,
		)
	}

	pub fn as_volume_delta(&self) -> VolumeDelta<IS> {
		if self
			.directionless_volume
			.is_zero()
		{
			return VolumeDelta::Zero;
		}

		VolumeDelta::RestingDelta {
			directionless_volume: self.directionless_volume,
			resting_side: self.resting_side,
		}
	}
}

impl<IS: InstrumentSpec> Display for RestingVolume<IS> {
	fn fmt(
		&self,
		f: &mut std::fmt::Formatter<'_>,
	) -> std::fmt::Result {
		let volume = self.as_decimal();
		write!(f, "{}", volume)
	}
}

impl<IS: InstrumentSpec> Debug for RestingVolume<IS> {
	fn fmt(
		&self,
		f: &mut std::fmt::Formatter<'_>,
	) -> std::fmt::Result {
		<Self as Display>::fmt(&self, f)
	}
}