/// @file dpf/net/async_sctp_stream_array.hpp
/// @brief Truly asynchronous SCTP-backed indexed byte streams (Linux/libsctp).
/// @details One SCTP association carries every lane: index `i` maps to SCTP
///          stream `i`. Receive is head-of-line free across streams. Writes are
///          split into `wire_policy::chunk_bytes` messages and sent round-robin
///          across streams, so a large write on one stream does not hold small
///          writes on another behind it. The window covers the association.
///
/// Platform contract:
///   * Linux with `<netinet/sctp.h>` (libsctp) → real backend, needs `-lsctp`.
///   * Everything else → the class exists, every constructor throws.
#ifndef LIBDPF_INCLUDE_DPF_NET_ASYNC_SCTP_STREAM_ARRAY_HPP__
#define LIBDPF_INCLUDE_DPF_NET_ASYNC_SCTP_STREAM_ARRAY_HPP__

#if !defined(DPF_HAS_LIBSCTP)
#  if defined(__linux__) && defined(__has_include)
#    if __has_include(<netinet/sctp.h>)
#      define DPF_HAS_LIBSCTP 1
#    else
#      define DPF_HAS_LIBSCTP 0
#    endif
#  else
#    define DPF_HAS_LIBSCTP 0
#  endif
#endif

#include <atomic>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <deque>
#include <exception>
#include <functional>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <string>
#include <system_error>
#include <utility>
#include <vector>

#include "dpf/net/asio_ns.hpp"

#include "hedley/hedley.h"

#include "dpf/net/async_stream_array.hpp"
#include "dpf/net/connect.hpp"
#include "dpf/net/policy.hpp"

#if DPF_HAS_LIBSCTP
#  include <arpa/inet.h>
#  include <fcntl.h>
#  include <netinet/in.h>
#  include <netinet/sctp.h>
#  include <sys/socket.h>
#  include <unistd.h>
#  include <cerrno>
#endif

namespace dpf
{
namespace net
{

/// @brief True when this build has a real SCTP backend.
inline constexpr bool sctp_available() noexcept
{
    return DPF_HAS_LIBSCTP != 0;
}

#if DPF_HAS_LIBSCTP

namespace detail
{

/// @brief Stream counts, per-message `sinfo`, and socket options.
inline void sctp_configure(int fd, std::size_t nstreams,
    const socket_options & o = {})
{
    struct sctp_initmsg im;
    std::memset(&im, 0, sizeof(im));
    im.sinit_num_ostreams = static_cast<std::uint16_t>(nstreams);
    im.sinit_max_instreams = static_cast<std::uint16_t>(nstreams);
    (void)::setsockopt(fd, IPPROTO_SCTP, SCTP_INITMSG, &im, sizeof(im));

    struct sctp_event_subscribe ev;
    std::memset(&ev, 0, sizeof(ev));
    ev.sctp_data_io_event = 1;
    (void)::setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, &ev, sizeof(ev));

    const int nodelay = o.no_delay ? 1 : 0;
    (void)::setsockopt(fd, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, sizeof(nodelay));
    if (o.send_buffer > 0)
        (void)::setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &o.send_buffer,
            sizeof(o.send_buffer));
    if (o.recv_buffer > 0)
        (void)::setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &o.recv_buffer,
            sizeof(o.recv_buffer));
}

}  // namespace detail

/// @brief N lanes over one SCTP association, fully overlapped.
class async_sctp_stream_array final : public async_stream_array
{
public:
    /// @brief Adopt a connected one-to-one SCTP fd.
    async_sctp_stream_array(asio::io_context & io, int fd, std::size_t nstreams,
        const wire_policy & pol = {})
    {
        if (nstreams == 0)
            throw std::invalid_argument("async_sctp_stream_array empty");
        if (nstreams > 0xffffu)
            throw std::invalid_argument("async_sctp_stream_array: stream ids are u16");
        pol.validate();
        detail::sctp_configure(fd, nstreams, pol.socket);
        impl_ = std::make_shared<impl>(io, fd, nstreams, pol);
        impl_->start();
    }

    async_sctp_stream_array(const async_sctp_stream_array &) = delete;
    async_sctp_stream_array & operator=(const async_sctp_stream_array &) = delete;

    ~async_sctp_stream_array() override
    {
        if (impl_)
            impl_->close_graceful();
    }

    std::size_t size() const noexcept override { return impl_->n; }
    asio::io_context & context() noexcept override { return impl_->io; }

    void async_write(std::size_t i, const void * src, std::size_t n,
        async_handler h) override
    {
        impl_->write(i, n == 0 ? nullptr : copy_buffer(src, n), std::move(h));
    }

    void async_write_owned(std::size_t i,
        std::shared_ptr<std::vector<std::uint8_t>> buf, async_handler h) override
    {
        impl_->write(i, std::move(buf), std::move(h));
    }

    void async_read(std::size_t i, void * dst, std::size_t n,
        async_handler h) override
    {
        impl_->read(i, dst, n, std::move(h));
    }

    std::size_t buffered_bytes() const noexcept override
    {
        return impl_->buffered.load(std::memory_order_relaxed);
    }

    std::size_t window_bytes() const noexcept override
    {
        return impl_->window.load(std::memory_order_relaxed);
    }

    void set_window_bytes(std::size_t bytes) override
    {
        impl_->window.store(bytes, std::memory_order_relaxed);
    }

    stream_stats stats() const override { return impl_->stats(); }

    void close() noexcept override
    {
        impl_->close(asio::error::operation_aborted);
    }

private:
    struct chunk
    {
        std::shared_ptr<std::vector<std::uint8_t>> payload;
        std::size_t off = 0;
        std::size_t len = 0;
        std::shared_ptr<detail::write_op> op;
    };

    struct impl : std::enable_shared_from_this<impl>
    {
        impl(asio::io_context & io_, int fd, std::size_t nstreams,
            const wire_policy & pol_)
          : io(io_),
            sd(io_),
            strand(asio::make_strand(io_)),
            n(nstreams),
            pol(pol_),
            inbox(nstreams),
            partial(nstreams),
            wait(nstreams),
            outq(nstreams),
            rbuf(std::max<std::size_t>(pol_.chunk_bytes, std::size_t{1} << 16)),
            window(pol_.window_bytes)
        {
            const int fl = ::fcntl(fd, F_GETFL, 0);
            if (fl >= 0)
                (void)::fcntl(fd, F_SETFL, fl | O_NONBLOCK);
            sd.assign(fd);
        }

        void check(std::size_t i) const
        {
            if (i >= n)
                throw std::out_of_range("async_sctp_stream_array index "
                    + std::to_string(i));
        }

        void start()
        {
            auto self = shared_from_this();
            asio::post(strand, [self] { self->arm_read(); });
        }

        // --- reads ---------------------------------------------------------
        void read(std::size_t i, void * dst, std::size_t nbytes, async_handler h)
        {
            check(i);
            std::lock_guard<std::mutex> lock(mu);
            if (fail)
            {
                detail::post_handler(io, std::move(h), fail);
                return;
            }
            auto & w = wait[i];
            if (w.active)
                throw std::logic_error(
                    "async_sctp_stream_array: overlapping read on stream "
                    + std::to_string(i));
            const std::size_t k = inbox[i].take(dst, nbytes, pol.compact_bytes);
            if (k == nbytes)
            {
                detail::post_handler(io, std::move(h), {});
                return;
            }
            w.active = true;
            w.dst = dst;
            w.n = nbytes;
            w.filled = k;
            w.h = std::move(h);
        }

        void satisfy_locked(std::size_t i)
        {
            auto & w = wait[i];
            if (!w.active)
                return;
            w.filled += inbox[i].take(static_cast<std::uint8_t *>(w.dst) + w.filled,
                w.n - w.filled, pol.compact_bytes);
            if (w.filled == w.n)
            {
                w.active = false;
                detail::post_handler(io, std::move(w.h), {});
            }
        }

        void arm_read()
        {
            auto self = shared_from_this();
            sd.async_wait(asio::posix::stream_descriptor::wait_read,
                asio::bind_executor(strand, [self](const std::error_code & ec) {
                    self->on_readable(ec);
                }));
        }

        void on_readable(const std::error_code & ec)
        {
            if (ec)
            {
                deliver_error(ec);
                return;
            }
            for (;;)
            {
                struct sctp_sndrcvinfo sinfo;
                std::memset(&sinfo, 0, sizeof(sinfo));
                int flags = 0;
                const ssize_t r = ::sctp_recvmsg(sd.native_handle(), rbuf.data(),
                    rbuf.size(), nullptr, nullptr, &sinfo, &flags);
                if (r < 0)
                {
                    if (errno == EAGAIN || errno == EWOULDBLOCK)
                        break;
                    deliver_error(std::error_code(errno, std::generic_category()));
                    return;
                }
                if (r == 0)
                {
                    deliver_error(asio::error::eof);
                    return;
                }
                if (flags & MSG_NOTIFICATION)
                    continue;
                const std::size_t stream = sinfo.sinfo_stream;
                if (stream >= n)
                {
                    deliver_error(std::make_error_code(std::errc::protocol_error));
                    return;
                }
                bool too_big = false;
                {
                    std::lock_guard<std::mutex> lock(mu);
                    if (closed)
                        return;
                    auto & part = partial[stream];
                    part.insert(part.end(), rbuf.begin(), rbuf.begin() + r);
                    if (part.size() > pol.max_frame)
                        too_big = true;
                    else if ((flags & MSG_EOR) != 0)
                    {
                        counters.read(part.size(), part.size(), 1);
                        auto & box = inbox[stream].bytes;
                        box.insert(box.end(), part.begin(), part.end());
                        part.clear();
                        satisfy_locked(stream);
                    }
                }
                if (too_big)
                {
                    deliver_error(std::make_error_code(std::errc::message_size));
                    return;
                }
            }
            arm_read();
        }

        void fail_waiters_locked(const std::error_code & ec)
        {
            for (auto & w : wait)
            {
                if (!w.active)
                    continue;
                w.active = false;
                detail::post_handler(io, std::move(w.h), ec);
            }
        }

        void deliver_error(const std::error_code & ec)
        {
            {
                std::lock_guard<std::mutex> lock(mu);
                if (!fail)
                    fail = ec;
                fail_waiters_locked(fail);
            }
            auto self = shared_from_this();
            asio::post(strand, [self, ec] { self->fail_queued(ec); });
        }

        void close(const std::error_code & ec)
        {
            {
                std::lock_guard<std::mutex> lock(mu);
                if (!fail)
                    fail = ec;
                if (closed && aborted)
                    return;
                closed = true;
                aborted = true;
                fail_waiters_locked(ec);
            }
            auto self = shared_from_this();
            asio::post(strand, [self, ec] {
                std::error_code e;
                self->sd.close(e);
                self->fail_queued(ec);
            });
        }

        void close_graceful()
        {
            {
                std::lock_guard<std::mutex> lock(mu);
                if (closed)
                    return;
                closed = true;
                fail_waiters_locked(asio::error::operation_aborted);
            }
            auto self = shared_from_this();
            asio::post(strand, [self] {
                self->draining = true;
                if (!self->writing)
                {
                    std::error_code e;
                    self->sd.close(e);
                }
            });
        }

        stream_stats stats() const
        {
            stream_stats s;
            counters.fill(s);
            s.buffered = buffered.load(std::memory_order_relaxed);
            std::lock_guard<std::mutex> lock(mu);
            for (const auto & b : inbox)
                s.unread += b.avail();
            s.error = fail;
            s.closed = closed;
            return s;
        }

        // --- writes (strand) ----------------------------------------------
        void write(std::size_t i, std::shared_ptr<std::vector<std::uint8_t>> payload,
            async_handler h)
        {
            check(i);
            const std::size_t len = payload ? payload->size() : 0;
            {
                std::lock_guard<std::mutex> lock(mu);
                if (fail || closed)
                {
                    detail::post_handler(io, std::move(h),
                        fail ? fail : asio::error::operation_aborted);
                    return;
                }
            }
            if (len == 0)
            {
                detail::post_handler(io, std::move(h), {});
                return;
            }
            const auto pieces = detail::split_chunks(len, pol.chunk_bytes);
            auto op = std::make_shared<detail::write_op>();
            op->h = std::move(h);
            op->left = pieces.size();
            std::vector<chunk> cs;
            cs.reserve(pieces.size());
            for (const auto & pc : pieces)
                cs.push_back(chunk{payload, pc.first, pc.second, op});
            buffered.fetch_add(len, std::memory_order_relaxed);
            auto self = shared_from_this();
            asio::post(strand, [self, i, cs = std::move(cs)]() mutable {
                std::error_code ec;
                {
                    std::lock_guard<std::mutex> lock(self->mu);
                    ec = self->fail;
                }
                if (ec)
                {
                    for (auto & c : cs)
                        self->finish_chunk(c, ec);
                    return;
                }
                for (auto & c : cs)
                    self->outq[i].push_back(std::move(c));
                if (!self->writing)
                    self->write_next();
            });
        }

        void finish_chunk(chunk & c, const std::error_code & ec)
        {
            buffered.fetch_sub(std::min(buffered.load(std::memory_order_relaxed),
                                   c.len),
                std::memory_order_relaxed);
            auto & op = *c.op;
            if (ec && !op.ec)
                op.ec = ec;
            if (--op.left == 0)
                detail::post_handler(io, std::move(op.h), op.ec);
        }

        bool pick(std::size_t & lane)
        {
            for (std::size_t k = 0; k < n; ++k)
            {
                const std::size_t l = (rr + k) % n;
                if (!outq[l].empty())
                {
                    lane = l;
                    return true;
                }
            }
            return false;
        }

        void write_next()
        {
            std::size_t lane = 0;
            if (!pick(lane))
            {
                writing = false;
                if (draining)
                {
                    std::error_code e;
                    sd.close(e);
                }
                return;
            }
            writing = true;
            auto & front = outq[lane].front();
            const ssize_t r = ::sctp_sendmsg(sd.native_handle(),
                front.payload->data() + front.off, front.len, nullptr, 0, 0, 0,
                static_cast<std::uint16_t>(lane), 0, 0);
            if (r < 0)
            {
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                {
                    auto self = shared_from_this();
                    sd.async_wait(asio::posix::stream_descriptor::wait_write,
                        asio::bind_executor(strand,
                            [self](const std::error_code & ec) {
                                if (ec)
                                {
                                    self->writing = false;
                                    self->deliver_error(ec);
                                    return;
                                }
                                self->write_next();
                            }));
                    return;
                }
                writing = false;
                deliver_error(std::error_code(errno, std::generic_category()));
                return;
            }
            const std::size_t sent = static_cast<std::size_t>(r);
            counters.wrote(sent, sent, 1);
            if (sent < front.len)
            {
                buffered.fetch_sub(std::min(buffered.load(), sent),
                    std::memory_order_relaxed);
                front.off += sent;
                front.len -= sent;
                write_next();
                return;
            }
            chunk done = std::move(front);
            outq[lane].pop_front();
            rr = (lane + 1) % n;
            finish_chunk(done, {});
            auto self = shared_from_this();
            asio::post(strand, [self] { self->write_next(); });
        }

        void fail_queued(const std::error_code & ec)
        {
            writing = false;
            for (auto & q : outq)
            {
                for (auto & c : q)
                    finish_chunk(c, ec);
                q.clear();
            }
        }

        asio::io_context & io;
        asio::posix::stream_descriptor sd;
        asio::strand<asio::io_context::executor_type> strand;
        std::size_t n = 0;
        wire_policy pol;
        mutable std::mutex mu;
        std::vector<detail::stream_inbox> inbox;
        std::vector<std::vector<std::uint8_t>> partial;
        std::vector<detail::stream_waiter> wait;
        std::error_code fail;
        bool closed = false;
        bool aborted = false;
        std::vector<std::deque<chunk>> outq;
        std::size_t rr = 0;
        bool writing = false;
        bool draining = false;
        std::vector<std::uint8_t> rbuf;
        std::atomic<std::size_t> buffered{0};
        std::atomic<std::size_t> window;
        detail::io_counters counters;
    };

    std::shared_ptr<impl> impl_;
};

// ---------------------------------------------------------------------------
// Association setup (deadline-bounded)
// ---------------------------------------------------------------------------

/// @brief Listening one-to-one SCTP socket.
class sctp_listener
{
public:
    sctp_listener(unsigned short port, std::size_t nstreams,
        const socket_options & o = {})
      : nstreams_(nstreams), opts_(o)
    {
        if (nstreams == 0)
            throw std::invalid_argument("sctp_listener: no streams");
        fd_ = ::socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
        if (fd_ < 0)
            throw std::system_error(errno, std::generic_category(),
                "sctp_listener: socket");
        int one = 1;
        (void)::setsockopt(fd_, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
        detail::sctp_configure(fd_, nstreams, o);
        struct sockaddr_in addr;
        std::memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
        addr.sin_port = htons(port);
        if (::bind(fd_, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) < 0
            || ::listen(fd_, 16) < 0)
        {
            const int e = errno;
            ::close(fd_);
            fd_ = -1;
            throw std::system_error(e, std::generic_category(),
                "sctp_listener: bind/listen on port " + std::to_string(port));
        }
        socklen_t alen = sizeof(addr);
        if (::getsockname(fd_, reinterpret_cast<struct sockaddr *>(&addr), &alen) == 0)
            port_ = ntohs(addr.sin_port);
    }

    sctp_listener(const sctp_listener &) = delete;
    sctp_listener & operator=(const sctp_listener &) = delete;

    ~sctp_listener()
    {
        if (fd_ >= 0)
            ::close(fd_);
    }

    unsigned short port() const noexcept { return port_; }
    int native_handle() const noexcept { return fd_; }

    /// @brief Accept one association within `budget`; returns the fd.
    int accept(std::chrono::milliseconds budget)
    {
        const auto deadline = setup_clock::now() + budget;
        detail::wait_fd(fd_, POLLIN, deadline,
            "sctp accept on port " + std::to_string(port_));
        const int cfd = ::accept(fd_, nullptr, nullptr);
        if (cfd < 0)
            throw std::system_error(errno, std::generic_category(), "sctp accept");
        detail::sctp_configure(cfd, nstreams_, opts_);
        return cfd;
    }

private:
    int fd_ = -1;
    unsigned short port_ = 0;
    std::size_t nstreams_ = 0;
    socket_options opts_{};
};

/// @brief Connect one SCTP association, retrying refusals until `budget`.
HEDLEY_WARN_UNUSED_RESULT
inline int connect_sctp(const std::string & host, unsigned short port,
    std::size_t nstreams, std::chrono::milliseconds budget,
    const socket_options & o = {})
{
    const auto deadline = setup_clock::now() + budget;
    struct sockaddr_in addr;
    std::memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    const std::string h = host == "localhost" ? "127.0.0.1" : host;
    if (::inet_pton(AF_INET, h.c_str(), &addr.sin_addr) != 1)
        throw std::invalid_argument("connect_sctp: bad host " + host);
    int last = ETIMEDOUT;
    for (;;)
    {
        const int fd = ::socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
        if (fd < 0)
            throw std::system_error(errno, std::generic_category(),
                "connect_sctp: socket");
        detail::sctp_configure(fd, nstreams, o);
        if (::connect(fd, reinterpret_cast<struct sockaddr *>(&addr),
                sizeof(addr)) == 0)
            return fd;
        last = errno;
        ::close(fd);
        if (setup_clock::now() >= deadline)
            throw std::system_error(last, std::generic_category(),
                "connect_sctp " + host + ":" + std::to_string(port));
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
    }
}

/// @brief Accept one association on an ephemeral (or given) port.
HEDLEY_WARN_UNUSED_RESULT
inline int accept_sctp_association(asio::io_context &,
    std::atomic<unsigned short> & port, std::size_t nstreams,
    std::chrono::milliseconds budget = deadlines{}.accept)
{
    sctp_listener lst(port.load(), nstreams);
    port.store(lst.port());
    return lst.accept(budget);
}

/// @brief Connect one association to `host:port`.
HEDLEY_WARN_UNUSED_RESULT
inline int connect_sctp_association(asio::io_context &, const std::string & host,
    std::atomic<unsigned short> & port, std::size_t nstreams,
    std::chrono::milliseconds budget = deadlines{}.connect)
{
    return connect_sctp(host, port.load(), nstreams, budget);
}

#else  // !DPF_HAS_LIBSCTP

class async_sctp_stream_array final : public async_stream_array
{
public:
    async_sctp_stream_array(asio::io_context &, int, std::size_t,
        const wire_policy & = {})
    {
        throw std::logic_error(
            "async_sctp_stream_array: real SCTP requires Linux + libsctp "
            "(<netinet/sctp.h>, link -lsctp)");
    }

    std::size_t size() const noexcept override { return 0; }
    asio::io_context & context() noexcept override
    {
        std::terminate();
    }
    void async_write(std::size_t, const void *, std::size_t,
        async_handler) override
    {
        throw std::logic_error("async_sctp_stream_array: not available");
    }
    void async_read(std::size_t, void *, std::size_t, async_handler) override
    {
        throw std::logic_error("async_sctp_stream_array: not available");
    }
};

class sctp_listener
{
public:
    sctp_listener(unsigned short, std::size_t, const socket_options & = {})
    {
        throw std::logic_error("sctp_listener: SCTP requires Linux + libsctp");
    }
    unsigned short port() const noexcept { return 0; }
    int native_handle() const noexcept { return -1; }
    int accept(std::chrono::milliseconds) { return -1; }
};

HEDLEY_WARN_UNUSED_RESULT
inline int connect_sctp(const std::string &, unsigned short, std::size_t,
    std::chrono::milliseconds, const socket_options & = {})
{
    throw std::logic_error("connect_sctp: SCTP requires Linux + libsctp");
}

HEDLEY_WARN_UNUSED_RESULT
inline int accept_sctp_association(asio::io_context &,
    std::atomic<unsigned short> &, std::size_t,
    std::chrono::milliseconds = deadlines{}.accept)
{
    throw std::logic_error(
        "accept_sctp_association: SCTP requires Linux + libsctp");
}

HEDLEY_WARN_UNUSED_RESULT
inline int connect_sctp_association(asio::io_context &, const std::string &,
    std::atomic<unsigned short> &, std::size_t,
    std::chrono::milliseconds = deadlines{}.connect)
{
    throw std::logic_error(
        "connect_sctp_association: SCTP requires Linux + libsctp");
}

#endif  // DPF_HAS_LIBSCTP

}  // namespace net
}  // namespace dpf

#endif  // LIBDPF_INCLUDE_DPF_NET_ASYNC_SCTP_STREAM_ARRAY_HPP__