#[derive(Debug, Error)]
pub enum SecureSessionError {
    #[error("inner secure-stream failure: {0}")]
    SecretStream(#[from] SecretStreamError),
    #[error("secure-session transcript failure: {0}")]
    Protocol(#[from] ProtocolError),
    #[error("secure-session handshake or bootstrap confirmation timed out")]
    HandshakeDeadline,
    #[error("secure-session operation was cancelled")]
    Cancelled,
    #[error("invalid secure-session policy: {0}")]
    InvalidPolicy(&'static str),
    #[error("remote bootstrap length exceeds the Protocol 1.0 limit")]
    BootstrapTooLarge,
    #[error("remote bootstrap bytes differ from the local canonical transcript")]
    BootstrapMismatch,
    #[error("replacement produced the prior channel-binding digest")]
    ReusedChannelBinding,
    #[error("replacement context differs from the old session invariant")]
    ReplacementContextMismatch,
    #[error("replacement plan has no remaining monotonic generation")]
    ReplacementGenerationExhausted,
    #[error("operating-system CSPRNG initialization failed")]
    RandomnessUnavailable,
    #[error("flow-credit grant exceeds the configured bounded window")]
    FlowCreditOverflow,
    #[error("session resource limit is exhausted")]
    ResourceLimitExceeded,
    #[error("resource governor denied the requested operation")]
    ResourceGovernorDenied,
}

#[derive(Clone, Debug, Default)]
pub struct SecureSessionOptions {
pub local_key_pair: Option<KeyPair>,
pub expected_remote_noise_static_key: Option<[u8; 32]>,
/// Outer-governed keepalive cadence. Zero disables keepalives.

pub keep_alive_interval: Duration,
/// Inactivity timeout enforced by the inner encrypted stream. Zero disables it.

pub idle_timeout: Duration
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LocalTransportRole {
    Initiator,
    Responder,
}

use zer0_secret_stream::session::AuthenticatedTransport;
# let stream = tokio::io::duplex(64).0;
// No safe `new` constructor exists.
let _ = AuthenticatedTransport::new(stream);

pub struct AuthenticatedTransport<S> {

}

pub unsafe fn from_verified_outer(
        stream: S,
        local_role: LocalTransportRole,
        selected_protocol_id: ProtocolId,
        initiator_peer_id: TransportPeerId,
        responder_peer_id: TransportPeerId,
    ) -> Self;

pub trait SessionClock: Send + Sync {
    fn now_ms(&self) -> u64;
}

#[derive(Clone, Debug, Default)]
pub struct SessionCancellation(CancellationToken);

pub fn new() -> Self;

pub fn cancel(&self);

pub fn is_cancelled(&self) -> bool;

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum SessionPriority {
    Background = 0,
    Normal = 1,
    Interactive = 2,
    Critical = 3,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SessionOperation {
    Read,
    Write,
}

pub trait SessionResourcePermit: Send + Unpin {}

pub trait SessionResourceGovernor: Send + Sync {
    fn poll_acquire(
        &self,
        resource_id: u64,
        priority: SessionPriority,
        operation: SessionOperation,
        requested_bytes: usize,
        cx: &mut Context<'_>,
    ) -> Poll<io::Result<Box<dyn SessionResourcePermit>>>;
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SessionResourceLimits {
/// Maximum raw encrypted inbound bytes admitted across the session.

pub max_read_bytes: u64,
pub max_written_bytes: u64,
/// Maximum authenticated encrypted inbound frames, including keepalives.

pub max_read_operations: u64,
pub max_write_operations: u64,
/// Shared hard ceiling for inbound and outbound keepalive control frames.

pub max_control_operations: u64
}

#[derive(Clone)]
pub struct SessionFlowController(Arc<FlowCreditInner>);

pub fn available(&self) -> usize;

pub fn maximum(&self) -> usize;

pub fn grant(&self, bytes: usize) -> Result<(), SecureSessionError>;

pub struct SessionPolicy {

}

#[allow(clippy::too_many_arguments)]
pub fn new(
        handshake_deadline: Duration,
        stream_deadline: Option<Duration>,
        flow_control_window: usize,
        priority: SessionPriority,
        resource_id: u64,
        cancellation: SessionCancellation,
        resource_limits: SessionResourceLimits,
        governor: Arc<dyn SessionResourceGovernor>,
    ) -> Result<Self, SecureSessionError>;

pub fn handshake_deadline(&self) -> Duration;

pub fn stream_deadline(&self) -> Option<Duration>;

pub fn flow_control_window(&self) -> usize;

pub fn priority(&self) -> SessionPriority;

pub fn resource_id(&self) -> u64;

pub fn cancellation(&self) -> SessionCancellation;

pub fn resource_limits(&self) -> SessionResourceLimits;

#[derive(Debug, PartialEq, Eq)]
pub struct MigrationGeneration(u64);

pub fn initial() -> Self;

pub fn from_persisted(value: u64) -> Self;

pub fn value(&self) -> u64;

#[derive(Debug)]
pub struct ReplacementPlan {

}

pub fn next_generation(&self) -> u64;

pub fn reserve_attempt(&mut self) -> Result<ReplacementAttempt, SecureSessionError>;

#[derive(Debug)]
pub struct ReplacementAttempt {

}

pub fn generation(&self) -> u64;

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SessionResourceSnapshot {
pub resource_id: u64,
/// Raw encrypted inbound frame bytes admitted by the outer governor.

pub bytes_read: u64,
pub bytes_written: u64,
pub read_operations: u64,
pub write_operations: u64,
/// Total authenticated inbound plus physically committed outbound keepalives.

pub keepalive_operations: u64
}

pub struct SecureSession<S> {

}

pub async fn establish(
        transport: AuthenticatedTransport<S>,
        options: SecureSessionOptions,
        context: SessionBootstrapContext,
        generation: MigrationGeneration,
        policy: SessionPolicy,
        clock: Arc<dyn SessionClock>,
    ) -> Result<Self, SecureSessionError>;

pub async fn establish_replacement(
        transport: AuthenticatedTransport<S>,
        options: SecureSessionOptions,
        context: SessionBootstrapContext,
        attempt: ReplacementAttempt,
        policy: SessionPolicy,
        clock: Arc<dyn SessionClock>,
    ) -> Result<Self, SecureSessionError>;

pub fn confirmed_bootstrap(&self) -> &SessionBootstrapV1;

pub fn channel_binding(&self) -> &ChannelBinding;

pub fn binding_digest(&self) -> [u8; 32];

pub fn policy(&self) -> &SessionPolicy;

pub fn flow_controller(&self) -> SessionFlowController;

pub fn application_auth_transcript(
        &self,
        inputs: OpaqueApplicationAuthInputs,
    ) -> Result<ApplicationAuthTranscriptV1, ProtocolError>;

pub fn resource_snapshot(&self) -> SessionResourceSnapshot;

pub fn is_terminal(&self) -> bool;

pub fn begin_replacement(&mut self) -> Result<ReplacementPlan, ProtocolError>;