/*
 *
 *    Copyright (c) 2015-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *  @file
 *
 *  @brief
 *    Definitions for the Binding class.
 *
 *  This file defines common methods and callbacks for the WDM
 *  Binding class, which is responsible for keeping track of state
 *  required to communicate with a particular device.
 *
 *  Binding is not, in itself, part of the published interface to WDM
 *  but it provides the basis for portions of that interface.
 */


#ifndef _WEAVE_DATA_MANAGEMENT_BINDING_LEGACY_H
#define _WEAVE_DATA_MANAGEMENT_BINDING_LEGACY_H

#include <Weave/Profiles/data-management/Legacy/WdmManagedNamespace.h>
#include <Weave/Profiles/data-management/DMConstants.h>

namespace nl {
namespace Weave {
namespace Profiles {
namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Legacy) {

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
    using ServiceDirectory::WeaveServiceManager;
#endif

    class ProtocolEngine;

    /**
     *  @class Binding
     *
     *  @brief
     *    The Binding class manages communications state on behalf of
     *    an application entity using Weave.
     *
     *  When an application wants to use Weave to communicate with a
     *  remote entity there exists a wide variety of options. The
     *  Binding class corrals these options and arranges them in such
     *  a way that the easy stuff is easy and the more difficult stuff
     *  is at least tractable. Options covered include:
     *
     *  - unicast UDP communication with a known peer node.
     *
     *  - UDP broadcast with "any" node.
     *
     *  - unicast WRMP communication with a known peer node.
     *
     *  - TCP communications with a known peer node.
     *
     *  - TCP communications with a known service endpoint using a
     *    service manager instance to set things up.
     *
     *  - TCP communications based on a pre-established connection.
     */

    class Binding
    {

        friend class ProtocolEngine;

    public:

        Binding(void);

        virtual ~Binding(void);

        /**
         *  @brief
         *    Initialize a Binding with just a node ID.
         *
         *  This results in a binding with the configured default
         *  transport.
         *
         *  @param [in]     aPeerNodeId     A reference to the 64-bit
         *                                  ID of the binding target.
         *
         *  @retval #WEAVE_NO_ERROR On success.
         *
         *  @retval #WEAVE_ERROR_INVALID_ARGUMENT If the binding is
         *  under-specified.
         */

        inline WEAVE_ERROR Init(const uint64_t &aPeerNodeId)
        {
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
            return Init(aPeerNodeId, kTransport_WRMP);
#else
            return Init(aPeerNodeId, kTransport_TCP);
#endif
        }

        WEAVE_ERROR Init(const uint64_t &aPeerNodeId, uint8_t aTransport);

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
        WEAVE_ERROR Init(const uint64_t &aServiceEpt,
                         WeaveServiceManager *aServiceMgr,
                         WeaveAuthMode aAuthMode);
#endif

        WEAVE_ERROR Init(WeaveConnection *aConnection);

        WEAVE_ERROR Connect(WeaveConnection *aConnection);

        void Finalize(void);

        void Finalize(WEAVE_ERROR aErr);

        void Free(void);

        bool IsFree(void);

        WEAVE_ERROR CompleteRequest(ProtocolEngine *aEngine);

        void CompleteConfirm(WeaveConnection *aConnection);

        void CompleteConfirm(StatusReport &aReport);

        void CompleteConfirm(void);

        void UncompleteRequest(void);

        void UncompleteRequest(WEAVE_ERROR aErr);

        void IncompleteIndication(StatusReport &aReport);

        /**
         *  @brief
         *    Check if a binding is complete.
         *
         *  @note
         *    "Complete", in the case of a binding is tantamount to
         *    "ready for use". Thus, at this point, UDP-based bindings
         *    are always complete at initialization time as are
         *    TCP-based bindings that are initialized with a
         *    previously completed Weave connection. Bindings that
         *    depend on TCP and, especially, that bind to service
         *    endpoints are not, generally speaking, complete at
         *    initialization time and must go through a multi-stage
         *    process, as described elsewhere, before they are
         *    complete.
         *
         *  @sa CompleteRequest(ProtocolEngine *aEngine)
         *
         *  @return true if it's complete, false otherwise.
         */

        inline bool IsComplete(void)
        {
            return mState == kState_Complete;
        }

        ExchangeContext *GetExchangeCtx(WeaveExchangeManager *aExchangeMgr, void *aAppState);

        /*
         * There are the various attributes governing communication
         * via the exchange layer. For TCP-based communication, all
         * you really need is a connection but there are various ways
         * to get at that. For UDP/WRMP even less is required -
         * really, just a node ID or other address.
         *
         * NOTE!! These member should be treated as READ-ONLY.
         */

        /**
         *  @brief
         *    The 64-bit node ID of the binding target. (READ-ONLY)
         *
         *  Every Binding has a target entity, which is named here. In
         *  addition to a Weave node ID this may name a service
         *  endpoint.
         */

        uint64_t                                                    mPeerNodeId;

        /**
         *  @brief
         *    The transport to use in completing this Binding.
         *    (READ-ONLY)
         *
         *  Possible values for mTransport are defined in DMConstants.h.
         */

        uint8_t                                                     mTransport;

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
        /**
         *  @brief
         *    A pointer to the (optional) ServiceManager object to use
         *    in completing this binding. (READ-ONLY)
         *
         *  When binding to the Weave service, a 64-bit service
         *  endpoint ID may be supplied at initialization time in
         *  place of a Weave node ID. In this case, a ServiceManager
         *  object is also required to complete the binding. Normal
         *  TCP or WRMP bindings do not require a ServiceManager
         *  object.
         */

        nl::Weave::Profiles::ServiceDirectory::WeaveServiceManager *mServiceMgr;
#endif

        /**
         *  @brief
         *    The Weave authentication mode to be used. (READ_ONLY)
         *
         *  This is the authentication mode used in all communications
         *  governed by this binding.
         */

        WeaveAuthMode                                               mAuthMode;

        /**
         *  @brief
         *    A pointer to the Weave connection currently in use in
         *    this binding. (READ-ONLY)
         *
         *  TCP bindings may be initialized with a connection right off
         *  the bat or they may allocate one at completion time.
         *
         *  @note
         *    Although it is permissible to read, it is an error and
         *    could cause unexpected results to modify the value of
         *    mConnection directly.
         */

        WeaveConnection                                            *mConnection;

        /**
         *  @brief
         *    A pointer to the ProtocolEngine object related to
         *    this Binding.
         *
         *  A binding is generally completed with respect to a
         *  particular protocol engine, which is mostly used as a way
         *  of accessing the MessageLayer. This is where we keep track
         *  of it.
         */

        ProtocolEngine                                             *mEngine;

        /**
         *  @brief
         *    The set of Binding object states.
         */

        enum
        {
            kState_Incomplete                                     = 0, /**< The initial (and final) state of a Binding. */
            kState_Completing                                     = 1, /**< The state of a Binding that is in the process of being completed */
            kState_Complete                                       = 2  /**< The state of a Binding that is complete and ready for use. */
        };

        /**
         *  @brief
         *    The current Binding object state.
         *
         *  Only one "complete" operation can run at a time and, in any
         *  case, if you ask to complete a completed binding it just
         *  calls the confirm function immediately. The state variable
         *  below tracks the current state and acts as a lockout.
         */

        uint8_t                                                     mState;
    };

}; // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Legacy)
}; // Profiles
}; // Weave
}; // nl

#endif // _WEAVE_DATA_MANAGEMENT_BINDING_LEGACY_H