/**
 * @file lliopipe.h
 * @author Phoenix
 * @date 2004-11-18
 * @brief Declaration of base IO class
 *
 * $LicenseInfo:firstyear=2004&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLIOPIPE_H
#define LL_LLIOPIPE_H

#include <boost/intrusive_ptr.hpp>
#include "llwin32headerslean.h"
#include "apr_poll.h"

#include "llsd.h"

class LLIOPipe;
class LLPumpIO;
class LLBufferArray;
class LLChannelDescriptors;

// Debugging schmutz for deadlocks
//#define LL_DEBUG_PUMPS
#ifdef LL_DEBUG_PUMPS
void pump_debug(const char *file, S32 line);
#define PUMP_DEBUG pump_debug(__FILE__, __LINE__);
#define END_PUMP_DEBUG pump_debug("none", 0);
#else /* LL_DEBUG_PUMPS */
#define PUMP_DEBUG
#define END_PUMP_DEBUG
#endif


/**
 * intrusive pointer support
 */
void intrusive_ptr_add_ref(LLIOPipe* p);
void intrusive_ptr_release(LLIOPipe* p);

/**
 * @class LLIOPipe
 * @brief This class is an abstract base class for data processing units
 * @see LLPumpIO
 *
 * The LLIOPipe is a base class for implementing the basic non-blocking
 * processing of data subsystem in our system.
 *
 * Implementations of this class should behave like a stateful or
 * stateless signal processor. Each call to <code>process()</code>
 * hands the pipe implementation a buffer and a set of channels in the
 * buffer to process, and the pipe returns the status of the
 * operation. This is an abstract base class and developer created
 * concrete implementations provide block or stream based processing
 * of data to implement a particular protocol.
 */
class LLIOPipe
{
public:
    /**
     * @brief I have decided that IO objects should have a reference
     * count. In general, you can pass bald LLIOPipe pointers around
     * as you need, but if you need to maintain a reference to one,
     * you need to hold a ptr_t.
     */
    typedef boost::intrusive_ptr<LLIOPipe> ptr_t;

    /**
     * @brief Scattered memory container.
     */
    typedef std::shared_ptr<LLBufferArray> buffer_ptr_t;

    /**
     * @brief Enumeration for IO return codes
     *
     * A status code a positive integer value is considered a success,
     * but may indicate special handling for future calls, for
     * example, issuing a STATUS_STOP to an LLIOSocketReader instance
     * will tell the instance to stop reading the socket. A status
     * code with a negative value means that a problem has been
     * encountered which will require further action on the caller or
     * a developer to correct. Some mechanisms, such as the LLPumpIO
     * may depend on this definition of success and failure.
     */
    enum EStatus
    {
        // Processing occurred normally, future calls will be accepted.
        STATUS_OK = 0,

        // Processing occured normally, but stop unsolicited calls to
        // process.
        STATUS_STOP = 1,

        // This pipe is done with the processing. Future calls to
        // process will be accepted as long as new data is available.
        STATUS_DONE = 2,

        // This pipe is requesting that it become the head in a process.
        STATUS_BREAK = 3,

        // This pipe is requesting that it become the head in a process.
        STATUS_NEED_PROCESS = 4,

        // Keep track of the highest number of success codes here.
        STATUS_SUCCESS_COUNT = 5,

        // A generic error code.
        STATUS_ERROR = -1,

        // This method has not yet been implemented. This usually
        // indicates the programmer working on the pipe is not yet
        // done.
        STATUS_NOT_IMPLEMENTED = -2,

        // This indicates that a pipe precondition was not met. For
        // example, many pipes require an element to appear after them
        // in a chain (ie, mNext is not null) and will return this in
        // response to method calls. To recover from this, it will
        // require the caller to adjust the pipe state or may require
        // a dev to adjust the code to satisfy the preconditions.
        STATUS_PRECONDITION_NOT_MET = -3,

        // This means we could not connect to a remote host.
        STATUS_NO_CONNECTION = -4,

        // The connection was lost.
        STATUS_LOST_CONNECTION = -5,

        // The totoal process time has exceeded the timeout.
        STATUS_EXPIRED = -6,

        // Keep track of the count of codes here.
        STATUS_ERROR_COUNT = 6,
    };

    /**
     * @brief Helper function to check status.
     *
     * When writing code to check status codes, if you do not
     * specifically check a particular value, use this method for
     * checking an error condition.
     * @param status The status to check.
     * @return Returns true if the code indicates an error occurred.
     */
    inline static bool isError(EStatus status)
    {
        return ((S32)status < 0);
    }

    /**
     * @brief Helper function to check status.
     *
     * When writing code to check status codes, if you do not
     * specifically check a particular value, use this method for
     * checking an error condition.
     * @param status The status to check.
     * @return Returns true if the code indicates no error was generated.
     */
    inline static bool isSuccess(EStatus status)
    {
        return ((S32)status >= 0);
    }

    /**
     * @brief Helper function to turn status into a string.
     *
     * @param status The status to check.
     * @return Returns the name of the status code or empty string on failure.
     */
    static std::string lookupStatusString(EStatus status);

    /**
     * @brief Process the data in buffer.
     *
     * @param data The data processed
     * @param eos True if this function call is the last because end of stream.
     * @param pump The pump which is calling process. May be NULL.
     * @param context Shared meta-data for the process.
     * @return Returns a status code from the operation.
     */
    EStatus process(
        const LLChannelDescriptors& channels,
        buffer_ptr_t& buffer,
        bool& eos,
        LLSD& context,
        LLPumpIO* pump);

    /**
     * @brief Give this pipe a chance to handle a generated error
     *
     * If this pipe is in a chain being processed by a pump, and one
     * of the pipes generates an error, the pump will rewind through
     * the chain to see if any of the links can handle the error. For
     * example, if a connection is refused in a socket connection, the
     * socket client can try to find a new destination host. Return an
     * error code if this pipe does not handle the error passed in.
     * @param status The status code for the error
     * @param pump The pump which was calling process before the error
     * was generated.
     * @return Returns a status code from the operation. Returns an
     * error code if the error passed in was not handled. Returns
     * STATUS_OK to indicate the error has been handled.
     */
    virtual EStatus handleError(EStatus status, LLPumpIO* pump);

    /**
     * @brief Base Destructor - do not call <code>delete</code> directly.
     */
    virtual ~LLIOPipe();

    virtual bool isValid() ;

protected:
    /**
     * @brief Base Constructor.
     */
    LLIOPipe();

    /**
     * @brief Process the data in buffer
     */
    virtual EStatus process_impl(
        const LLChannelDescriptors& channels,
        buffer_ptr_t& buffer,
        bool& eos,
        LLSD& context,
        LLPumpIO* pump) = 0;

private:
    friend void intrusive_ptr_add_ref(LLIOPipe* p);
    friend void intrusive_ptr_release(LLIOPipe* p);
    U32 mReferenceCount;
};

inline void intrusive_ptr_add_ref(LLIOPipe* p)
{
    ++p->mReferenceCount;
}
inline void intrusive_ptr_release(LLIOPipe* p)
{
    if(p && 0 == --p->mReferenceCount)
    {
        delete p;
    }
}

#endif // LL_LLIOPIPE_H