#ifndef STRAW_HPP
#define STRAW_HPP 1
#include <sstream>
#include <cstdint>
#include <cstddef>
#include <vector>
#include <span>
#include <string>
#include <concepts>
#include <cassert>
#include <iostream>
#include <algorithm>
namespace straw
{
struct color {
std::uint8_t r{}, g{}, b{};
constexpr color(std::uint8_t R, std::uint8_t G, std::uint8_t B) : r(R), g(G), b(B) {}
constexpr color(std::uint8_t A) : r(A), g(A), b(A) {}
constexpr uint32_t single() { return (uint32_t)r << 16 | (uint32_t)g << 8 | (uint32_t)b; }
constexpr bool operator==(const color &o) const = default;
};
static constexpr color WHITE{255, 255, 255};
static constexpr color BLACK{0, 0, 0};
struct attribs {
color bg{0, 0, 0}, fg{255, 255, 255};
bool bold, underline;
constexpr attribs() = default;
constexpr attribs(color Fg) : fg(Fg) {}
constexpr attribs(color Bg, color Fg) : bg(Bg), fg(Fg) {}
constexpr attribs(color Bg, color Fg, bool B, bool U) : bg(Bg), fg(Fg), bold(B), underline(U) {}
constexpr bool operator==(const attribs &o) const = default;
};
template<typename T>
concept char_type = std::integral<T>;
template<char_type chartype>
struct cell {
chartype chr{};
attribs attr{};
constexpr cell() = default;
constexpr cell(chartype Chr) : chr(Chr) {}
constexpr cell(chartype Chr, color Fg) : chr(Chr), attr(Fg) {}
constexpr cell(chartype Chr, color Bg, color Fg) : chr(Chr), attr(Bg, Fg) {}
constexpr cell(chartype Chr, color Bg, color Fg, bool B, bool U) : chr(Chr), attr(Bg, Fg, B, U) {}
constexpr cell(chartype Chr, attribs Attr) : chr(Chr), attr(Attr) {}
constexpr bool operator==(const cell &o) const = default;
};
const std::string ANSI_ESCAPE = "\E[";
static void ANSI_MOVE(unsigned x, unsigned y) { std::cout << ANSI_ESCAPE << y+1 << ';' << x+1 << 'H' << std::flush; }
static void ANSI_COLOR_FG(color c) { std::cout << ANSI_ESCAPE << "38;2;" << (unsigned)c.r << ';' << (unsigned)c.g << ';' << (unsigned)c.b << 'm' << std::flush; }
static void ANSI_COLOR_BG(color c) { std::cout << ANSI_ESCAPE << "48;2;" << (unsigned)c.r << ';' << (unsigned)c.g << ';' << (unsigned)c.b << 'm' << std::flush; }
class screen_command_base {};
template<char_type chartype>
class screen {
public:
explicit screen(unsigned X, unsigned Y, unsigned W, unsigned H, chartype C, color B, color F) :
m_x(X), m_y(Y), m_width(W), m_height(H), m_front(W * H, cell{C, B, F}), m_back(m_front),
m_cursorAttribs(B,F), m_fillChar(C)
{
redraw();
}
explicit screen(unsigned X, unsigned Y, unsigned W, unsigned H, chartype C) :
screen(X, Y, W, H, C, color{0, 0, 0}, color{255, 255, 255}) {}
explicit screen(unsigned X, unsigned Y, unsigned W, unsigned H) :
screen(X, Y, W, H, ' ') {}
constexpr void setcursorxy(unsigned x, unsigned y) { m_cursorX = x; m_cursorY = y; }
constexpr void setcursorfg(uint8_t r, uint8_t g, uint8_t b) { m_cursorAttribs.fg = color{r, g, b}; }
constexpr void setcursorbg(uint8_t r, uint8_t g, uint8_t b) { m_cursorAttribs.bg = color{r, g, b}; }
constexpr void setcursorfg(color c) { m_cursorAttribs.fg = c; }
constexpr void setcursorbg(color c) { m_cursorAttribs.bg = c; }
constexpr void setcursorbold(bool bold) { m_cursorAttribs.bold = bold; }
constexpr void setcursorunderline(bool underline) { m_cursorAttribs.underline = underline; }
constexpr unsigned getcursorx() { return m_cursorX; }
constexpr unsigned getcursory() { return m_cursorY; }
constexpr unsigned getx() { return m_x; }
constexpr unsigned gety() { return m_y; }
constexpr unsigned getwidth() { return m_width; }
constexpr unsigned getheight() { return m_height; }
void clear(const chartype c) { std::fill(m_front.begin(), m_front.end(), cell{c, m_cursorAttribs}); }
void clearrow(unsigned y, const chartype c) {
assert(y < m_height);
std::fill(m_front.begin() + (y * m_width),
m_front.begin() + (y * m_width) + m_width,
cell{c, m_cursorAttribs});
}
void scroll() {
m_cursorY = m_height - 1;
std::copy(m_front.begin() + m_width, m_front.end(), m_front.begin());
std::fill(m_front.end() - m_width, m_front.end(), cell{m_fillChar, m_cursorAttribs});
}
void setc(unsigned x, unsigned y, chartype c) {
assert(x < m_width);
assert(y < m_height);
m_front[x + (y * m_width)] = cell{c, m_cursorAttribs};
}
void putc(chartype c){
if(m_cursorY == m_height) {
scroll();
}
switch(c) {
case '\n':
m_cursorX = 0; m_cursorY++;
break;
default:
(*this)[m_cursorY][m_cursorX++] =
cell{c, m_cursorAttribs};
break;
}
if(m_cursorX == m_width) {
m_cursorY++;
m_cursorX = 0;
}
}
void puts(const std::basic_string<chartype> &s){
for(const chartype &c : s) this->putc(c);
}
void redraw() {
attribs cattr = (*this)[0][0].attr;
ANSI_COLOR_BG(cattr.bg);
ANSI_COLOR_FG(cattr.fg);
for(unsigned y = 0; y < m_height; y++) {
ANSI_MOVE(m_x, m_y + y);
for(cell c : (*this)[y]) {
if(cattr != c.attr) {
cattr = c.attr;
ANSI_COLOR_FG(cattr.fg);
ANSI_COLOR_BG(cattr.bg);
}
std::cout << c.chr;
}
std::cout.clear();
}
m_back = m_front;
}
void flush() {
attribs currAttr = m_front[0].attr;
ANSI_COLOR_FG(currAttr.fg);
ANSI_COLOR_BG(currAttr.bg);
for(unsigned y = 0; y < m_height; y++) {
auto backspan = std::span<cell<chartype>>(
m_back.begin() + (y * m_width),
m_back.begin() + (y * m_width) + m_width);
auto frontspan = (*this)[y];
bool change = false;
if(std::equal(backspan.begin(), backspan.end(), frontspan.begin(), frontspan.end())) continue;
for(unsigned x = 0; x < m_width; x++) {
cell c = frontspan[x];
if(c == backspan[x]) continue;
ANSI_MOVE(x + m_x, y + m_y);
if(c.attr != currAttr) {
ANSI_COLOR_FG(c.attr.fg);
ANSI_COLOR_BG(c.attr.bg);
currAttr = c.attr;
}
change = true;
std::cout << c.chr;
}
if(change) std::cout.clear();
}
m_back = m_front;
}
std::span<cell<chartype>> operator[](std::size_t i) {
assert(i < m_width * m_height);
return std::span<cell<chartype>>(
m_front.begin() + (i * m_width),
m_front.begin() + (i * m_width) + m_width);
}
template<typename T>
requires(!std::is_base_of<screen_command_base, T>::value)
friend screen &operator<<(screen &o, const T &rhs) {
std::basic_stringstream<chartype> ss;
ss << rhs;
o.puts(ss.str());
return o;
}
private:
unsigned m_x{}, m_y{};
unsigned m_width{}, m_height{};
std::vector<cell<chartype>> m_front;
std::vector<cell<chartype>> m_back;
unsigned m_cursorX{}, m_cursorY{};
attribs m_cursorAttribs;
chartype m_fillChar;
};
struct screen_command_flush : public screen_command_base {
explicit screen_command_flush() = default;
template<char_type T>
friend screen<T> &operator<<(screen<T> &o, const screen_command_flush &cmd) {
(void)cmd;
o.flush();
return o;
}
};
[[nodiscard]] static screen_command_flush flush() { return screen_command_flush{}; }
struct screen_command_redraw : public screen_command_base {
explicit screen_command_redraw() = default;
template<char_type T>
friend screen<T> &operator<<(screen<T> &o, const screen_command_redraw &cmd) {
(void)cmd;
o.redraw();
return o;
}
};
[[nodiscard]] static screen_command_redraw redraw() { return screen_command_redraw{}; }
template<char_type chartype>
struct screen_command_clear : public screen_command_base {
chartype c;
explicit screen_command_clear(chartype C) : c(C) {}
friend screen<chartype> &operator<<(screen<chartype> &o, const screen_command_clear &cmd) {
o.clear(cmd.c);
return o;
}
};
template<char_type chartype>
[[nodiscard]] static screen_command_clear<chartype> clear() { return screen_command_clear{chartype{}}; }
template<char_type chartype>
[[nodiscard]] static screen_command_clear<chartype> clear(chartype c) { return screen_command_clear{c}; }
struct screen_command_move : public screen_command_base {
unsigned x, y;
explicit screen_command_move(unsigned X, unsigned Y) : x(X), y(Y) {}
template<char_type T>
friend screen<T> &operator<<(screen<T> &o, const screen_command_move &cmd) {
o.setcursorxy(cmd.x, cmd.y);
return o;
}
};
[[nodiscard]] static screen_command_move move(unsigned x, unsigned y) { return screen_command_move{x, y}; }
template<char_type chartype>
struct screen_command_plot : public screen_command_base {
chartype c;
unsigned x, y;
explicit screen_command_plot(unsigned X, unsigned Y, chartype C) : c(C), x(X), y(Y) {}
friend screen<chartype> &operator<<(screen<chartype> &o, const screen_command_plot &cmd) {
o.setc(cmd.x, cmd.y, cmd.c);
return o;
}
};
template<char_type T>
[[nodiscard]] static screen_command_plot<T> plot(unsigned x, unsigned y, T c) { return screen_command_plot{x, y, c}; }
struct screen_command_recolor : public screen_command_base {
color fg, bg;
bool rfg, rbg;
explicit screen_command_recolor(color Fg, bool side) : fg(Fg), bg(Fg), rfg(side ? true : false), rbg(side ? false : true) {}
explicit screen_command_recolor(color Fg, color Bg) : fg(Fg), bg(Bg), rfg(true), rbg(true) {}
template<char_type T>
friend screen<T> &operator<<(screen<T> &o, const screen_command_recolor &cmd) {
if(cmd.rbg) o.setcursorbg(cmd.bg);
if(cmd.rfg) o.setcursorfg(cmd.fg);
return o;
}
};
[[nodiscard]] static screen_command_recolor setfg(uint8_t r, uint8_t g, uint8_t b) { return screen_command_recolor{color{r, g, b}, true}; }
[[nodiscard]] static screen_command_recolor setbg(uint8_t r, uint8_t g, uint8_t b) { return screen_command_recolor{color{r, g, b}, false}; }
[[nodiscard]] static screen_command_recolor setcolor(color fg, color bg) { return screen_command_recolor{fg, bg}; }
[[nodiscard]] static screen_command_recolor resetcolor() { return screen_command_recolor{WHITE, BLACK}; }
template<char_type chartype>
struct screen_command_fillrow : public screen_command_base {
unsigned row;
chartype c;
friend screen<chartype> &operator<<(screen<chartype> &o, const screen_command_fillrow &cmd) {
o.clearrow(cmd.row, cmd.c);
return o;
}
};
template<char_type T>
[[nodiscard]] static screen_command_fillrow<T> fillrow(unsigned row) { return screen_command_fillrow<T>{.row = row, .c = ' '}; }
template<char_type T>
[[nodiscard]] static screen_command_fillrow<T> fillrow(unsigned row, T c) { return screen_command_fillrow<T>{.row = row, .c = c}; }
}
#endif
