#ifndef ASCSCRN_HPP
#define ASCSCRN_HPP

// $Id: ascscrn.hpp 2.2 1996/02/04 22:31:59 tsurace Exp $
// $Log: ascscrn.hpp $// Revision 2.2  1996/02/04  22:31:59  tsurace// Added code to handle illegal cursor placement gracefully.//
// Revision 2.1  1995/10/24  15:52:51  tsurace
// Roll.
//
// Revision 1.4  1995/10/11  20:56:48  tsurace
// Modified to use MY ASSERT macro.
//
// Revision 1.3  1995/10/08  23:27:24  tsurace
// Added ansi(fg) color support.
//
// (end of log)


#include "debug.hpp"
#include "units.hpp" // Pos
#include "esc_seq.hpp"

#define ASBUFFER_LEN 2048

// ASBuffer - class to buffer input for a while.  This is to speed
//   lots of stuff, and is used to detect escape sequences.
class ASBuffer
{
  public:
    ASBuffer();
    
    void   Append(char c);     // Push onto stack
    void   Clear();            // Clear buffer
    int    Length() const;
    operator char * ();        // Return pointer to buffer
    char   operator [](int offset) const; // Return element of buffer

  private:
    char _buffer[ASBUFFER_LEN];       // null-terminated character string
    int  _buf_len;

    ASBuffer (const ASBuffer &); // Disable copy 'cause it's slow
};

// AsciiScreen class header file
//
// Note that the position coordinates are zero-indexed.

class AsciiScreen
{
  public:
    AsciiScreen(int width,
                int height,
                COLORREF normal_foreground,
                COLORREF bold_foreground,
                void (*invalidate_func)(const Pos & pos,
                                        const Size & size,
                                        void * extra),
                void * invalidateFuncExtra,
                int (*scroll_func)(int top,
                                   int bottom,
                                   int amount,
                                   void * extra),
                void * scrollFuncExtra);

    ~AsciiScreen();

    const Pos & Cursor() const { return _cursor; };
    const char &     TextElement(const Pos & pos) const ;
    const char &     TextElement(int index) const ;
    const COLORREF & ForegroundElement(const Pos & pos) const;
    const COLORREF & ForegroundElement(int index) const;
    
    
    void        Foreground(COLORREF foreground);
    void        Goto(Pos & pos);
    int         Height() const { return _height; };
    int         IndexOf(int column, int row) const;
    int         IndexOf(const Pos & pos) const;
    int         IsOnScreen(const Pos & pos) const;
    void        Put(char c);
    void        Put(char c, Pos & pos);
    void        Put(char * c);
    void        Put(char * c, Pos & pos);
    void        Resize(int width, int height);
    void        Scroll(int top, int bottom, int amount);
    int         Width() const { return _width; };

  protected:
    Pos         _cursor;             // Cursor attributes
    COLORREF    _cursorForeground;   // Current color

    int         _useAnsiColor;       // 1 to use the color below
    int         _cursorAnsiColor;    // ANSI color attribute (0-7)
    int         _cursorIsBold;       // 0(normal) or 1(bold)
    
    COLORREF    _boldForeground;     // Default used if ANSI not used
    COLORREF    _normalForeground;   // Used for normal characters
    
    int         _width;       // Screen size
    int         _height;
    int         _scrollRegionTop;    // Top of virtual screen
    int         _scrollRegionBottom; // Bottom of virtual screen
    char      * _text;        // The actual screen buffer
    COLORREF  * _foreground;  // And its colors
    
    void        (*_invalidateFunc)(const Pos & pos,
                                   const Size & size,
                                   void * extra);
    
    void      * _invalidateFuncExtra;
    void        _Invalidate(const Pos & pos, const Size & size) const;
    
    int         (*_scrollFunc)(int target, int src, int size, void * extra);
    void      * _scrollFuncExtra;
    int         _CallScrollFunc(int target, int source, int size) const;

    ASBuffer    _inputBuffer;   // Buffer object

    void   _AnsiColor(const EscapeSequence & esc);
    void   _IncrementPos();     // Moves cursor one space to the right
    void   _BackSpace();
    void   _CopyRow(int target, int source);
    void   _ClearToEOL();
    void   _ClearScreen();
    void   _ClearRow(int row);
    void   _ClearRows(int top, int bottom);
    void   _EscapeSequence(EscapeSequence & esc);
    void   _ReverseNewLine();
    void   _CarriageReturn();
    void   _NewLine(int count = 1);
    void   _ScrollCurrentRegion(int amount);

    char &     _TextElement(const Pos & pos);
    COLORREF & _ForegroundElement(const Pos & pos);
    
    // Disable copy/assign for now
    AsciiScreen(const AsciiScreen &);
    const AsciiScreen & operator=(const AsciiScreen &);

};

// >>>>> Buffer inlines <<<<<

inline ASBuffer::ASBuffer()
: _buf_len(0)
{
    _buffer[0] = '\0'; 
};
    
inline void ASBuffer::Append(char c)
{
    _buffer[_buf_len] = c;
    ++ _buf_len;
    ASSERT(ASBUFFER_LEN > _buf_len, "Out of room in internal buffer");
    _buffer[_buf_len] = '\0';  // Null-terminate
}

inline void ASBuffer::Clear()
{
    _buf_len = 0;
    _buffer[0] = '\0';
}

inline ASBuffer::operator char * ()
{
    return _buffer;
}

inline char ASBuffer::operator [](int offset) const
{
    ASSERT(ASBUFFER_LEN > offset && 0 <= offset, "Index out of bounds");
    return _buffer[offset];
};

inline int ASBuffer::Length() const
{
    return _buf_len;
};

// >>>>> AsciiScreen inlines <<<<<

inline void AsciiScreen::Put(char c, Pos & pos)
{
    Goto(pos);
    Put(c);
}

// PutString with pos - puts string starting at a particular location
inline void AsciiScreen::Put(char * c, Pos & pos)
{
    Goto(pos);
    Put(c);
}

// ------------------------------------------------------------------------
// IndexOf - returns array offset of this screen pos
//
inline int AsciiScreen::IndexOf(int x, int y) const
{
    return (y * Width()) + x;
}

// IndexOf - returns array index of pos
//
inline int AsciiScreen::IndexOf(const Pos & pos) const
{
    return IndexOf(pos.X(), pos.Y());
}

// _TextElement - accesses a particular element of the text array
//
// Parameters:
//   pos - coordinate of element to address

inline char & AsciiScreen::_TextElement(const Pos & pos)
{
    ASSERT(IsOnScreen(pos), "Accessing element offscreen");
    
    return _text[IndexOf(pos)];
}

inline COLORREF &
AsciiScreen::_ForegroundElement(const Pos & pos)
{
    ASSERT(IsOnScreen(pos), "Accessing foreground color offscreen");
    
    return _foreground[IndexOf(pos)];
}

inline const char &
AsciiScreen::TextElement(int index) const
{
    ASSERT(0 <= index, "Negative array index not allowed");
    ASSERT((Width() * Height()) > index, "Index past end of buffer");
    
    return _text[index];
}

inline const char &
AsciiScreen::TextElement(const Pos & pos) const
{
    ASSERT(IsOnScreen(pos), "Reading element offscreen");
    
    return TextElement(IndexOf(pos));
}

inline const COLORREF &
AsciiScreen::ForegroundElement(int index) const
{
    ASSERT(0 <= index, "Negative array index not allowed");
    ASSERT((Width() * Height()) > index, "Index past end of array");
    
    return _foreground[index];
}

inline const COLORREF &
AsciiScreen::ForegroundElement(const Pos & pos) const
{
    ASSERT(IsOnScreen(pos), "Element is off screen?");
    
    return ForegroundElement(IndexOf(pos));
}

inline int AsciiScreen::_CallScrollFunc(int top,
                                        int bottom,
                                        int amount) const
{
    ASSERT(NULL != _scrollFunc, "Bad function pointer");
    
    return (*_scrollFunc)(top, bottom, amount, _scrollFuncExtra);
};


// _Invalidate - call the invalidate function, if non-null
inline void
AsciiScreen::_Invalidate(const Pos & pos, const Size & size) const
{
    ASSERT(NULL != _invalidateFunc, "Bad function pointer");
    
    (*_invalidateFunc)(pos, size, _invalidateFuncExtra);
}

// -------------------------------------------------------------------
// ScrollCurrentRegion - scrolls the current scroll region forward
//   by amount (amount may be  negative)
//
inline void AsciiScreen::_ScrollCurrentRegion(int amount)
{
    Scroll(_scrollRegionTop, _scrollRegionBottom, amount);
};


#endif // ASCSCRN_HPP