#include "message.h"

    msg::deinitalise_mpr_streams();

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr
 * *********************************************************************** */
void replay_messages(void);

bool any_messages();
void replay_messages();

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr - it_use3 - items - religion
 * *********************************************************************** */

// last updated 18mar2001 {dlb}
/* ***********************************************************************
 * called from: acr
 * *********************************************************************** */
bool any_messages(void);

struct setchan

namespace msg

    setchan(msg_channel_type chan);
    msg_channel_type m_chan;
};

    extern std::ostream stream;
    std::ostream& streams(msg_channel_type chan = MSGCH_PLAIN);
    struct setparam
    {
        setparam(int param);
        int m_param;
    };

struct setparam
{
    setparam(int param);
    int m_param;
};

    struct mute
    {
        mute(bool value = true);
        bool m_value;
    };

std::ostream& operator<<(std::ostream& os, const setchan& sc);
std::ostream& operator<<(std::ostream& os, const setparam& sp);

    class mpr_stream_buf : public std::streambuf
    {
    public:
        mpr_stream_buf(msg_channel_type chan);
        void set_param(int p);
        void set_muted(bool m);
    protected:
        int overflow(int c);
    private:
        static const int INTERNAL_LENGTH = 500;
        char internal_buf[500]; // if your terminal is wider than this, too bad
        int internal_count;
        int param;
        bool muted;
        msg_channel_type channel;
    };

class mpr_stream_buf : public std::streambuf
{
public:
    mpr_stream_buf();
protected:
    int overflow(int c);
private:
    static const int INTERNAL_LENGTH = 500;
    char internal_buf[500]; // if your terminal is wider than this, too bad
    int internal_count;
};

    void initialise_mpr_streams();
    void deinitalise_mpr_streams();
}

extern std::ostream mpr_stream;

std::ostream& operator<<(std::ostream& os, const msg::setparam& sp);

// globals controlling message output
// there must be a better way to do this!
static bool mpr_stream_silent = false;
static msg_channel_type mpr_stream_channel = MSGCH_PLAIN;
static int mpr_stream_param = 0;
std::ostream mpr_stream(new mpr_stream_buf);

setchan::setchan(msg_channel_type chan)

namespace msg

    m_chan = chan;
}

    std::ostream stream(new mpr_stream_buf(MSGCH_PLAIN));
    std::vector<std::ostream*> stream_ptrs;

setparam::setparam(int param)
{
    m_param = param;
}

    std::ostream& streams(msg_channel_type chan)
    {
        ASSERT(chan >= 0 &&
               static_cast<unsigned int>(chan) < stream_ptrs.size());
        return *stream_ptrs[chan];
    }

std::ostream& operator<<(std::ostream& os, const setchan& sc)
{
    mpr_stream_channel = sc.m_chan;
    return os;
}

    void initialise_mpr_streams()
    {
        for (int i = 0; i < NUM_MESSAGE_CHANNELS; ++i)
        {
            mpr_stream_buf* pmsb =
                new mpr_stream_buf(static_cast<msg_channel_type>(i));
            std::ostream* pos = new std::ostream(pmsb);
            (*pos) << std::nounitbuf;
            stream_ptrs.push_back(pos);
        }
        stream << std::nounitbuf;
    }

std::ostream& operator<<(std::ostream& os, const setparam& sp)
{
    mpr_stream_param = sp.m_param;
    return os;
}

    void deinitalise_mpr_streams()
    {
        for (unsigned int i = 0; i < stream_ptrs.size(); ++i)
            delete stream_ptrs[i];
    }

mpr_stream_buf::mpr_stream_buf()
{
    for ( int i = 0; i < INTERNAL_LENGTH; ++i )
        internal_buf[0] = 0;
    internal_count = 0;
}

// again, can be improved
int mpr_stream_buf::overflow(int c)
{
    if ( c == '\n' )

    setparam::setparam(int param)

        // null-terminate the string
        internal_buf[internal_count] = 0;

        m_param = param;
    }

        if ( !mpr_stream_silent )
            mpr(internal_buf, mpr_stream_channel, mpr_stream_param);

    mpr_stream_buf::mpr_stream_buf(msg_channel_type chan) :
        internal_count(0), muted(false), channel(chan)
    {}

        internal_count = 0;

    void mpr_stream_buf::set_param(int p)
    {
        this->param = p;
    }

        // reset to defaults (channel changing isn't sticky)
        mpr_stream_channel = MSGCH_PLAIN;
        mpr_stream_param = 0;

    void mpr_stream_buf::set_muted(bool m)
    {
        this->muted = m;

    else
        internal_buf[internal_count++] = c;

    
    // again, can be improved
    int mpr_stream_buf::overflow(int c)
    {
        if ( muted )
            return 0;
        if ( c == '\n' )
        {
            // null-terminate and print the string
            internal_buf[internal_count] = 0;
            mpr(internal_buf, channel, param);
            
            internal_count = 0;

    if ( internal_count + 3 > INTERNAL_LENGTH )
    {
        mpr("oops, hit overflow", MSGCH_DANGER);
        internal_count = 0;
        return std::streambuf::traits_type::eof();

            // reset to defaults (param changing isn't sticky)
            set_param(0);
        }
        else
            internal_buf[internal_count++] = c;
        
        if ( internal_count + 3 > INTERNAL_LENGTH )
        {
            mpr("oops, hit overflow", MSGCH_DANGER);
            internal_count = 0;
            return std::streambuf::traits_type::eof();
        }
        return 0;

    return 0;

}
std::ostream& operator<<(std::ostream& os, const msg::setparam& sp)
{
    msg::mpr_stream_buf* ps = dynamic_cast<msg::mpr_stream_buf*>(os.rdbuf());
    ps->set_param(sp.m_param);
    return os;

    mpr_stream_silent = true;

    mpr_stream_silent = msuppressed;

        mpr_stream << "Welcome, " << you.your_name << " the "
                   << species_name( you.species,you.experience_level )
                   << " " << you.class_name << "."
                   << std::endl;

        msg::stream << "Welcome, " << you.your_name << " the "
                    << species_name( you.species,you.experience_level )
                    << " " << you.class_name << "."
                    << std::endl;

            int ch = 'x';
            mpr_stream << setchan(MSGCH_TUTORIAL)
                       << "Press any key to start the tutorial intro, "
                       << "or Escape to skip it."
                       << std::endl;
            ch = c_getch();

            msg::streams(MSGCH_TUTORIAL)
                << "Press any key to start the tutorial intro, "
                "or Escape to skip it."
                << std::endl;
            const int ch = c_getch();

    // Ensure no buffering on the mpr() stream.
    mpr_stream << std::nounitbuf;

    msg::initialise_mpr_streams();

        init_item( i );

        init_item(i);

    strcpy(info, "");

    info[0] = 0;