/*
 * Copyright 2008, Oliver Ruiz Dorantes. All rights reserved.
 * Copyright 2024, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef L2CAP_ENDPOINT_H
#define L2CAP_ENDPOINT_H


#include <lock.h>
#include <condition_variable.h>
#include <util/AVLTree.h>

#include <net_protocol.h>
#include <net_socket.h>
#include <ProtocolUtilities.h>

#include <bluetooth/L2CAP/btL2CAP.h>
#include "l2cap_internal.h"


class L2capEndpoint;


class L2capEndpoint : public net_protocol, public ProtocolSocket, public AVLTreeNode {
public:
                                                L2capEndpoint(net_socket* socket);
        virtual                         ~L2capEndpoint();

                        status_t        Open();
                        status_t        Shutdown();
                        status_t        Close();
                        status_t        Free();

                        status_t        Bind(const struct sockaddr* _address);
                        status_t        Unbind();
                        status_t        Listen(int backlog);
                        status_t        Connect(const struct sockaddr* address);
                        status_t        Accept(net_socket** _acceptedSocket);

                        uint16          ChannelID() const { return fChannelID; }

                        ssize_t         ReadData(size_t numBytes, uint32 flags, net_buffer** _buffer);
                        ssize_t         SendData(net_buffer* buffer);
                        status_t        ReceiveData(net_buffer* buffer);
                        ssize_t         Sendable();
                        ssize_t         Receivable();

public:
                        void            _HandleCommandRejected(uint8 ident, uint16 reason,
                                                        const l2cap_command_reject_data& data);
                        void            _HandleConnectionReq(HciConnection* connection,
                                                        uint8 ident, uint16 psm, uint16 scid);
                        void            _HandleConnectionRsp(uint8 ident, const l2cap_connection_rsp& response);
                        void            _HandleConfigurationReq(uint8 ident, uint16 flags,
                                                        uint16* mtu, uint16* flush_timeout, l2cap_qos* flow);
                        void            _HandleConfigurationRsp(uint8 ident, uint16 scid, uint16 flags,
                                                        uint16 result, uint16* mtu, uint16* flush_timeout, l2cap_qos* flow);
                        void            _HandleDisconnectionReq(uint8 ident, uint16 scid);
                        void            _HandleDisconnectionRsp(uint8 ident, uint16 dcid, uint16 scid);

private:
        inline bool
        _IsEstablishing()
        {
                return fState > LISTEN && fState < OPEN;
        }

                        status_t        _WaitForStateChange(bigtime_t absoluteTimeout);

        static  void            _SendTimer(net_timer* timer, void* _endpoint);
                        void            _SendQueued();

                        void            _SendChannelConfig();
                        status_t        _MarkEstablished();
                        void            _MarkClosed();

private:
        friend class L2capEndpointManager;

        sem_id                  fAcceptSemaphore;
        mutex                   fLock;

        enum channel_status {
                CLOSED,
                BOUND,
                LISTEN,

                WAIT_FOR_CONNECTION_RSP,
                CONFIGURATION,
                OPEN,
                WAIT_FOR_DISCONNECTION_RSP,
                RECEIVED_DISCONNECTION_REQ,
        } fState;

        HciConnection*  fConnection;

        ConditionVariable fCommandWait;

        uint16                  fChannelID, fDestinationChannelID;

        net_fifo                fReceiveQueue, fSendQueue;
        net_timer               fSendTimer;

        struct ConfigState {
                enum : uint8 {
                        NONE,
                        SENT,
                        DONE,
                } in, out;
        } fConfigState;
        struct ChannelConfiguration {
                uint16          incoming_mtu;
                l2cap_qos       incoming_flow;
                uint16          outgoing_mtu;
                l2cap_qos       outgoing_flow;

                uint16          flush_timeout;
                uint16          link_timeout;
        } fChannelConfig;
};


#endif  // L2CAP_ENDPOINT_H