fn try_from(value: u8) -> Result<Self, Self::Error> {

        match value {

            x if x == CcsdsTimeCode::CucCcsdsEpoch as u8 => Ok(CcsdsTimeCode::CucCcsdsEpoch),

            x if x == CcsdsTimeCode::CucAgencyEpoch as u8 => Ok(CcsdsTimeCode::CucAgencyEpoch),

            x if x == CcsdsTimeCode::Cds as u8 => Ok(CcsdsTimeCode::Cds),

            x if x == CcsdsTimeCode::Ccs as u8 => Ok(CcsdsTimeCode::Ccs),

            x if x == CcsdsTimeCode::AgencyDefined as u8 => Ok(CcsdsTimeCode::AgencyDefined),

            _ => Err(()),

    }

pub fn ccsds_time_code_from_p_field(pfield: u8) -> Result<CcsdsTimeCode, u8> {

    let raw_bits = (pfield >> 4) & 0b111;

    CcsdsTimeCode::try_from(raw_bits).map_err(|_| raw_bits)

}

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

        match self {

            TimestampError::InvalidTimeCode { expected, found } => {

                write!(

                    f,

                    "invalid raw time code value {found} for time code {expected:?}"

                )

            TimestampError::Cuc(e) => {

                write!(f, "cuc error: {e}")

            TimestampError::ByteConversion(e) => {

                write!(f, "time stamp: {e}")

    }

    fn from(e: cds::CdsError) -> Self {

        TimestampError::Cds(e)

    }

    fn from(e: cuc::CucError) -> Self {

        TimestampError::Cuc(e)

    }

pub fn seconds_since_epoch() -> f64 {

    SystemTime::now()

        .duration_since(SystemTime::UNIX_EPOCH)

        .expect("System time generation failed")

        .as_secs_f64()

}

pub const fn unix_to_ccsds_days(unix_days: i64) -> i64 {

    unix_days - DAYS_CCSDS_TO_UNIX as i64

}

pub const fn ccsds_to_unix_days(ccsds_days: i64) -> i64 {

    ccsds_days + DAYS_CCSDS_TO_UNIX as i64

}

pub const fn unix_epoch_to_ccsds_epoch(unix_epoch: i64) -> i64 {

    unix_epoch - (DAYS_CCSDS_TO_UNIX as i64 * SECONDS_PER_DAY as i64)

}

pub const fn ccsds_epoch_to_unix_epoch(ccsds_epoch: i64) -> i64 {

    ccsds_epoch + (DAYS_CCSDS_TO_UNIX as i64 * SECONDS_PER_DAY as i64)

}

pub fn ms_of_day(seconds_since_epoch: f64) -> u32 {

    let fraction_ms = seconds_since_epoch - seconds_since_epoch.floor();

    let ms_of_day: u32 = (((seconds_since_epoch.floor() as u32 % SECONDS_PER_DAY) * 1000) as f64

        + fraction_ms)

        .floor() as u32;

    ms_of_day

}

    fn to_vec(&self) -> Result<alloc::vec::Vec<u8>, TimestampError> {

        let mut vec = alloc::vec![0; self.len_written()];

        self.write_to_bytes(&mut vec)?;

        Ok(vec)

    }

    fn subsec_millis(&self) -> u16 {

        (self.subsec_nanos() / 1_000_000) as u16

    }

    fn chrono_date_time(&self) -> chrono::LocalResult<chrono::DateTime<chrono::Utc>> {

        chrono::Utc.timestamp_opt(self.unix_secs(), self.subsec_nanos())

    }

    fn timelib_date_time(&self) -> Result<time::OffsetDateTime, time::error::ComponentRange> {

        Ok(time::OffsetDateTime::from_unix_timestamp(self.unix_secs())?

            + time::Duration::nanoseconds(self.subsec_nanos().into()))

    }

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

    pub fn new_checked(unix_seconds: i64, subsec_nanos: u32) -> Option<Self> {

        if subsec_nanos >= NANOS_PER_SECOND {

        }

        Some(Self::new(unix_seconds, subsec_nanos))

    }

    pub fn new_subsec_millis_checked(unix_seconds: i64, subsec_millis: u16) -> Option<Self> {

        if subsec_millis >= 1000 {

        }

        Self::new_checked(unix_seconds, subsec_millis as u32 * 1_000_000)

    }

    pub const fn new(unix_seconds: i64, subsecond_nanos: u32) -> Self {

        if subsecond_nanos >= NANOS_PER_SECOND {

        }

        Self {

            secs: unix_seconds,

            subsec_nanos: subsecond_nanos,

        }

    }

    pub fn new_only_secs(unix_seconds: i64) -> Self {

        Self {

            secs: unix_seconds,

            subsec_nanos: 0,

        }

    }

    pub fn subsec_millis(&self) -> u16 {

        (self.subsec_nanos / 1_000_000) as u16

    }

    pub fn subsec_nanos(&self) -> u32 {

        self.subsec_nanos

    }

    pub fn now() -> Result<Self, SystemTimeError> {

        let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;

        let epoch = now.as_secs();

        Ok(Self::new(epoch as i64, now.subsec_nanos()))

    }

    pub fn unix_secs_f64(&self) -> f64 {

        self.secs as f64 + (self.subsec_nanos as f64 / 1_000_000_000.0)

    }

    pub fn as_secs(&self) -> i64 {

        self.secs

    }

    pub fn chrono_date_time(&self) -> chrono::LocalResult<chrono::DateTime<chrono::Utc>> {

        Utc.timestamp_opt(self.secs, self.subsec_nanos)

    }

    pub fn timelib_date_time(&self) -> Result<time::OffsetDateTime, time::error::ComponentRange> {

        Ok(time::OffsetDateTime::from_unix_timestamp(self.as_secs())?

            + time::Duration::nanoseconds(self.subsec_nanos().into()))

    }

    pub fn diff_in_millis(&self, other: &UnixTime) -> Option<i64> {

        let seconds_difference = self.secs.checked_sub(other.secs)?;

        let milliseconds_difference = seconds_difference.checked_mul(1000)?;

        let subsecond_difference_nanos = self.subsec_nanos as i64 - other.subsec_nanos as i64;

        // Combine the differences

        Some(milliseconds_difference + (subsecond_difference_nanos / 1_000_000))

    }

    fn from(value: chrono::DateTime<chrono::Utc>) -> Self {

        Self::new(value.timestamp(), value.timestamp_subsec_nanos())

    }

    fn from(value: time::OffsetDateTime) -> Self {

        Self::new(value.unix_timestamp(), value.nanosecond())

    }

    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {

        Some(self.cmp(other))

    }

    fn cmp(&self, other: &Self) -> Ordering {

        if self == other {

            return Ordering::Equal;

        }

        match self.secs.cmp(&other.secs) {

            Ordering::Less => return Ordering::Less,

            Ordering::Greater => return Ordering::Greater,

            _ => (),

        }

        match self.subsec_millis().cmp(&other.subsec_millis()) {

                return if self.secs < 0 {

                    Ordering::Greater

                    Ordering::Less

                return if self.secs < 0 {

                    Ordering::Less

                    Ordering::Greater

    }

    fn sub(self, rhs: Self) -> Self::Output {

        let difference = self.diff_in_millis(&rhs)?;

        Some(if difference < 0 {

            StampDiff {

                positive_duration: false,

                duration_absolute: Duration::from_millis(-difference as u64),

            }

            StampDiff {

                positive_duration: true,

                duration_absolute: Duration::from_millis(difference as u64),

            }

    }

fn get_new_stamp_after_addition(current_stamp: &UnixTime, duration: Duration) -> UnixTime {

    let mut new_subsec_nanos = current_stamp.subsec_nanos() + duration.subsec_nanos();

    let mut new_unix_seconds = current_stamp.secs;

    let mut increment_seconds = |value: u32| {

        if new_unix_seconds < 0 {

        } else {

            new_unix_seconds = new_unix_seconds

                .checked_add(value.into())

                .expect("new unix seconds would exceed i64::MAX");

        }

    };

    if new_subsec_nanos >= 1_000_000_000 {

        new_subsec_nanos -= 1_000_000_000;

        increment_seconds(1);

    }

    increment_seconds(

        duration

            .as_secs()

            .try_into()

            .expect("duration seconds exceeds u32::MAX"),

    );

    UnixTime::new(new_unix_seconds, new_subsec_nanos)

}

    fn add_assign(&mut self, duration: Duration) {

        *self = get_new_stamp_after_addition(self, duration);

    }

    fn add(self, duration: Duration) -> Self::Output {

        get_new_stamp_after_addition(&self, duration)

    }

    fn add(self, duration: Duration) -> Self::Output {

        get_new_stamp_after_addition(self, duration)

    }

    fn test_days_conversion() {

        assert_eq!(unix_to_ccsds_days(DAYS_CCSDS_TO_UNIX.into()), 0);

        assert_eq!(ccsds_to_unix_days(0), DAYS_CCSDS_TO_UNIX.into());

    }

    fn test_get_current_time() {

        let sec_floats = seconds_since_epoch();

        assert!(sec_floats > 0.0);

    }

    fn test_ms_of_day() {

        let ms = ms_of_day(0.0);

        assert_eq!(ms, 0);

        let ms = ms_of_day(5.0);

        assert_eq!(ms, 5000);

    }

    fn test_ccsds_epoch() {

        let now = SystemTime::now()

            .duration_since(SystemTime::UNIX_EPOCH)

            .unwrap();

        let unix_epoch = now.as_secs();

        let ccsds_epoch = unix_epoch_to_ccsds_epoch(now.as_secs() as i64) as u64;

        assert!(ccsds_epoch > unix_epoch);

        assert_eq!((ccsds_epoch - unix_epoch) % SECONDS_PER_DAY as u64, 0);

        let days_diff = (ccsds_epoch - unix_epoch) / SECONDS_PER_DAY as u64;

        assert_eq!(days_diff, -DAYS_CCSDS_TO_UNIX as u64);

    }

    fn basic_unix_stamp_test() {

        let stamp = UnixTime::new_only_secs(-200);

        assert_eq!(stamp.secs, -200);

        assert_eq!(stamp.subsec_millis(), 0);

        let stamp = UnixTime::new_only_secs(250);

        assert_eq!(stamp.secs, 250);

        assert_eq!(stamp.subsec_millis(), 0);

    }

    fn basic_float_unix_stamp_test() {

        let stamp = UnixTime::new_subsec_millis_checked(500, 600).unwrap();

        assert_eq!(stamp.secs, 500);

        let subsec_millis = stamp.subsec_millis();

        assert_eq!(subsec_millis, 600);

        println!("{:?}", (500.6 - stamp.unix_secs_f64()).to_string());

        assert!((500.6 - stamp.unix_secs_f64()).abs() < 0.0001);

    }

    fn test_ord_larger() {

        let stamp0 = UnixTime::new_only_secs(5);

        let stamp1 = UnixTime::new_subsec_millis_checked(5, 500).unwrap();

        let stamp2 = UnixTime::new_only_secs(6);

        assert!(stamp1 > stamp0);

        assert!(stamp2 > stamp0);

        assert!(stamp2 > stamp1);

    }

    fn test_ord_smaller() {

        let stamp0 = UnixTime::new_only_secs(5);

        let stamp1 = UnixTime::new_subsec_millis_checked(5, 500).unwrap();

        let stamp2 = UnixTime::new_only_secs(6);

        assert!(stamp0 < stamp1);

        assert!(stamp0 < stamp2);

        assert!(stamp1 < stamp2);

    }

    fn test_ord_larger_neg_numbers() {

        let stamp0 = UnixTime::new_only_secs(-5);

        let stamp1 = UnixTime::new_subsec_millis_checked(-5, 500).unwrap();

        let stamp2 = UnixTime::new_only_secs(-6);

        assert!(stamp0 > stamp1);

        assert!(stamp0 > stamp2);

        assert!(stamp1 > stamp2);

        assert!(stamp1 >= stamp2);

        assert!(stamp0 >= stamp1);

    }

    fn test_ord_smaller_neg_numbers() {

        let stamp0 = UnixTime::new_only_secs(-5);

        let stamp1 = UnixTime::new_subsec_millis_checked(-5, 500).unwrap();

        let stamp2 = UnixTime::new_only_secs(-6);

        assert!(stamp2 < stamp1);

        assert!(stamp2 < stamp0);

        assert!(stamp1 < stamp0);

        assert!(stamp1 <= stamp0);

        assert!(stamp2 <= stamp1);

    }

    fn test_eq() {

        let stamp0 = UnixTime::new(5, 0);

        let stamp1 = UnixTime::new_only_secs(5);

        assert_eq!(stamp0, stamp1);

        assert!(stamp0 <= stamp1);

        assert!(stamp0 >= stamp1);

        assert!(!(stamp0 < stamp1));

        assert!(!(stamp0 > stamp1));

    }

    fn test_addition() {

        let mut stamp0 = UnixTime::new_only_secs(1);

        stamp0 += Duration::from_secs(5);

        assert_eq!(stamp0.as_secs(), 6);

        assert_eq!(stamp0.subsec_millis(), 0);

        let stamp1 = stamp0 + Duration::from_millis(500);

        assert_eq!(stamp1.secs, 6);

        assert_eq!(stamp1.subsec_millis(), 500);

    }

    fn test_addition_on_ref() {

        let stamp0 = &UnixTime::new_subsec_millis_checked(20, 500).unwrap();

        let stamp1 = stamp0 + Duration::from_millis(2500);

        assert_eq!(stamp1.secs, 23);

        assert_eq!(stamp1.subsec_millis(), 0);

    }

    fn test_as_dt() {

        let stamp = UnixTime::new_only_secs(0);

        let dt = stamp.chrono_date_time().unwrap();

        assert_eq!(dt.year(), 1970);

        assert_eq!(dt.month(), 1);

        assert_eq!(dt.day(), 1);

        assert_eq!(dt.hour(), 0);

        assert_eq!(dt.minute(), 0);

        assert_eq!(dt.second(), 0);

    }

    fn test_from_now() {

        let stamp_now = UnixTime::now().unwrap();

        let dt_now = stamp_now.chrono_date_time().unwrap();

        assert!(dt_now.year() >= 2020);

    }

    fn test_stamp_diff_positive_0() {

        let stamp_later = UnixTime::new(2, 0);

        let StampDiff {

            positive_duration,

            duration_absolute,

        } = (stamp_later - UnixTime::new(1, 0)).expect("stamp diff error");

        assert!(positive_duration);

        assert_eq!(duration_absolute, Duration::from_secs(1));

    }

    fn test_stamp_diff_positive_1() {

        let stamp_later = UnixTime::new(3, 800 * 1_000_000);

        let stamp_earlier = UnixTime::new_subsec_millis_checked(1, 900).unwrap();

        let StampDiff {

            positive_duration,

            duration_absolute,

        } = (stamp_later - stamp_earlier).expect("stamp diff error");

        assert!(positive_duration);

        assert_eq!(duration_absolute, Duration::from_millis(1900));

    }

    fn test_stamp_diff_negative() {

        let stamp_later = UnixTime::new_subsec_millis_checked(3, 800).unwrap();

        let stamp_earlier = UnixTime::new_subsec_millis_checked(1, 900).unwrap();

        let StampDiff {

            positive_duration,

            duration_absolute,

        } = (stamp_earlier - stamp_later).expect("stamp diff error");

        assert!(!positive_duration);

        assert_eq!(duration_absolute, Duration::from_millis(1900));

    }

    fn test_addition_spillover() {

        let mut stamp0 = UnixTime::new_subsec_millis_checked(1, 900).unwrap();

        stamp0 += Duration::from_millis(100);

        assert_eq!(stamp0.secs, 2);

        assert_eq!(stamp0.subsec_millis(), 0);

        stamp0 += Duration::from_millis(1100);

        assert_eq!(stamp0.secs, 3);

        assert_eq!(stamp0.subsec_millis(), 100);

    }

    fn test_cuc_error_printout() {

        let cuc_error = CucError::InvalidCounterWidth(12);

        let stamp_error = TimestampError::from(cuc_error);

        assert_eq!(stamp_error.to_string(), format!("cuc error: {cuc_error}"));

    }

    fn test_unix_stamp_as_timelib_datetime() {

        let stamp_epoch = UnixTime::EPOCH;

        let timelib_dt = stamp_epoch.timelib_date_time().unwrap();

        assert_eq!(timelib_dt.year(), 1970);

        assert_eq!(timelib_dt.month(), time::Month::January);

        assert_eq!(timelib_dt.day(), 1);

        assert_eq!(timelib_dt.hour(), 0);

        assert_eq!(timelib_dt.minute(), 0);

        assert_eq!(timelib_dt.second(), 0);

    }

    fn test_unix_stamp_from_timelib_datetime() {

        let timelib_dt = time::OffsetDateTime::UNIX_EPOCH;

        let unix_time = UnixTime::from(timelib_dt);

        let timelib_converted_back = unix_time.timelib_date_time().unwrap();

        assert_eq!(timelib_dt, timelib_converted_back);

    }