lcpfs 2026.1.102

// Copyright 2025 LunaOS Contributors
// SPDX-License-Identifier: Apache-2.0

//! NFSv4 operation definitions.
//!
//! This module defines the NFSv4 operations (opcodes) and their request/response
//! structures as defined in RFC 7530.

use alloc::string::String;
use alloc::vec::Vec;

use super::error::NfsStatus;
use super::types::{
    AccessBits, AttrBitmap, ClientId, DirEntry, FileHandle, FsInfo, FsStat, LockRange, LockType,
    NfsAttr, OpenMode, SessionId, SetAttr, ShareAccess, ShareDeny, StateId, Verifier,
};

// ═══════════════════════════════════════════════════════════════════════════════
// OPERATION CODES
// ═══════════════════════════════════════════════════════════════════════════════

/// NFSv4 operation codes (RFC 7530).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum Opcode {
    /// Access check.
    Access = 3,
    /// Close file.
    Close = 4,
    /// Commit writes.
    Commit = 5,
    /// Create file/dir.
    Create = 6,
    /// Delegate purge.
    DelegatePurge = 7,
    /// Delegate return.
    DelegateReturn = 8,
    /// Get attributes.
    Getattr = 9,
    /// Get current file handle.
    Getfh = 10,
    /// Create hard link.
    Link = 11,
    /// Lock file.
    Lock = 12,
    /// Test lock.
    Lockt = 13,
    /// Unlock file.
    Locku = 14,
    /// Lookup name.
    Lookup = 15,
    /// Lookup parent.
    Lookupp = 16,
    /// No operation.
    Nverify = 17,
    /// Open file.
    Open = 18,
    /// Open attribute.
    Openattr = 19,
    /// Open confirm.
    OpenConfirm = 20,
    /// Open downgrade.
    OpenDowngrade = 21,
    /// Put file handle.
    Putfh = 22,
    /// Put public file handle.
    Putpubfh = 23,
    /// Put root file handle.
    Putrootfh = 24,
    /// Read data.
    Read = 25,
    /// Read directory.
    Readdir = 26,
    /// Read link.
    Readlink = 27,
    /// Remove file.
    Remove = 28,
    /// Rename file.
    Rename = 29,
    /// Renew lease.
    Renew = 30,
    /// Restore file handle.
    Restorefh = 31,
    /// Save file handle.
    Savefh = 32,
    /// Security info.
    Secinfo = 33,
    /// Set attributes.
    Setattr = 34,
    /// Set client ID.
    Setclientid = 35,
    /// Confirm client ID.
    SetclientidConfirm = 36,
    /// Verify attributes.
    Verify = 37,
    /// Write data.
    Write = 38,
    /// Release lock owner.
    ReleaseLockowner = 39,

    // NFSv4.1 operations
    /// Backchannel control.
    BackchannelCtl = 40,
    /// Bind connection to session.
    BindConnToSession = 41,
    /// Exchange ID.
    ExchangeId = 42,
    /// Create session.
    CreateSession = 43,
    /// Destroy session.
    DestroySession = 44,
    /// Free state ID.
    FreeStateid = 45,
    /// Get device info.
    GetDeviceinfo = 47,
    /// Get device list.
    GetDevicelist = 48,
    /// Layout commit.
    Layoutcommit = 49,
    /// Layout get.
    Layoutget = 50,
    /// Layout return.
    Layoutreturn = 51,
    /// Security info (no name).
    SecinfoNoName = 52,
    /// Sequence.
    Sequence = 53,
    /// Set SSV.
    SetSsv = 54,
    /// Test state ID.
    TestStateid = 55,
    /// Want delegation.
    WantDelegation = 56,
    /// Destroy client ID.
    DestroyClientid = 57,
    /// Reclaim complete.
    ReclaimComplete = 58,

    /// Illegal operation.
    Illegal = 10044,
}

impl Opcode {
    /// Convert from raw u32.
    pub fn from_u32(v: u32) -> Option<Self> {
        match v {
            3 => Some(Self::Access),
            4 => Some(Self::Close),
            5 => Some(Self::Commit),
            6 => Some(Self::Create),
            7 => Some(Self::DelegatePurge),
            8 => Some(Self::DelegateReturn),
            9 => Some(Self::Getattr),
            10 => Some(Self::Getfh),
            11 => Some(Self::Link),
            12 => Some(Self::Lock),
            13 => Some(Self::Lockt),
            14 => Some(Self::Locku),
            15 => Some(Self::Lookup),
            16 => Some(Self::Lookupp),
            17 => Some(Self::Nverify),
            18 => Some(Self::Open),
            19 => Some(Self::Openattr),
            20 => Some(Self::OpenConfirm),
            21 => Some(Self::OpenDowngrade),
            22 => Some(Self::Putfh),
            23 => Some(Self::Putpubfh),
            24 => Some(Self::Putrootfh),
            25 => Some(Self::Read),
            26 => Some(Self::Readdir),
            27 => Some(Self::Readlink),
            28 => Some(Self::Remove),
            29 => Some(Self::Rename),
            30 => Some(Self::Renew),
            31 => Some(Self::Restorefh),
            32 => Some(Self::Savefh),
            33 => Some(Self::Secinfo),
            34 => Some(Self::Setattr),
            35 => Some(Self::Setclientid),
            36 => Some(Self::SetclientidConfirm),
            37 => Some(Self::Verify),
            38 => Some(Self::Write),
            39 => Some(Self::ReleaseLockowner),
            40 => Some(Self::BackchannelCtl),
            41 => Some(Self::BindConnToSession),
            42 => Some(Self::ExchangeId),
            43 => Some(Self::CreateSession),
            44 => Some(Self::DestroySession),
            45 => Some(Self::FreeStateid),
            47 => Some(Self::GetDeviceinfo),
            48 => Some(Self::GetDevicelist),
            49 => Some(Self::Layoutcommit),
            50 => Some(Self::Layoutget),
            51 => Some(Self::Layoutreturn),
            52 => Some(Self::SecinfoNoName),
            53 => Some(Self::Sequence),
            54 => Some(Self::SetSsv),
            55 => Some(Self::TestStateid),
            56 => Some(Self::WantDelegation),
            57 => Some(Self::DestroyClientid),
            58 => Some(Self::ReclaimComplete),
            10044 => Some(Self::Illegal),
            _ => None,
        }
    }

    /// Get the operation name.
    pub fn name(&self) -> &'static str {
        match self {
            Self::Access => "ACCESS",
            Self::Close => "CLOSE",
            Self::Commit => "COMMIT",
            Self::Create => "CREATE",
            Self::DelegatePurge => "DELEGPURGE",
            Self::DelegateReturn => "DELEGRETURN",
            Self::Getattr => "GETATTR",
            Self::Getfh => "GETFH",
            Self::Link => "LINK",
            Self::Lock => "LOCK",
            Self::Lockt => "LOCKT",
            Self::Locku => "LOCKU",
            Self::Lookup => "LOOKUP",
            Self::Lookupp => "LOOKUPP",
            Self::Nverify => "NVERIFY",
            Self::Open => "OPEN",
            Self::Openattr => "OPENATTR",
            Self::OpenConfirm => "OPEN_CONFIRM",
            Self::OpenDowngrade => "OPEN_DOWNGRADE",
            Self::Putfh => "PUTFH",
            Self::Putpubfh => "PUTPUBFH",
            Self::Putrootfh => "PUTROOTFH",
            Self::Read => "READ",
            Self::Readdir => "READDIR",
            Self::Readlink => "READLINK",
            Self::Remove => "REMOVE",
            Self::Rename => "RENAME",
            Self::Renew => "RENEW",
            Self::Restorefh => "RESTOREFH",
            Self::Savefh => "SAVEFH",
            Self::Secinfo => "SECINFO",
            Self::Setattr => "SETATTR",
            Self::Setclientid => "SETCLIENTID",
            Self::SetclientidConfirm => "SETCLIENTID_CONFIRM",
            Self::Verify => "VERIFY",
            Self::Write => "WRITE",
            Self::ReleaseLockowner => "RELEASE_LOCKOWNER",
            Self::BackchannelCtl => "BACKCHANNEL_CTL",
            Self::BindConnToSession => "BIND_CONN_TO_SESSION",
            Self::ExchangeId => "EXCHANGE_ID",
            Self::CreateSession => "CREATE_SESSION",
            Self::DestroySession => "DESTROY_SESSION",
            Self::FreeStateid => "FREE_STATEID",
            Self::GetDeviceinfo => "GETDEVICEINFO",
            Self::GetDevicelist => "GETDEVICELIST",
            Self::Layoutcommit => "LAYOUTCOMMIT",
            Self::Layoutget => "LAYOUTGET",
            Self::Layoutreturn => "LAYOUTRETURN",
            Self::SecinfoNoName => "SECINFO_NO_NAME",
            Self::Sequence => "SEQUENCE",
            Self::SetSsv => "SET_SSV",
            Self::TestStateid => "TEST_STATEID",
            Self::WantDelegation => "WANT_DELEGATION",
            Self::DestroyClientid => "DESTROY_CLIENTID",
            Self::ReclaimComplete => "RECLAIM_COMPLETE",
            Self::Illegal => "ILLEGAL",
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// OPERATION ARGUMENTS
// ═══════════════════════════════════════════════════════════════════════════════

/// PUTFH arguments.
#[derive(Debug, Clone)]
pub struct PutfhArgs {
    /// File handle.
    pub fh: FileHandle,
}

/// LOOKUP arguments.
#[derive(Debug, Clone)]
pub struct LookupArgs {
    /// Name to look up.
    pub name: String,
}

/// GETATTR arguments.
#[derive(Debug, Clone)]
pub struct GetattrArgs {
    /// Attribute bitmap.
    pub attr_request: AttrBitmap,
}

/// ACCESS arguments.
#[derive(Debug, Clone)]
pub struct AccessArgs {
    /// Access bits to check.
    pub access: AccessBits,
}

/// READ arguments.
#[derive(Debug, Clone)]
pub struct ReadArgs {
    /// State ID.
    pub stateid: StateId,
    /// Offset to read from.
    pub offset: u64,
    /// Number of bytes to read.
    pub count: u32,
}

/// WRITE arguments.
#[derive(Debug, Clone)]
pub struct WriteArgs {
    /// State ID.
    pub stateid: StateId,
    /// Offset to write at.
    pub offset: u64,
    /// Stability mode.
    pub stable: StableHow,
    /// Data to write.
    pub data: Vec<u8>,
}

/// WRITE stability mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum StableHow {
    /// Unstable (async).
    Unstable = 0,
    /// Data sync.
    DataSync = 1,
    /// File sync.
    FileSync = 2,
}

/// OPEN arguments.
#[derive(Debug, Clone)]
pub struct OpenArgs {
    /// Sequence ID.
    pub seqid: u32,
    /// Share access.
    pub share_access: ShareAccess,
    /// Share deny.
    pub share_deny: ShareDeny,
    /// Owner.
    pub owner: StateOwner,
    /// Open type.
    pub open_type: OpenType,
    /// File name (for create/open).
    pub name: Option<String>,
}

/// Open type.
#[derive(Debug, Clone)]
pub enum OpenType {
    /// Open existing file.
    NoCreate,
    /// Create file.
    Create {
        /// Create mode.
        mode: OpenMode,
        /// Attributes for new file.
        attrs: SetAttr,
        /// Verifier for exclusive create.
        verifier: Option<Verifier>,
    },
}

/// State owner.
#[derive(Debug, Clone)]
pub struct StateOwner {
    /// Client ID.
    pub clientid: ClientId,
    /// Owner string.
    pub owner: Vec<u8>,
}

/// CLOSE arguments.
#[derive(Debug, Clone)]
pub struct CloseArgs {
    /// Sequence ID.
    pub seqid: u32,
    /// State ID.
    pub stateid: StateId,
}

/// READDIR arguments.
#[derive(Debug, Clone)]
pub struct ReaddirArgs {
    /// Cookie.
    pub cookie: u64,
    /// Cookie verifier.
    pub cookieverf: Verifier,
    /// Max directory bytes.
    pub dircount: u32,
    /// Max response bytes.
    pub maxcount: u32,
    /// Attribute request.
    pub attr_request: AttrBitmap,
}

/// CREATE arguments.
#[derive(Debug, Clone)]
pub struct CreateArgs {
    /// Object type.
    pub obj_type: CreateType,
    /// Object name.
    pub name: String,
    /// Attributes.
    pub attrs: SetAttr,
}

/// Object type for CREATE.
#[derive(Debug, Clone)]
pub enum CreateType {
    /// Regular file (not typically used, use OPEN).
    Regular,
    /// Directory.
    Directory,
    /// Symbolic link.
    Symlink(String),
    /// Block device.
    Block {
        /// Major device number.
        major: u32,
        /// Minor device number.
        minor: u32,
    },
    /// Character device.
    Char {
        /// Major device number.
        major: u32,
        /// Minor device number.
        minor: u32,
    },
    /// Socket.
    Socket,
    /// FIFO.
    Fifo,
}

/// REMOVE arguments.
#[derive(Debug, Clone)]
pub struct RemoveArgs {
    /// Target name.
    pub target: String,
}

/// RENAME arguments.
#[derive(Debug, Clone)]
pub struct RenameArgs {
    /// Old name.
    pub oldname: String,
    /// New name.
    pub newname: String,
}

/// LINK arguments.
#[derive(Debug, Clone)]
pub struct LinkArgs {
    /// New link name.
    pub newname: String,
}

/// SETATTR arguments.
#[derive(Debug, Clone)]
pub struct SetattrArgs {
    /// State ID (for size changes).
    pub stateid: StateId,
    /// Attributes to set.
    pub attrs: SetAttr,
}

/// LOCK arguments.
#[derive(Debug, Clone)]
pub struct LockArgs {
    /// Lock type.
    pub locktype: LockType,
    /// Reclaim flag.
    pub reclaim: bool,
    /// Offset.
    pub offset: u64,
    /// Length.
    pub length: u64,
    /// Lock owner.
    pub locker: Locker,
}

/// Lock owner (new or existing).
#[derive(Debug, Clone)]
pub enum Locker {
    /// New lock owner.
    New {
        /// Open sequence ID.
        open_seqid: u32,
        /// Open state ID.
        open_stateid: StateId,
        /// Lock sequence ID.
        lock_seqid: u32,
        /// Lock owner.
        lock_owner: StateOwner,
    },
    /// Existing lock owner.
    Existing {
        /// Lock state ID.
        lock_stateid: StateId,
        /// Lock sequence ID.
        lock_seqid: u32,
    },
}

/// LOCKT arguments.
#[derive(Debug, Clone)]
pub struct LocktArgs {
    /// Lock type.
    pub locktype: LockType,
    /// Offset.
    pub offset: u64,
    /// Length.
    pub length: u64,
    /// Lock owner.
    pub owner: StateOwner,
}

/// LOCKU arguments.
#[derive(Debug, Clone)]
pub struct LockuArgs {
    /// Lock type.
    pub locktype: LockType,
    /// Sequence ID.
    pub seqid: u32,
    /// Lock state ID.
    pub lock_stateid: StateId,
    /// Offset.
    pub offset: u64,
    /// Length.
    pub length: u64,
}

/// COMMIT arguments.
#[derive(Debug, Clone)]
pub struct CommitArgs {
    /// Offset.
    pub offset: u64,
    /// Count (0 = all).
    pub count: u32,
}

/// SETCLIENTID arguments.
#[derive(Debug, Clone)]
pub struct SetclientidArgs {
    /// Client verifier.
    pub verifier: Verifier,
    /// Client owner.
    pub id: Vec<u8>,
    /// Callback program.
    pub callback_program: u32,
    /// Callback network ID.
    pub callback_netid: String,
    /// Callback address.
    pub callback_addr: String,
    /// Callback ID.
    pub callback_ident: u32,
}

/// SETCLIENTID_CONFIRM arguments.
#[derive(Debug, Clone)]
pub struct SetclientidConfirmArgs {
    /// Client ID.
    pub clientid: ClientId,
    /// Verifier.
    pub verifier: Verifier,
}

/// RENEW arguments.
#[derive(Debug, Clone)]
pub struct RenewArgs {
    /// Client ID.
    pub clientid: ClientId,
}

// NFSv4.1 Operations

/// EXCHANGE_ID arguments.
#[derive(Debug, Clone)]
pub struct ExchangeIdArgs {
    /// Client owner.
    pub client_owner: ClientOwner4,
    /// Flags.
    pub flags: u32,
    /// State protect.
    pub state_protect: StateProtect4A,
    /// Implementation ID.
    pub impl_id: Vec<NfsImplId4>,
}

/// Client owner for NFSv4.1.
#[derive(Debug, Clone)]
pub struct ClientOwner4 {
    /// Verifier.
    pub verifier: Verifier,
    /// Owner ID.
    pub ownerid: Vec<u8>,
}

/// State protection type.
#[derive(Debug, Clone)]
pub enum StateProtect4A {
    /// No protection.
    None,
    /// Machine credential.
    MachCred { ops: Vec<u32> },
    /// SSV.
    Ssv {
        ssv_ops: Vec<u32>,
        hash_algs: Vec<u32>,
        encrypt_algs: Vec<u32>,
    },
}

/// Implementation ID.
#[derive(Debug, Clone)]
pub struct NfsImplId4 {
    /// Domain.
    pub domain: String,
    /// Name.
    pub name: String,
    /// Date.
    pub date: u64,
}

/// CREATE_SESSION arguments.
#[derive(Debug, Clone)]
pub struct CreateSessionArgs {
    /// Client ID.
    pub clientid: ClientId,
    /// Sequence ID.
    pub seqid: u32,
    /// Flags.
    pub flags: u32,
    /// Fore channel attrs.
    pub fore_chan_attrs: ChannelAttrs4,
    /// Back channel attrs.
    pub back_chan_attrs: ChannelAttrs4,
    /// Callback program.
    pub cb_program: u32,
    /// Security parameters.
    pub sec_parms: Vec<CallbackSecParms4>,
}

/// Channel attributes.
#[derive(Debug, Clone)]
pub struct ChannelAttrs4 {
    /// Header padding.
    pub header_pad_size: u32,
    /// Max request size.
    pub max_req_size: u32,
    /// Max response size.
    pub max_resp_size: u32,
    /// Max response size (cached).
    pub max_resp_size_cached: u32,
    /// Max operations.
    pub max_ops: u32,
    /// Max requests.
    pub max_reqs: u32,
    /// RDMA IORDs.
    pub rdma_ird: Vec<u32>,
}

/// Callback security parameters.
#[derive(Debug, Clone)]
pub struct CallbackSecParms4 {
    /// Security flavor.
    pub flavor: u32,
    /// Auth sys (if flavor == 1).
    pub auth_sys: Option<AuthSys>,
}

/// AUTH_SYS credentials.
#[derive(Debug, Clone)]
pub struct AuthSys {
    /// Stamp.
    pub stamp: u32,
    /// Machine name.
    pub machinename: String,
    /// UID.
    pub uid: u32,
    /// GID.
    pub gid: u32,
    /// Auxiliary GIDs.
    pub gids: Vec<u32>,
}

/// SEQUENCE arguments.
#[derive(Debug, Clone)]
pub struct SequenceArgs {
    /// Session ID.
    pub sessionid: SessionId,
    /// Sequence ID.
    pub sequenceid: u32,
    /// Slot ID.
    pub slotid: u32,
    /// Highest slot.
    pub highest_slotid: u32,
    /// Cachethis flag.
    pub cachethis: bool,
}

/// DESTROY_SESSION arguments.
#[derive(Debug, Clone)]
pub struct DestroySessionArgs {
    /// Session ID.
    pub sessionid: SessionId,
}

/// RECLAIM_COMPLETE arguments.
#[derive(Debug, Clone)]
pub struct ReclaimCompleteArgs {
    /// One filesystem only.
    pub one_fs: bool,
}

// ═══════════════════════════════════════════════════════════════════════════════
// OPERATION RESULTS
// ═══════════════════════════════════════════════════════════════════════════════

/// GETFH result.
#[derive(Debug, Clone)]
pub struct GetfhResult {
    /// File handle.
    pub fh: FileHandle,
}

/// GETATTR result.
#[derive(Debug, Clone)]
pub struct GetattrResult {
    /// Attributes.
    pub attrs: NfsAttr,
    /// Returned attribute bitmap.
    pub attrmask: AttrBitmap,
}

/// ACCESS result.
#[derive(Debug, Clone)]
pub struct AccessResult {
    /// Supported access.
    pub supported: AccessBits,
    /// Access granted.
    pub access: AccessBits,
}

/// READ result.
#[derive(Debug, Clone)]
pub struct ReadResult {
    /// End of file.
    pub eof: bool,
    /// Data read.
    pub data: Vec<u8>,
}

/// WRITE result.
#[derive(Debug, Clone)]
pub struct WriteResult {
    /// Bytes written.
    pub count: u32,
    /// Stability.
    pub committed: StableHow,
    /// Write verifier.
    pub verifier: Verifier,
}

/// OPEN result.
#[derive(Debug, Clone)]
pub struct OpenResult {
    /// State ID.
    pub stateid: StateId,
    /// Change info.
    pub cinfo: ChangeInfo,
    /// Result flags.
    pub rflags: u32,
    /// Attribute set.
    pub attrset: AttrBitmap,
    /// Delegation type.
    pub delegation: Delegation,
}

/// Change info for operations.
#[derive(Debug, Clone, Copy)]
pub struct ChangeInfo {
    /// Atomic change.
    pub atomic: bool,
    /// Before value.
    pub before: u64,
    /// After value.
    pub after: u64,
}

/// Delegation type.
#[derive(Debug, Clone)]
pub enum Delegation {
    /// No delegation.
    None,
    /// Read delegation.
    Read {
        /// State ID.
        stateid: StateId,
        /// Recall flag.
        recall: bool,
        /// ACE permissions.
        permissions: u32,
    },
    /// Write delegation.
    Write {
        /// State ID.
        stateid: StateId,
        /// Recall flag.
        recall: bool,
        /// Space limit.
        space_limit: Option<u64>,
        /// ACE permissions.
        permissions: u32,
    },
}

/// CLOSE result.
#[derive(Debug, Clone)]
pub struct CloseResult {
    /// Final state ID.
    pub stateid: StateId,
}

/// READDIR result.
#[derive(Debug, Clone)]
pub struct ReaddirResult {
    /// Cookie verifier.
    pub cookieverf: Verifier,
    /// Directory entries.
    pub entries: Vec<DirEntry>,
    /// End of directory.
    pub eof: bool,
}

/// LOOKUP result (empty, success indicated by status).
#[derive(Debug, Clone, Copy)]
pub struct LookupResult;

/// CREATE result.
#[derive(Debug, Clone)]
pub struct CreateResult {
    /// Change info.
    pub cinfo: ChangeInfo,
    /// Attributes set.
    pub attrset: AttrBitmap,
}

/// REMOVE result.
#[derive(Debug, Clone)]
pub struct RemoveResult {
    /// Change info.
    pub cinfo: ChangeInfo,
}

/// RENAME result.
#[derive(Debug, Clone)]
pub struct RenameResult {
    /// Source change info.
    pub source_cinfo: ChangeInfo,
    /// Target change info.
    pub target_cinfo: ChangeInfo,
}

/// LINK result.
#[derive(Debug, Clone)]
pub struct LinkResult {
    /// Change info.
    pub cinfo: ChangeInfo,
}

/// SETATTR result.
#[derive(Debug, Clone)]
pub struct SetattrResult {
    /// Attributes set.
    pub attrsset: AttrBitmap,
}

/// READLINK result.
#[derive(Debug, Clone)]
pub struct ReadlinkResult {
    /// Link target.
    pub link: String,
}

/// LOCK result.
#[derive(Debug, Clone)]
pub struct LockResult {
    /// Lock state ID.
    pub lock_stateid: StateId,
}

/// LOCK denied result.
#[derive(Debug, Clone)]
pub struct LockDenied {
    /// Offset.
    pub offset: u64,
    /// Length.
    pub length: u64,
    /// Lock type.
    pub locktype: LockType,
    /// Owner.
    pub owner: StateOwner,
}

/// LOCKU result.
#[derive(Debug, Clone)]
pub struct LockuResult {
    /// New lock state ID.
    pub lock_stateid: StateId,
}

/// COMMIT result.
#[derive(Debug, Clone)]
pub struct CommitResult {
    /// Write verifier.
    pub verifier: Verifier,
}

/// SETCLIENTID result.
#[derive(Debug, Clone)]
pub struct SetclientidResult {
    /// Client ID.
    pub clientid: ClientId,
    /// Verifier.
    pub verifier: Verifier,
}

/// EXCHANGE_ID result.
#[derive(Debug, Clone)]
pub struct ExchangeIdResult {
    /// Client ID.
    pub clientid: ClientId,
    /// Sequence ID.
    pub sequenceid: u32,
    /// Flags.
    pub flags: u32,
    /// State protect.
    pub state_protect: StateProtect4R,
    /// Server owner.
    pub server_owner: ServerOwner4,
    /// Server scope.
    pub server_scope: Vec<u8>,
    /// Implementation ID.
    pub impl_id: Vec<NfsImplId4>,
}

/// State protection result.
#[derive(Debug, Clone)]
pub enum StateProtect4R {
    /// No protection.
    None,
    /// Machine credential.
    MachCred { ops: Vec<u32> },
    /// SSV.
    Ssv { ssv_info: SsvInfo },
}

/// SSV info.
#[derive(Debug, Clone)]
pub struct SsvInfo {
    /// Hash algorithm.
    pub hash_alg: u32,
    /// Encrypt algorithm.
    pub encrypt_alg: u32,
    /// SSV length.
    pub ssv_len: u32,
    /// Window.
    pub window: u32,
    /// Handles.
    pub handles: Vec<Vec<u8>>,
}

/// Server owner.
#[derive(Debug, Clone)]
pub struct ServerOwner4 {
    /// Minor ID.
    pub minor_id: u64,
    /// Major ID.
    pub major_id: Vec<u8>,
}

/// CREATE_SESSION result.
#[derive(Debug, Clone)]
pub struct CreateSessionResult {
    /// Session ID.
    pub sessionid: SessionId,
    /// Sequence ID.
    pub sequenceid: u32,
    /// Flags.
    pub flags: u32,
    /// Fore channel attrs.
    pub fore_chan_attrs: ChannelAttrs4,
    /// Back channel attrs.
    pub back_chan_attrs: ChannelAttrs4,
}

/// SEQUENCE result.
#[derive(Debug, Clone)]
pub struct SequenceResult {
    /// Session ID.
    pub sessionid: SessionId,
    /// Sequence ID.
    pub sequenceid: u32,
    /// Slot ID.
    pub slotid: u32,
    /// Highest slot.
    pub highest_slotid: u32,
    /// Target highest slot.
    pub target_highest_slotid: u32,
    /// Status flags.
    pub status_flags: u32,
}

// ═══════════════════════════════════════════════════════════════════════════════
// COMPOUND REQUEST/RESPONSE
// ═══════════════════════════════════════════════════════════════════════════════

/// NFS COMPOUND request.
#[derive(Debug, Clone)]
pub struct CompoundRequest {
    /// Tag.
    pub tag: String,
    /// Minor version.
    pub minorversion: u32,
    /// Operations.
    pub operations: Vec<Operation>,
}

/// NFS COMPOUND response.
#[derive(Debug, Clone)]
pub struct CompoundResponse {
    /// Status.
    pub status: NfsStatus,
    /// Tag.
    pub tag: String,
    /// Results.
    pub results: Vec<OperationResult>,
}

/// A single NFS operation.
#[derive(Debug, Clone)]
pub enum Operation {
    /// ACCESS.
    Access(AccessArgs),
    /// CLOSE.
    Close(CloseArgs),
    /// COMMIT.
    Commit(CommitArgs),
    /// CREATE.
    Create(CreateArgs),
    /// GETATTR.
    Getattr(GetattrArgs),
    /// GETFH.
    Getfh,
    /// LINK.
    Link(LinkArgs),
    /// LOCK.
    Lock(LockArgs),
    /// LOCKT.
    Lockt(LocktArgs),
    /// LOCKU.
    Locku(LockuArgs),
    /// LOOKUP.
    Lookup(LookupArgs),
    /// LOOKUPP.
    Lookupp,
    /// OPEN.
    Open(OpenArgs),
    /// PUTFH.
    Putfh(PutfhArgs),
    /// PUTPUBFH.
    Putpubfh,
    /// PUTROOTFH.
    Putrootfh,
    /// READ.
    Read(ReadArgs),
    /// READDIR.
    Readdir(ReaddirArgs),
    /// READLINK.
    Readlink,
    /// REMOVE.
    Remove(RemoveArgs),
    /// RENAME.
    Rename(RenameArgs),
    /// RENEW.
    Renew(RenewArgs),
    /// RESTOREFH.
    Restorefh,
    /// SAVEFH.
    Savefh,
    /// SETATTR.
    Setattr(SetattrArgs),
    /// SETCLIENTID.
    Setclientid(SetclientidArgs),
    /// SETCLIENTID_CONFIRM.
    SetclientidConfirm(SetclientidConfirmArgs),
    /// WRITE.
    Write(WriteArgs),
    // NFSv4.1
    /// EXCHANGE_ID.
    ExchangeId(ExchangeIdArgs),
    /// CREATE_SESSION.
    CreateSession(CreateSessionArgs),
    /// DESTROY_SESSION.
    DestroySession(DestroySessionArgs),
    /// SEQUENCE.
    Sequence(SequenceArgs),
    /// RECLAIM_COMPLETE.
    ReclaimComplete(ReclaimCompleteArgs),
}

impl Operation {
    /// Get the opcode for this operation.
    pub fn opcode(&self) -> Opcode {
        match self {
            Self::Access(_) => Opcode::Access,
            Self::Close(_) => Opcode::Close,
            Self::Commit(_) => Opcode::Commit,
            Self::Create(_) => Opcode::Create,
            Self::Getattr(_) => Opcode::Getattr,
            Self::Getfh => Opcode::Getfh,
            Self::Link(_) => Opcode::Link,
            Self::Lock(_) => Opcode::Lock,
            Self::Lockt(_) => Opcode::Lockt,
            Self::Locku(_) => Opcode::Locku,
            Self::Lookup(_) => Opcode::Lookup,
            Self::Lookupp => Opcode::Lookupp,
            Self::Open(_) => Opcode::Open,
            Self::Putfh(_) => Opcode::Putfh,
            Self::Putpubfh => Opcode::Putpubfh,
            Self::Putrootfh => Opcode::Putrootfh,
            Self::Read(_) => Opcode::Read,
            Self::Readdir(_) => Opcode::Readdir,
            Self::Readlink => Opcode::Readlink,
            Self::Remove(_) => Opcode::Remove,
            Self::Rename(_) => Opcode::Rename,
            Self::Renew(_) => Opcode::Renew,
            Self::Restorefh => Opcode::Restorefh,
            Self::Savefh => Opcode::Savefh,
            Self::Setattr(_) => Opcode::Setattr,
            Self::Setclientid(_) => Opcode::Setclientid,
            Self::SetclientidConfirm(_) => Opcode::SetclientidConfirm,
            Self::Write(_) => Opcode::Write,
            Self::ExchangeId(_) => Opcode::ExchangeId,
            Self::CreateSession(_) => Opcode::CreateSession,
            Self::DestroySession(_) => Opcode::DestroySession,
            Self::Sequence(_) => Opcode::Sequence,
            Self::ReclaimComplete(_) => Opcode::ReclaimComplete,
        }
    }
}

/// Result of a single operation.
#[derive(Debug, Clone)]
pub enum OperationResult {
    /// ACCESS result.
    Access(Result<AccessResult, NfsStatus>),
    /// CLOSE result.
    Close(Result<CloseResult, NfsStatus>),
    /// COMMIT result.
    Commit(Result<CommitResult, NfsStatus>),
    /// CREATE result.
    Create(Result<CreateResult, NfsStatus>),
    /// GETATTR result.
    Getattr(Result<GetattrResult, NfsStatus>),
    /// GETFH result.
    Getfh(Result<GetfhResult, NfsStatus>),
    /// LINK result.
    Link(Result<LinkResult, NfsStatus>),
    /// LOCK result.
    Lock(Result<LockResult, NfsStatus>),
    /// LOCKT result (Ok = lock would succeed, Err = denied).
    Lockt(Result<(), LockDenied>),
    /// LOCKU result.
    Locku(Result<LockuResult, NfsStatus>),
    /// LOOKUP result.
    Lookup(Result<LookupResult, NfsStatus>),
    /// LOOKUPP result.
    Lookupp(Result<LookupResult, NfsStatus>),
    /// OPEN result.
    Open(Result<OpenResult, NfsStatus>),
    /// PUTFH result.
    Putfh(Result<(), NfsStatus>),
    /// PUTPUBFH result.
    Putpubfh(Result<(), NfsStatus>),
    /// PUTROOTFH result.
    Putrootfh(Result<(), NfsStatus>),
    /// READ result.
    Read(Result<ReadResult, NfsStatus>),
    /// READDIR result.
    Readdir(Result<ReaddirResult, NfsStatus>),
    /// READLINK result.
    Readlink(Result<ReadlinkResult, NfsStatus>),
    /// REMOVE result.
    Remove(Result<RemoveResult, NfsStatus>),
    /// RENAME result.
    Rename(Result<RenameResult, NfsStatus>),
    /// RENEW result.
    Renew(Result<(), NfsStatus>),
    /// RESTOREFH result.
    Restorefh(Result<(), NfsStatus>),
    /// SAVEFH result.
    Savefh(Result<(), NfsStatus>),
    /// SETATTR result.
    Setattr(Result<SetattrResult, NfsStatus>),
    /// SETCLIENTID result.
    Setclientid(Result<SetclientidResult, NfsStatus>),
    /// SETCLIENTID_CONFIRM result.
    SetclientidConfirm(Result<(), NfsStatus>),
    /// WRITE result.
    Write(Result<WriteResult, NfsStatus>),
    // NFSv4.1
    /// EXCHANGE_ID result.
    ExchangeId(Result<ExchangeIdResult, NfsStatus>),
    /// CREATE_SESSION result.
    CreateSession(Result<CreateSessionResult, NfsStatus>),
    /// DESTROY_SESSION result.
    DestroySession(Result<(), NfsStatus>),
    /// SEQUENCE result.
    Sequence(Result<SequenceResult, NfsStatus>),
    /// RECLAIM_COMPLETE result.
    ReclaimComplete(Result<(), NfsStatus>),
}

impl OperationResult {
    /// Get the status of this result.
    pub fn status(&self) -> NfsStatus {
        match self {
            Self::Access(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Close(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Commit(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Create(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Getattr(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Getfh(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Link(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Lock(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Lockt(r) => {
                if r.is_ok() {
                    NfsStatus::Ok
                } else {
                    NfsStatus::Denied
                }
            }
            Self::Locku(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Lookup(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Lookupp(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Open(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Putfh(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Putpubfh(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Putrootfh(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Read(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Readdir(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Readlink(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Remove(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Rename(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Renew(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Restorefh(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Savefh(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Setattr(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Setclientid(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::SetclientidConfirm(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Write(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::ExchangeId(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::CreateSession(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::DestroySession(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::Sequence(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
            Self::ReclaimComplete(r) => r.as_ref().map(|_| NfsStatus::Ok).unwrap_or_else(|e| *e),
        }
    }

    /// Check if this result is successful.
    pub fn is_ok(&self) -> bool {
        self.status() == NfsStatus::Ok
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// TESTS
// ═══════════════════════════════════════════════════════════════════════════════

#[cfg(test)]
mod tests {
    use super::*;
    use alloc::vec;

    #[test]
    fn test_opcode_from_u32() {
        assert_eq!(Opcode::from_u32(3), Some(Opcode::Access));
        assert_eq!(Opcode::from_u32(25), Some(Opcode::Read));
        assert_eq!(Opcode::from_u32(38), Some(Opcode::Write));
        assert_eq!(Opcode::from_u32(9999), None);
    }

    #[test]
    fn test_opcode_name() {
        assert_eq!(Opcode::Access.name(), "ACCESS");
        assert_eq!(Opcode::Read.name(), "READ");
        assert_eq!(Opcode::Write.name(), "WRITE");
    }

    #[test]
    fn test_stable_how() {
        assert_eq!(StableHow::Unstable as u32, 0);
        assert_eq!(StableHow::DataSync as u32, 1);
        assert_eq!(StableHow::FileSync as u32, 2);
    }

    #[test]
    fn test_change_info() {
        let cinfo = ChangeInfo {
            atomic: true,
            before: 100,
            after: 101,
        };
        assert!(cinfo.atomic);
        assert_eq!(cinfo.before, 100);
        assert_eq!(cinfo.after, 101);
    }

    #[test]
    fn test_operation_opcode() {
        let op = Operation::Lookup(LookupArgs {
            name: "test".into(),
        });
        assert_eq!(op.opcode(), Opcode::Lookup);

        let op2 = Operation::Getfh;
        assert_eq!(op2.opcode(), Opcode::Getfh);
    }

    #[test]
    fn test_operation_result_status() {
        let ok_result = OperationResult::Lookup(Ok(LookupResult));
        assert_eq!(ok_result.status(), NfsStatus::Ok);
        assert!(ok_result.is_ok());

        let err_result = OperationResult::Lookup(Err(NfsStatus::Noent));
        assert_eq!(err_result.status(), NfsStatus::Noent);
        assert!(!err_result.is_ok());
    }

    #[test]
    fn test_compound_request() {
        let req = CompoundRequest {
            tag: "test".into(),
            minorversion: 1,
            operations: vec![
                Operation::Putrootfh,
                Operation::Lookup(LookupArgs { name: "dir".into() }),
                Operation::Getfh,
            ],
        };
        assert_eq!(req.operations.len(), 3);
        assert_eq!(req.minorversion, 1);
    }

    #[test]
    fn test_state_owner() {
        let owner = StateOwner {
            clientid: ClientId::new(12345),
            owner: b"user@host".to_vec(),
        };
        assert_eq!(owner.clientid.id, 12345);
    }

    #[test]
    fn test_delegation_none() {
        let deleg = Delegation::None;
        assert!(matches!(deleg, Delegation::None));
    }

    #[test]
    fn test_locker_new() {
        let locker = Locker::New {
            open_seqid: 1,
            open_stateid: StateId::anonymous(),
            lock_seqid: 1,
            lock_owner: StateOwner {
                clientid: ClientId::new(1),
                owner: vec![],
            },
        };
        assert!(matches!(locker, Locker::New { .. }));
    }

    #[test]
    fn test_create_type() {
        let dir = CreateType::Directory;
        assert!(matches!(dir, CreateType::Directory));

        let symlink = CreateType::Symlink("/target".into());
        assert!(matches!(symlink, CreateType::Symlink(_)));
    }
}