// Licensed under the Apache-2.0 license
// SPDX-License-Identifier: Apache-2.0

//! Generic USB protocol stack.
//!
//! This module provides the core logic for a USB device stack, including
//! Endpoint 0 control request handling, descriptor management, and
//! multi-packet transfer accumulation.

#![no_std]

use aligned::Aligned;
use aligned::A4;
use core::mem::size_of;
use hal_usb::driver::UsbDriver;
use hal_usb::driver::UsbEvent;
use hal_usb::driver::UsbPacket;
use hal_usb::DescriptorInfo;
use hal_usb::DescriptorType;
use hal_usb::Request;
use hal_usb::SetupPacket;
use hal_usb::StringDescriptorRef;
use hal_usb::StringHandle;
use zerocopy::IntoBytes;

use pw_status::Error;

pub const CONFIG_0: Aligned<A4, [u8; 1]> = Aligned([0]);
pub const CONFIG_1: Aligned<A4, [u8; 1]> = Aligned([1]);
pub const STATUS_OK: Aligned<A4, [u8; 2]> = Aligned([0, 0]);
pub const STATUS_HALTED: Aligned<A4, [u8; 2]> = Aligned([1, 0]);

#[inline(always)]
const fn endpoint_number(endpoint_addr: u8) -> u8 {
    endpoint_addr & 0x0f
}

#[inline(always)]
const fn endpoint_is_in(endpoint_addr: u8) -> bool {
    (endpoint_addr & 0x80) != 0
}

#[inline(always)]
const fn endpoint_bit_index(endpoint_addr: u8) -> u32 {
    let num = endpoint_number(endpoint_addr) as u32;
    if endpoint_is_in(endpoint_addr) {
        16 + num
    } else {
        num
    }
}

/// A trait for providing USB descriptors to the stack.
///
/// Applications must implement this trait to define the device's identity
/// and capabilities.
pub trait DescriptorSource {
    /// Device descriptor bytes.
    const DEVICE_DESC_BYTES: &'static Aligned<A4, [u8]>;
    /// Configuration descriptor bytes (including interfaces and endpoints).
    const CONFIG_DESC_BYTES: &'static Aligned<A4, [u8]>;
    /// String descriptor 0 bytes (supported languages).
    const STRING_DESC_0_BYTES: &'static Aligned<A4, [u8]>;
    /// Device status bytes (2 bytes, usually [0, 0]).
    const DEVICE_STATUS: Aligned<A4, [u8; 2]>;

    /// Returns a string descriptor by handle and language ID.
    fn get_string(&self, handle: StringHandle, lang: u16) -> Option<StringDescriptorRef<'_>>;
    /// Returns the device status bytes.
    fn get_device_status(&self) -> &Aligned<A4, [u8]> {
        &Self::DEVICE_STATUS
    }
}

/// An empty aligned buffer.
pub const EMPTY: &Aligned<A4, [u8]> = &Aligned([]);

/// A simple implementation of USB Endpoint 0 (control endpoint).
pub struct SimpleEp0 {
    new_address: Option<u8>,
    configuration: u8,
    halted_endpoints: u32,
    pending_halt: Option<(u8, bool)>,
}

/// A trait for modular USB class implementations.
pub trait UsbClass {
    /// Attempt to handle a USB event.
    ///
    /// If the event is handled by this class, it returns `Ok(UsbAction)`.
    /// Otherwise, it returns the original event in `Err`.
    fn handle_event<'a, P: UsbPacket>(
        &'a mut self,
        event: UsbEvent<P>,
    ) -> Result<UsbAction<'a>, UsbEvent<P>>;
}

/// Indicates the result of running a USB action.
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum UsbActionRun {
    /// No operation was performed.
    NoOp,
    /// The action has more data to transfer.
    HasMoreData,
    /// The action is complete.
    Done,
}

/// Actions to be performed on a USB driver.
pub enum UsbAction<'a> {
    /// No action.
    None,
    /// Perform an IN transfer on the specified endpoint.
    TransferIn {
        /// The endpoint index.
        endpoint: u8,
        /// The data to transfer.
        data: &'a Aligned<A4, [u8]>,
        /// If true, send a zero-length packet (ZLP) if the data length
        /// is a multiple of the maximum packet size.
        zlp: bool,
    },
    /// Perform an IN transfer on the specified endpoint using unaligned data.
    TransferInUnaligned {
        /// The endpoint index.
        endpoint: u8,
        /// The data to transfer.
        data: &'a [u8],
        /// If true, send a zero-length packet (ZLP) if the data length
        /// is a multiple of the maximum packet size.
        zlp: bool,
    },
    /// Stall both IN and OUT directions on the specified endpoint.
    StallInAndOut {
        /// The endpoint index.
        endpoint: u8,
    },
    /// Set the device address.
    SetAddress {
        /// The new device address.
        new_address: u8,
    },
    /// Set the stall status of an endpoint.
    EndpointHalt {
        /// The endpoint address.
        endpoint_addr: u8,
        /// Whether to stall or unstall the endpoint.
        halted: bool,
    },
}

impl PartialEq for UsbAction<'_> {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::None, Self::None) => true,
            (
                Self::TransferIn {
                    endpoint: e1,
                    data: d1,
                    zlp: z1,
                },
                Self::TransferIn {
                    endpoint: e2,
                    data: d2,
                    zlp: z2,
                },
            ) => e1 == e2 && core::ptr::eq(*d1, *d2) && z1 == z2,
            (
                Self::TransferInUnaligned {
                    endpoint: e1,
                    data: d1,
                    zlp: z1,
                },
                Self::TransferInUnaligned {
                    endpoint: e2,
                    data: d2,
                    zlp: z2,
                },
            ) => e1 == e2 && core::ptr::eq(*d1, *d2) && z1 == z2,
            (Self::StallInAndOut { endpoint: e1 }, Self::StallInAndOut { endpoint: e2 }) => {
                e1 == e2
            }
            (Self::SetAddress { new_address: a1 }, Self::SetAddress { new_address: a2 }) => {
                a1 == a2
            }
            (
                Self::EndpointHalt {
                    endpoint_addr: a1,
                    halted: h1,
                },
                Self::EndpointHalt {
                    endpoint_addr: a2,
                    halted: h2,
                },
            ) => a1 == a2 && h1 == h2,
            _ => false,
        }
    }
}
impl Eq for UsbAction<'_> {}

impl<'a> UsbAction<'a> {
    /// Helper to create a TransferIn action for a control transfer,
    /// or a StallInAndOut if the requested length is too small.
    #[inline(always)]
    #[track_caller]
    pub fn control_transfer_in_or_stall(
        endpoint: u8,
        pkt: &SetupPacket,
        data: &'a Aligned<A4, [u8]>,
    ) -> Self {
        if data.len() > pkt.length().into() {
            Self::StallInAndOut { endpoint }
        } else {
            Self::TransferIn {
                endpoint,
                data,
                // Per USB Specs 5.5.3, we need to send ZLP for control transfers
                // if the response is less than requested.
                zlp: data.is_empty() || data.len() < pkt.length().into(),
            }
        }
    }
    /// Merges another action into this one.
    pub fn merge(&mut self, new_action: UsbAction<'a>) {
        match new_action {
            UsbAction::None => {}
            _ => *self = new_action,
        }
    }

    /// Executes the action on the provided driver.
    pub fn run<TDriver: UsbDriver>(&mut self, driver: &mut TDriver) -> UsbActionRun {
        match self {
            Self::None => return UsbActionRun::NoOp,
            Self::TransferIn {
                endpoint,
                data,
                zlp,
            } => {
                let bytes_transferred = driver.transfer_in(*endpoint, data, *zlp);
                // Note: bytes_transferred is guaranteed to be a multiple of
                // UsbDriver::MAX_PACKET_SIZE, which is guaranteed to be a
                // multiple of 4.
                if bytes_transferred < data.len() && (bytes_transferred & 3) == 0 {
                    // We're not done yet...
                    *data = &data[bytes_transferred..];
                    return UsbActionRun::HasMoreData;
                }
            }
            Self::TransferInUnaligned {
                endpoint,
                data,
                zlp,
            } => {
                let bytes_transferred = driver.transfer_in_unaligned(*endpoint, data, *zlp);
                if bytes_transferred < data.len() {
                    // We're not done yet...
                    *data = &data[bytes_transferred..];
                    return UsbActionRun::HasMoreData;
                }
            }
            Self::SetAddress { new_address } => driver.set_address(*new_address),
            Self::StallInAndOut { endpoint } => {
                driver.stall((*endpoint) & 0x7f, true);
                driver.stall((*endpoint) | 0x80, true);
            }
            Self::EndpointHalt {
                endpoint_addr,
                halted,
            } => {
                driver.stall(*endpoint_addr, *halted);
            }
        }
        *self = UsbAction::None;
        UsbActionRun::Done
    }
}

impl SimpleEp0 {
    /// Creates a new `SimpleEp0` handler.
    pub fn new() -> Self {
        Self {
            new_address: None,
            configuration: 0,
            halted_endpoints: 0,
            pending_halt: None,
        }
    }

    pub fn is_endpoint_halted(&self, endpoint_addr: u8) -> bool {
        let idx = endpoint_bit_index(endpoint_addr);
        (self.halted_endpoints & (1 << idx)) != 0
    }

    pub fn set_endpoint_halted(&mut self, endpoint_addr: u8, halted: bool) {
        let idx = endpoint_bit_index(endpoint_addr);
        if halted {
            self.halted_endpoints |= 1 << idx;
        } else {
            self.halted_endpoints &= !(1 << idx);
        }
    }

    /// A helper function to process a driver UsbEvent.
    ///
    /// This function returns the action that should be performed on the driver.
    pub fn handle_event<'a, P: UsbPacket>(
        &mut self,
        ev: UsbEvent<P>,
        descriptor_source: &'a impl DescriptorSource,
    ) -> Result<UsbAction<'a>, UsbEvent<P>> {
        match ev {
            UsbEvent::SetupPacket { endpoint: 0, pkt } => {
                use hal_usb::RequestType;
                if pkt.request().request_type() == RequestType::Standard {
                    Ok(self.handle_setup(pkt, descriptor_source))
                } else {
                    Err(ev)
                }
            }
            UsbEvent::PacketSent { endpoint: 0 } => Ok(self.handle_packet_sent()),
            UsbEvent::UsbReset => {
                self.configuration = 0;
                self.new_address = None;
                self.halted_endpoints = 0;
                self.pending_halt = None;
                Ok(UsbAction::None)
            }
            _ => Err(ev),
        }
    }

    /// Process a SETUP transfer and return the resulting action.
    fn handle_setup<'a, TDescriptorSource: DescriptorSource>(
        &mut self,
        setup_pkt: SetupPacket,
        descriptor_source: &'a TDescriptorSource,
    ) -> UsbAction<'a> {
        match setup_pkt.request() {
            Request::DEVICE_GET_DESCRIPTOR => {
                let descriptor = DescriptorInfo::from(&setup_pkt);
                #[rustfmt::skip]
                let mut response: Option<&Aligned<A4, [u8]>> = match descriptor {
                    DescriptorInfo { ty: DescriptorType::DEVICE, index: 0, .. } => {
                        Some(TDescriptorSource::DEVICE_DESC_BYTES)
                    }
                    DescriptorInfo { ty: DescriptorType::CONFIGURATION, index: 0, .. } => {
                        Some(TDescriptorSource::CONFIG_DESC_BYTES)
                    }
                    DescriptorInfo { ty: DescriptorType::STRING, index: 0, .. } => {
                        Some(TDescriptorSource::STRING_DESC_0_BYTES)
                    }
                    DescriptorInfo { ty: DescriptorType::STRING, index, .. } => {
                        descriptor_source
                            .get_string(StringHandle(index), setup_pkt.index())
                            .map(|desc| desc.as_bytes())
                    }
                    _ => None,
                };
                if let Some(response) = &mut response {
                    if response.len() > setup_pkt.length().into() {
                        *response = &(*response)[..setup_pkt.length().into()];
                    }
                    UsbAction::control_transfer_in_or_stall(0, &setup_pkt, response)
                } else {
                    UsbAction::StallInAndOut { endpoint: 0 }
                }
            }
            Request::DEVICE_GET_STATUS => UsbAction::control_transfer_in_or_stall(
                0,
                &setup_pkt,
                descriptor_source.get_device_status(),
            ),
            Request::INTERFACE_GET_STATUS => {
                UsbAction::control_transfer_in_or_stall(0, &setup_pkt, &STATUS_OK)
            }
            Request::ENDPOINT_GET_STATUS => {
                let ep_addr = u8::try_from(setup_pkt.index() & 0xff).unwrap();
                let data = if self.is_endpoint_halted(ep_addr) {
                    &STATUS_HALTED
                } else {
                    &STATUS_OK
                };
                UsbAction::control_transfer_in_or_stall(0, &setup_pkt, data)
            }
            Request::ENDPOINT_SET_FEATURE => {
                match setup_pkt.value() {
                    0 => {
                        // ENDPOINT_HALT
                        let ep_addr = u8::try_from(setup_pkt.index() & 0xff).unwrap();
                        if endpoint_number(ep_addr) == 0 {
                            // Endpoint 0 cannot be halted. Stall the control pipe to reject the request.
                            UsbAction::StallInAndOut { endpoint: 0 }
                        } else {
                            self.set_endpoint_halted(ep_addr, true);
                            self.pending_halt = Some((ep_addr, true));
                            UsbAction::TransferIn {
                                endpoint: 0,
                                data: EMPTY,
                                zlp: true,
                            }
                        }
                    }
                    _ => {
                        // Feature not supported.
                        UsbAction::StallInAndOut { endpoint: 0 }
                    }
                }
            }
            Request::ENDPOINT_CLEAR_FEATURE => {
                match setup_pkt.value() {
                    0 => {
                        // ENDPOINT_HALT
                        let ep_addr = u8::try_from(setup_pkt.index() & 0xff).unwrap();
                        if endpoint_number(ep_addr) == 0 {
                            // Endpoint 0 cannot be cleared. Stall the control pipe to reject the request.
                            UsbAction::StallInAndOut { endpoint: 0 }
                        } else {
                            self.set_endpoint_halted(ep_addr, false);
                            self.pending_halt = Some((ep_addr, false));
                            UsbAction::TransferIn {
                                endpoint: 0,
                                data: EMPTY,
                                zlp: true,
                            }
                        }
                    }
                    _ => {
                        // Feature not supported.
                        UsbAction::StallInAndOut { endpoint: 0 }
                    }
                }
            }
            Request::DEVICE_SET_ADDRESS => {
                self.new_address = Some(setup_pkt.value() as u8);
                UsbAction::TransferIn {
                    endpoint: 0,
                    data: EMPTY,
                    zlp: true,
                }
            }
            Request::DEVICE_SET_CONFIGURATION => {
                let val = setup_pkt.value();
                if val == 0 || val == 1 {
                    self.configuration = val as u8;
                    UsbAction::TransferIn {
                        endpoint: 0,
                        data: EMPTY,
                        zlp: true,
                    }
                } else {
                    UsbAction::StallInAndOut { endpoint: 0 }
                }
            }
            Request::DEVICE_GET_CONFIGURATION => {
                let data = match self.configuration {
                    1 => &CONFIG_1,
                    _ => &CONFIG_0,
                };
                UsbAction::control_transfer_in_or_stall(0, &setup_pkt, data)
            }
            Request::INTERFACE_GET_INTERFACE => {
                UsbAction::control_transfer_in_or_stall(0, &setup_pkt, &CONFIG_0)
            }
            Request::INTERFACE_SET_INTERFACE => {
                if setup_pkt.value() == 0 {
                    UsbAction::TransferIn {
                        endpoint: 0,
                        data: EMPTY,
                        zlp: true,
                    }
                } else {
                    UsbAction::StallInAndOut { endpoint: 0 }
                }
            }
            _ => UsbAction::StallInAndOut { endpoint: 0 },
        }
    }
    fn handle_packet_sent(&mut self) -> UsbAction<'static> {
        if let Some(new_address) = self.new_address.take() {
            // Now that the transfer is complete it's safe to change the address..
            return UsbAction::SetAddress { new_address };
        }
        if let Some((endpoint_addr, halted)) = self.pending_halt.take() {
            return UsbAction::EndpointHalt {
                endpoint_addr,
                halted,
            };
        }
        UsbAction::None
    }
}

impl Default for SimpleEp0 {
    fn default() -> Self {
        Self::new()
    }
}

/// A helper struct to handle multi-packet USB transfers.
///
/// It accumulates incoming USB packets into an internal buffer until a short
/// packet or a zero-length packet (ZLP) is received, indicating the end of a transfer.
///
/// `N` is the number of **words** (`u32`s) in the internal buffer and NOT bytes.
#[derive(Debug, PartialEq, Eq)]
pub struct Transfer<const N: usize> {
    buffer: [u32; N],
    word_offset: usize,
}

impl<const N: usize> Transfer<N> {
    /// Maximum packet size supported (fixed at 64 bytes).
    pub const MAX_PACKET_SIZE: usize = 64;

    /// Creates a new `Transfer` buffer.
    pub fn new() -> Self {
        Self {
            buffer: [0; N],
            word_offset: 0,
        }
    }

    /// Splices a USB packet into the buffer.
    ///
    /// Returns `Ok(Some(slice))` if the transfer is complete, `Ok(None)` otherwise.
    pub fn splice(&mut self, packet: impl UsbPacket) -> Result<Option<&Aligned<A4, [u8]>>, Error> {
        const {
            assert!(Self::MAX_PACKET_SIZE % size_of::<u32>() == 0);
        }
        let packet_len = packet.len();
        let dest = {
            let start = self.word_offset;
            let end = start + packet_len.div_ceil(size_of::<u32>());
            self.buffer.get_mut(start..end).ok_or(Error::OutOfRange)?
        };
        packet.copy_to(dest);
        if packet_len < Self::MAX_PACKET_SIZE {
            let result = &self
                .buffer
                .as_bytes()
                .get(..self.word_offset * size_of::<u32>() + packet_len)
                .ok_or(Error::OutOfRange)?;
            self.word_offset = 0;
            Ok(Some(
                // nosemgrep
                unsafe {
                    // SAFETY: `self.buffer` is `[u32]` which has alignment of 4.
                    core::mem::transmute::<&[u8], &Aligned<A4, [u8]>>(result)
                },
            ))
        } else {
            self.word_offset += Self::MAX_PACKET_SIZE / size_of::<u32>();
            Ok(None)
        }
    }
}

impl<const N: usize> Default for Transfer<N> {
    fn default() -> Self {
        Self::new()
    }
}

pub mod testing {
    use aligned::Aligned;
    use aligned::A4;
    use hal_usb::driver::UsbPacket;
    use zerocopy::IntoBytes;

    #[derive(Debug)]
    pub struct FakeUsbPacket<'a> {
        pub data: &'a [u8],
        pub ep: usize,
    }

    impl UsbPacket for FakeUsbPacket<'_> {
        fn endpoint_index(&self) -> usize {
            self.ep
        }

        fn len(&self) -> usize {
            self.data.len()
        }

        fn copy_to_uninit(self, _dest: &mut [core::mem::MaybeUninit<u32>]) -> &[u8] {
            unimplemented!()
        }

        fn copy_to(self, dest: &mut [u32]) -> &[u8] {
            let dest_bytes = dest.as_mut_bytes();
            let copy_len = self.data.len().min(dest_bytes.len());
            dest_bytes[..copy_len].copy_from_slice(&self.data[..copy_len]);
            // nosemgrep
            unsafe {
                // SAFETY: `dest` is a `&mut [u32]`, which is guaranteed to be 4-byte
                // aligned. `dest_bytes` is a byte slice view of the same memory, so it's also
                // 4-byte aligned. The subslice `&dest_bytes[..copy_len]` maintains this alignment.
                core::mem::transmute::<&[u8], &Aligned<A4, [u8]>>(&dest_bytes[..copy_len])
            }
        }

        fn copy_to_unaligned(self, dest: &mut [u8]) -> &[u8] {
            let copy_len = self.data.len().min(dest.len());
            dest[..copy_len].copy_from_slice(&self.data[..copy_len]);
            &dest[..copy_len]
        }
    }
}

#[cfg(test)]
mod splice_tests {
    use super::testing::FakeUsbPacket;
    use super::*;

    const MAX_PACKET_SIZE: usize = Transfer::<0>::MAX_PACKET_SIZE;

    #[test]
    fn test_splice_single_short_packet() {
        let packet_data = [1, 2, 3, 4];
        let packet = FakeUsbPacket {
            data: &packet_data,
            ep: 0,
        };

        let mut transfer = Transfer::<32>::new();
        let result = transfer.splice(packet).unwrap();

        assert!(result.is_some());
        assert_eq!(result.unwrap().as_ref(), &packet_data[..]);
    }

    #[test]
    fn test_splice_single_full_packet_then_zlp() {
        let packet_data = [42; MAX_PACKET_SIZE];
        let packet = FakeUsbPacket {
            data: &packet_data,
            ep: 0,
        };

        let mut transfer = Transfer::<32>::new();
        let result = transfer.splice(packet).unwrap();

        assert!(result.is_none());

        let zlp = FakeUsbPacket { data: &[], ep: 0 };
        let result = transfer.splice(zlp).unwrap();
        assert!(result.is_some());
        assert_eq!(result.unwrap().as_ref(), &packet_data[..]);
    }

    #[test]
    fn test_splice_multiple_packets() {
        let packet1_data = [1; MAX_PACKET_SIZE];
        let packet2_data = [2; MAX_PACKET_SIZE];
        let packet3_data = [3; 32];

        // Packet 1
        let packet1 = FakeUsbPacket {
            data: &packet1_data,
            ep: 0,
        };
        let mut transfer = Transfer::<64>::new();
        let result = transfer.splice(packet1).unwrap();
        assert!(result.is_none());

        // Packet 2
        let packet2 = FakeUsbPacket {
            data: &packet2_data,
            ep: 0,
        };
        let result = transfer.splice(packet2).unwrap();
        assert!(result.is_none());

        // Packet 3 (short packet)
        let packet3 = FakeUsbPacket {
            data: &packet3_data,
            ep: 0,
        };
        let result = transfer.splice(packet3).unwrap();
        assert!(result.is_some());

        let mut expected_data = [0u8; 2 * MAX_PACKET_SIZE + 32];
        expected_data[..MAX_PACKET_SIZE].copy_from_slice(&packet1_data);
        expected_data[MAX_PACKET_SIZE..2 * MAX_PACKET_SIZE].copy_from_slice(&packet2_data);
        expected_data[2 * MAX_PACKET_SIZE..].copy_from_slice(&packet3_data);

        assert_eq!(result.unwrap().as_ref(), &expected_data[..]);
    }

    #[test]
    fn test_splice_buffer_overflow() {
        let packet_data = [1; 1];
        let packet = FakeUsbPacket {
            data: &packet_data,
            ep: 0,
        };

        let mut transfer = Transfer::<16>::new();
        transfer
            .splice(FakeUsbPacket {
                data: &[0; MAX_PACKET_SIZE],
                ep: 0,
            })
            .unwrap();
        let result = transfer.splice(packet);
        assert_eq!(result.err(), Some(Error::OutOfRange));
    }

    #[test]
    fn test_full_capacity_with_full_packets_then_partial_packet() {
        const PARTIAL_SIZE: usize = 16;
        const FULL1_DATA: &[u8] = &[0xaa; MAX_PACKET_SIZE];
        const FULL2_DATA: &[u8] = &[0xbb; MAX_PACKET_SIZE];
        const PARTIAL_DATA: &[u8] = &[0xcc; PARTIAL_SIZE];
        const RECEIVE_BUFFER_WORDS: usize =
            (FULL1_DATA.len() + FULL2_DATA.len() + PARTIAL_DATA.len()) / size_of::<u32>();
        let full1 = FakeUsbPacket {
            data: FULL1_DATA,
            ep: 0,
        };
        let full2 = FakeUsbPacket {
            data: FULL2_DATA,
            ep: 0,
        };
        let partial = FakeUsbPacket {
            data: PARTIAL_DATA,
            ep: 0,
        };
        let mut transfer = Transfer::<RECEIVE_BUFFER_WORDS>::new();
        assert!(transfer.splice(full1).unwrap().is_none());
        assert!(transfer.splice(full2).unwrap().is_none());
        let buffer = transfer.splice(partial).unwrap().unwrap().as_ref();
        assert_eq!(&buffer[..MAX_PACKET_SIZE], FULL1_DATA);
        assert_eq!(&buffer[MAX_PACKET_SIZE..2 * MAX_PACKET_SIZE], FULL2_DATA);
    }
}

#[cfg(test)]
mod simple_ep0_tests {
    use super::*;
    use aligned::Aligned;
    use aligned::A4;
    use hal_usb::Request;
    use hal_usb::SetupPacket;
    use hal_usb::StringDescriptorRef;
    use hal_usb::StringHandle;

    struct DummyDescriptors;
    impl DescriptorSource for DummyDescriptors {
        const DEVICE_DESC_BYTES: &'static Aligned<A4, [u8]> = &Aligned([]);
        const CONFIG_DESC_BYTES: &'static Aligned<A4, [u8]> = &Aligned([]);
        const STRING_DESC_0_BYTES: &'static Aligned<A4, [u8]> = &Aligned([]);
        const DEVICE_STATUS: Aligned<A4, [u8; 2]> = Aligned([0, 0]);

        fn get_string(&self, _handle: StringHandle, _lang: u16) -> Option<StringDescriptorRef<'_>> {
            None
        }
    }

    fn unwrap_action<'a, P: UsbPacket>(res: Result<UsbAction<'a>, UsbEvent<P>>) -> UsbAction<'a> {
        match res {
            Ok(a) => a,
            Err(_) => panic!("Expected Ok action"),
        }
    }

    #[test]
    fn test_set_configuration() {
        let mut ep0 = SimpleEp0::new();
        let descriptors = DummyDescriptors;

        // Value = 0 (de-configure/address state) should be accepted
        let req = Request::DEVICE_SET_CONFIGURATION;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0]);
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(
            action,
            UsbAction::TransferIn {
                endpoint: 0,
                zlp: true,
                ..
            }
        ));

        // Value = 1 (active configuration) should be accepted
        let buf0 = (u16::from(req) as u32) | (1u32 << 16);
        let setup_pkt = SetupPacket::new([buf0, 0]);
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(
            action,
            UsbAction::TransferIn {
                endpoint: 0,
                zlp: true,
                ..
            }
        ));

        // Value = 2 (invalid configuration) should be stalled
        let buf0 = (u16::from(req) as u32) | (2u32 << 16);
        let setup_pkt = SetupPacket::new([buf0, 0]);
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(action, UsbAction::StallInAndOut { endpoint: 0 }));
    }

    #[test]
    fn test_get_configuration() {
        let mut ep0 = SimpleEp0::new();
        let descriptors = DummyDescriptors;

        // Initial state should be unconfigured (0)
        let req = Request::DEVICE_GET_CONFIGURATION;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0001_0000]); // Length = 1
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0]);
        } else {
            panic!("Expected TransferIn action");
        }

        // Set configuration to 1
        let req_set = Request::DEVICE_SET_CONFIGURATION;
        let buf0 = (u16::from(req_set) as u32) | (1u32 << 16);
        let setup_pkt = SetupPacket::new([buf0, 0]);
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let _ = ep0.handle_event(ev, &descriptors);

        // Now GET_CONFIGURATION should return 1
        let req_get = Request::DEVICE_GET_CONFIGURATION;
        let buf0 = u16::from(req_get) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0001_0000]); // Length = 1
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[1]);
        } else {
            panic!("Expected TransferIn action");
        }

        // USB reset should reset configuration back to 0
        let ev_reset: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::UsbReset;
        let _ = ep0.handle_event(ev_reset, &descriptors);

        // Now GET_CONFIGURATION should return 0
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0]);
        } else {
            panic!("Expected TransferIn action");
        }
    }

    #[test]
    fn test_get_status() {
        let mut ep0 = SimpleEp0::new();
        let descriptors = DummyDescriptors;

        // Device recipient
        let req = Request::DEVICE_GET_STATUS;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0002_0000]); // Length = 2
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0, 0]);
        } else {
            panic!("Expected TransferIn action");
        }

        // Interface recipient
        let req = Request::INTERFACE_GET_STATUS;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0002_0000]); // Length = 2
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0, 0]);
        } else {
            panic!("Expected TransferIn action");
        }

        // Endpoint recipient
        let req = Request::ENDPOINT_GET_STATUS;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0002_0000]); // Length = 2
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0, 0]);
        } else {
            panic!("Expected TransferIn action");
        }
    }

    #[test]
    fn test_fallback_interface_requests() {
        let mut ep0 = SimpleEp0::new();
        let descriptors = DummyDescriptors;

        // GET_INTERFACE should return alternate setting 0
        let req = Request::INTERFACE_GET_INTERFACE;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0001_0000]); // Length = 1
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0]);
        } else {
            panic!("Expected TransferIn action");
        }

        // SET_INTERFACE with alternate setting 0 should succeed
        let req = Request::INTERFACE_SET_INTERFACE;
        let buf0 = u16::from(req) as u32; // Value = 0
        let setup_pkt = SetupPacket::new([buf0, 0]);
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(
            action,
            UsbAction::TransferIn {
                endpoint: 0,
                zlp: true,
                ..
            }
        ));

        // SET_INTERFACE with alternate setting 1 should be stalled (only 0 supported as fallback)
        let buf0 = (u16::from(req) as u32) | (1u32 << 16); // Value = 1
        let setup_pkt = SetupPacket::new([buf0, 0]);
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(action, UsbAction::StallInAndOut { endpoint: 0 }));
    }

    #[test]
    fn test_endpoint_halt_requests() {
        let mut ep0 = SimpleEp0::new();
        let descriptors = DummyDescriptors;

        // 1. Check Endpoint 1 IN status (initially not halted)
        let req = Request::ENDPOINT_GET_STATUS;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0002_0081]); // Length = 2, Endpoint = 0x81 (1 IN)
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0, 0]);
        } else {
            panic!("Expected TransferIn action");
        }

        // 2. SET_FEATURE(ENDPOINT_HALT) to Endpoint 1 IN
        let req = Request::ENDPOINT_SET_FEATURE;
        let buf0 = u16::from(req) as u32; // Value = 0 (ENDPOINT_HALT)
        let setup_pkt = SetupPacket::new([buf0, 0x0000_0081]); // Endpoint = 0x81
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(
            action,
            UsbAction::TransferIn {
                endpoint: 0,
                zlp: true,
                ..
            }
        ));

        // Verify that handle_packet_sent returns EndpointHalt action
        let action_sent = ep0.handle_packet_sent();
        assert!(matches!(
            action_sent,
            UsbAction::EndpointHalt {
                endpoint_addr: 0x81,
                halted: true
            }
        ));

        // 3. Check Endpoint 1 IN status again (should be halted)
        let req = Request::ENDPOINT_GET_STATUS;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0002_0081]); // Length = 2, Endpoint = 0x81
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[1, 0]); // Halt bit set
        } else {
            panic!("Expected TransferIn action");
        }

        // 4. CLEAR_FEATURE(ENDPOINT_HALT) to Endpoint 1 IN
        let req = Request::ENDPOINT_CLEAR_FEATURE;
        let buf0 = u16::from(req) as u32; // Value = 0 (ENDPOINT_HALT)
        let setup_pkt = SetupPacket::new([buf0, 0x0000_0081]); // Endpoint = 0x81
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(
            action,
            UsbAction::TransferIn {
                endpoint: 0,
                zlp: true,
                ..
            }
        ));

        // Verify that handle_packet_sent returns EndpointHalt action (halted = false)
        let action_sent = ep0.handle_packet_sent();
        assert!(matches!(
            action_sent,
            UsbAction::EndpointHalt {
                endpoint_addr: 0x81,
                halted: false
            }
        ));

        // 5. Check Endpoint 1 IN status again (should be not halted)
        let req = Request::ENDPOINT_GET_STATUS;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0002_0081]); // Length = 2, Endpoint = 0x81
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        if let UsbAction::TransferIn {
            endpoint: 0, data, ..
        } = action
        {
            assert_eq!(data.as_ref(), &[0, 0]);
        } else {
            panic!("Expected TransferIn action");
        }

        // 6. Trying to halt Endpoint 0 should fail/stall
        let req = Request::ENDPOINT_SET_FEATURE;
        let buf0 = u16::from(req) as u32;
        let setup_pkt = SetupPacket::new([buf0, 0x0000_0000]); // Endpoint = 0
        let ev: UsbEvent<testing::FakeUsbPacket<'static>> = UsbEvent::SetupPacket {
            endpoint: 0,
            pkt: setup_pkt,
        };
        let action = unwrap_action(ep0.handle_event(ev, &descriptors));
        assert!(matches!(action, UsbAction::StallInAndOut { endpoint: 0 }));
    }
}