#ifndef OLEDI2C_h
#define OLEDI2C_h

// ===== константы =====
#define SSD1306_128x32 0
#define SSD1306_128x64 1
#define SSH1106_128x64 2
 
#define OLED_I2C 0
#define OLED_SPI 1

#define OLED_NO_BUFFER 0
#define OLED_BUFFER 1

#define OLED_CLEAR 0
#define OLED_FILL 1
#define OLED_STROKE 2

#define BUF_ADD 0
#define BUF_SUBTRACT 1
#define BUF_REPLACE 2

#define BITMAP_NORMAL 0
#define BITMAP_INVERT 1

// ===========================================================================

#include "I2C.h"  // лёгкая библиотека Wire (для atmega328)
#include "charMap.h"

#ifndef OLED_NO_PRINT
#include <Print.h>
#endif

// ============================ БЭКЭНД КОНСТАНТЫ ==============================
// внутренние константы
#define OLED_WIDTH 128
#define OLED_HEIGHT_32 0x02
#define OLED_HEIGHT_64 0x12
#define OLED_64 0x3F
#define OLED_32 0x1F

#define OLED_DISPLAY_OFF 0xAE
#define OLED_DISPLAY_ON 0xAF

#define OLED_COMMAND_MODE 0x00
#define OLED_ONE_COMMAND_MODE 0x80
#define OLED_DATA_MODE 0x40
#define OLED_ONE_DATA_MODE 0xC0

#define OLED_ADDRESSING_MODE 0x20
#define OLED_HORIZONTAL 0x00
#define OLED_VERTICAL 0x01

#define OLED_NORMAL_V 0xC8
#define OLED_FLIP_V 0xC0
#define OLED_NORMAL_H 0xA1
#define OLED_FLIP_H 0xA0

#define OLED_CONTRAST 0x81
#define OLED_SETCOMPINS 0xDA
#define OLED_SETVCOMDETECT 0xDB
#define OLED_CLOCKDIV 0xD5
#define OLED_SETMULTIPLEX 0xA8
#define OLED_COLUMNADDR 0x21
#define OLED_PAGEADDR 0x22
#define OLED_CHARGEPUMP 0x8D

#define OLED_NORMALDISPLAY 0xA6
#define OLED_INVERTDISPLAY 0xA7

#define BUFSIZE_128x64 (128 * 64 / 8)
#define BUFSIZE_128x32 (128 * 32 / 8)

#ifndef OLED_SPI_SPEED
#define OLED_SPI_SPEED 1000000ul
#endif

//static SPISettings OLED_SPI_SETT(OLED_SPI_SPEED, MSBFIRST, SPI_MODE0);

// список инициализации
static const uint8_t _oled_init[] PROGMEM = {
  OLED_DISPLAY_OFF,
  OLED_CLOCKDIV,
  0x80,  // value
  OLED_CHARGEPUMP,
  0x14,  // value
  OLED_ADDRESSING_MODE,
  OLED_VERTICAL,
  OLED_NORMAL_H,
  OLED_NORMAL_V,
  OLED_CONTRAST,
  0x7F,  // value
  OLED_SETVCOMDETECT,
  0x40,  // value
  OLED_NORMALDISPLAY,
  OLED_DISPLAY_ON,
};



// ========================== КЛАСС КЛАСС КЛАСС =============================
template<int _TYPE, int _BUFF = OLED_BUFFER, int _CONN = OLED_I2C, int8_t _CS = -1, int8_t _DC = -1, int8_t _RST = -1 >
#ifndef OLED_NO_PRINT
class OLEDI2C : public Print {
#else
class OLEDI2C {
#endif
public:
  // ========================== КОНСТРУКТОР =============================
  OLEDI2C(uint8_t address = 0x3C)
    : _address(address) {}

  // ============================= СЕРВИС ===============================
  // инициализация
  void init(int __attribute__((unused)) sda = 0, int __attribute__((unused)) scl = 0) {
#if defined(ESP32) || defined(ESP8266)
    if (sda || scl) Wire.begin(sda, scl);
    else Wire.begin();
#else
    Wire.begin();
#endif

    beginCommand();
    for (uint8_t i = 0; i < 15; i++) sendByte(pgm_read_byte(&_oled_init[i]));
    endTransm();
    beginCommand();
    sendByte(OLED_SETCOMPINS);
    sendByte(_TYPE ? OLED_HEIGHT_64 : OLED_HEIGHT_32);
    sendByte(OLED_SETMULTIPLEX);
    sendByte(_TYPE ? OLED_64 : OLED_32);
    endTransm();

    setCursorXY(0, 0);
    if (_BUFF) setWindow(0, 0, _maxX, _maxRow);  // для буфера включаем всю область
  }

  // очистить дисплей
  void clear() {
    fill(0);
  }

  // очистить область
  void clear(int x0, int y0, int x1, int y1) {
    if (_TYPE < 2) {  // для SSD1306
      if (_BUFF) rect(x0, y0, x1, y1, OLED_CLEAR);
      else {
        x1++;
        y1++;
        y0 >>= 3;
        y1 = (y1 - 1) >> 3;
        y0 = constrain(y0, 0, _maxRow);
        y1 = constrain(y1, 0, _maxRow);
        x0 = constrain(x0, 0, _maxX);
        x1 = constrain(x1, 0, _maxX);
        setWindow(x0, y0, x1, y1);
        beginData();
        for (int x = x0; x < x1; x++)
          for (int y = y0; y < y1 + 1; y++)
            writeData(0, y, x, 2);
        endTransm();
      }
    } else {
      // для SSH1108
    }
    setCursorXY(_x, _y);
  }

  // яркость 0-255
  void setContrast(uint8_t value) {
    sendCommand(OLED_CONTRAST, value);
  }

  // вкл/выкл
  void setPower(bool mode) {
    sendCommand(mode ? OLED_DISPLAY_ON : OLED_DISPLAY_OFF);
  }

  // отразить по горизонтали
  void flipH(bool mode) {
    sendCommand(mode ? OLED_FLIP_H : OLED_NORMAL_H);
  }

  // инвертировать дисплей
  void invertDisplay(bool mode) {
    sendCommand(mode ? OLED_INVERTDISPLAY : OLED_NORMALDISPLAY);
  }

  // отразить по вертикали
  void flipV(bool mode) {
    sendCommand(mode ? OLED_FLIP_V : OLED_NORMAL_V);
  }

  // ============================= ПЕЧАТЬ ==================================
  virtual size_t write(uint8_t data) {
#ifndef OLED_NO_PRINT
    // переносы и пределы
    bool newPos = false;
    if (data == '\r') {
      _x = 0;
      newPos = true;
      data = 0;
    }  // получен возврат каретки
    if (data == '\n') {
      _y += _scaleY;
      newPos = true;
      data = 0;
      _getn = 1;
    }  // получен перевод строки
    if (_println && (_x + 6 * _scaleX) >= _maxX) {
      _x = 0;
      _y += _scaleY;
      newPos = true;
    }                                        // строка переполненена, перевод и возврат
    if (newPos) setCursorXY(_x, _y);         // переставляем курсор
    if (_y + _scaleY > _maxY + 1) data = 0;  // дисплей переполнен
    if (_getn && _println && data == ' ' && _x == 0) {
      _getn = 0;
      data = 0;
    }  // убираем первый пробел в строке

    // фикс русских букв и некоторых символов
    if (data > 127) {
      uint8_t thisData = data;
      // data = 0 - флаг на пропуск
      if (data > 191) data = 0;
      else if (_lastChar == 209 && data == 145) data = 192;  // ё кастомная
      else if (_lastChar == 208 && data == 129) data = 149;  // Е вместо Ё
      else if (_lastChar == 226 && data == 128) data = 0;    // тире вместо длинного тире (начало)
      else if (_lastChar == 128 && data == 148) data = 45;   // тире вместо длинного тире
      _lastChar = thisData;
    }
    if (data == 0) return 1;
    // если тут не вылетели - печатаем символ

    if (_TYPE < 2 || 1) {  // для SSD1306
      int newX = _x + _scaleX * 6;
      if (newX < 0 || _x > _maxX) _x = newX;  // пропускаем вывод "за экраном"
      else {
        if (!_BUFF) beginData();
        for (uint8_t col = 0; col < 6; col++) {                // 6 стобиков буквы
          uint8_t bits = getFont(data, col);                   // получаем байт
          if (_invState) bits = ~bits;                         // инверсия
          if (_scaleX == 1) {                                  // если масштаб 1
            if (_x >= 0 && _x <= _maxX) {                      // внутри дисплея
              if (_shift == 0) {                               // если вывод без сдвига на строку
                writeData(bits, 0, 0, _mode);                  // выводим
              } else {                                         // со сдвигом
                writeData(bits << _shift, 0, 0, _mode);        // верхняя часть
                writeData(bits >> (8 - _shift), 1, 0, _mode);  // нижняя часть
              }
            }
          } else {                 // масштаб 2, 3 или 4 - растягиваем шрифт
            uint32_t newData = 0;  // буфер
            for (uint8_t i = 0, count = 0; i < 8; i++)
              for (uint8_t j = 0; j < _scaleX; j++, count++)
                bitWrite(newData, count, bitRead(bits, i));  // пакуем растянутый шрифт

            for (uint8_t i = 0; i < _scaleX; i++) {  // выводим. По Х
              byte prevData = 0;
              if (_x + i >= 0 && _x + i <= _maxX)                                           // внутри дисплея
                for (uint8_t j = 0; j < _scaleX; j++) {                                     // выводим. По Y
                  byte data = newData >> (j * 8);                                           // получаем кусок буфера
                  if (_shift == 0) {                                                        // если вывод без сдвига на строку
                    writeData(data, j, i, _mode);                                           // выводим
                  } else {                                                                  // со сдвигом
                    writeData((prevData >> (8 - _shift)) | (data << _shift), j, i, _mode);  // склеиваем и выводим
                    prevData = data;                                                        // запоминаем предыдущий
                  }
                }
              if (_shift != 0) writeData(prevData >> (8 - _shift), _scaleX, i, _mode);  // выводим нижний кусочек, если со сдвигом
            }
          }
          _x += _scaleX;  // двигаемся на ширину пикселя (1-4)
        }
        if (!_BUFF) endTransm();
      }
    } else {
      // для SSH1106
    }
#endif
    return 1;
  }

  // автоматически переносить текст
  void autoPrintln(bool mode) {
    _println = mode;
  }

  // отправить курсор в 0,0
  void home() {
    setCursorXY(0, 0);
  }

  // поставить курсор для символа 0-127, 0-8(4)
  void setCursor(int x, int y) {
    setCursorXY(x, y << 3);
  }

  // поставить курсор для символа 0-127, 0-63(31)
  void setCursorXY(int x, int y) {
    _x = x;
    _y = y;
    setWindowShift(x, y, _maxX, _scaleY);
  }

  // масштаб шрифта (1-4)
  void setScale(uint8_t scale) {
    scale = constrain(scale, 1, 4);  // защита от нечитающих доку
    _scaleX = scale;
    _scaleY = scale * 8;
    setCursorXY(_x, _y);
  }

  // инвертировать текст (0-1)
  void invertText(bool inv) {
    _invState = inv;
  }

  void textMode(byte mode) {
    _mode = mode;
  }

  // возвращает true, если дисплей "кончился" - при побуквенном выводе
  bool isEnd() {
    return (_y > _maxRow);
  }

  // ================================== ГРАФИКА ==================================
  // точка (заливка 1/0)
  void dot(int x, int y, byte fill = 1) {
    if (x < 0 || x > _maxX || y < 0 || y > _maxY) return;
    _x = 0;
    _y = 0;
    if (_BUFF) {
      bitWrite(_oled_buffer[_bufIndex(x, y)], y & 0b111, fill);
    } else {
      if (!_buf_flag) {
        setWindow(x, y >> 3, _maxX, _maxRow);
        beginData();
        sendByte(1 << (y & 0b111));  // задвигаем 1 на высоту y
        endTransm();
      } else {
        x -= _bufX;
        y -= _bufY;
        if (x < 0 || x > _bufsizeX || y < 0 || y > (_bufsizeY << 3)) return;
        bitWrite(_buf_ptr[(y >> 3) + x * _bufsizeY], y & 0b111, fill);
      }
    }
  }

  // линия
  void line(int x0, int y0, int x1, int y1, byte fill = 1) {
    _x = 0;
    _y = 0;
    if (x0 == x1) fastLineV(x0, y0, y1, fill);
    else if (y0 == y1) fastLineH(y0, x0, x1, fill);
    else {
      int sx, sy, e2, err;
      int dx = abs(x1 - x0);
      int dy = abs(y1 - y0);
      sx = (x0 < x1) ? 1 : -1;
      sy = (y0 < y1) ? 1 : -1;
      err = dx - dy;
      for (;;) {
        dot(x0, y0, fill);
        if (x0 == x1 && y0 == y1) return;
        e2 = err << 1;
        if (e2 > -dy) {
          err -= dy;
          x0 += sx;
        }
        if (e2 < dx) {
          err += dx;
          y0 += sy;
        }
      }
    }
  }

  // горизонтальная линия
  void fastLineH(int y, int x0, int x1, byte fill = 1) {
    _x = 0;
    _y = 0;
    if (x0 > x1) _swap(x0, x1);
    if (y < 0 || y > _maxY) return;
    if (x0 == x1) {
      dot(x0, y, fill);
      return;
    }
    x1++;
    x0 = constrain(x0, 0, _maxX);
    x1 = constrain(x1, 0, _maxX);
    if (_BUFF) {
      for (int x = x0; x < x1; x++) dot(x, y, fill);
    } else {
      if (_buf_flag) {
        for (int x = x0; x < x1; x++) dot(x, y, fill);
        return;
      }
      byte data = 0b1 << (y & 0b111);
      y >>= 3;
      setWindow(x0, y, x1, y);
      beginData();
      for (int x = x0; x < x1; x++) writeData(data, y, x);
      endTransm();
    }
  }

  // вертикальная линия
  void fastLineV(int x, int y0, int y1, byte fill = 1) {
    _x = 0;
    _y = 0;
    if (y0 > y1) _swap(y0, y1);
    if (x < 0 || x > _maxX) return;
    if (y0 == y1) {
      dot(x, y0, fill);
      return;
    }
    y1++;
    if (_BUFF) {
      for (int y = y0; y < y1; y++) dot(x, y, fill);
    } else {
      if (_buf_flag) {
        for (int y = y0; y < y1; y++) dot(x, y, fill);
        return;
      }
      if (fill) fill = 255;
      byte shift = y0 & 0b111;
      byte shift2 = 8 - (y1 & 0b111);
      if (shift2 == 8) shift2 = 0;
      int height = y1 - y0;
      y0 >>= 3;
      y1 = (y1 - 1) >> 3;
      byte numBytes = y1 - y0;
      setWindow(x, y0, x, y1);

      beginData();
      if (numBytes == 0) {
        if (_inRange(y0, 0, _maxRow)) writeData((fill >> (8 - height)) << shift, y0, x);
      } else {
        if (_inRange(y0, 0, _maxRow)) writeData(fill << shift, y0, x);  // начальный кусок
        y0++;
        for (byte i = 0; i < numBytes - 1; i++, y0++)
          if (_inRange(y0, 0, _maxRow)) writeData(fill, y0, x);          // столбик
        if (_inRange(y0, 0, _maxRow)) writeData(fill >> shift2, y0, x);  // нижний кусок
      }
      endTransm();
    }
  }

  // прямоугольник (лев. верхн, прав. нижн)
  void rect(int x0, int y0, int x1, int y1, byte fill = 1) {
    _x = 0;
    _y = 0;
    if (x0 > x1) _swap(x0, x1);
    if (y0 > y1) _swap(y0, y1);
    if (fill == OLED_STROKE) {
      fastLineH(y0, x0 + 1, x1 - 1);
      fastLineH(y1, x0 + 1, x1 - 1);
      fastLineV(x0, y0, y1);
      fastLineV(x1, y0, y1);
    } else {
      if (x0 == x1 && y0 == y1) {
        dot(x0, y0, fill);
        return;
      }
      if (x0 == x1) {
        fastLineV(x0, y0, y1);
        return;
      }
      if (y0 == y1) {
        fastLineH(y0, x0, x1);
        return;
      }
      if (!_BUFF && fill == OLED_CLEAR) {
        clear(x0, y0, x1, y1);
        return;
      }

      // если рисуем в мини-буфер
      if (_buf_flag) {
        x0 = constrain(x0, 0, _maxX);
        x1 = constrain(x1, 0, _maxX);
        for (byte x = x0; x <= x1; x++) fastLineV(x, y0, y1, fill == OLED_FILL ? 1 : 0);
        return;
      }
      byte thisFill = (fill == OLED_FILL ? 0 : 1);
      // рисуем в олед и в большой буфер
      x1++;
      y1++;
      byte shift = y0 & 0b111;
      byte shift2 = 8 - (y1 & 0b111);
      if (shift2 == 8) shift2 = 0;
      int height = y1 - y0;
      y0 >>= 3;
      y1 = (y1 - 1) >> 3;
      byte numBytes = y1 - y0;
      x0 = constrain(x0, 0, _maxX);
      x1 = constrain(x1, 0, _maxX);

      if (!_BUFF) setWindow(x0, y0, x1, y1);
      if (!_BUFF) beginData();
      for (byte x = x0; x < x1; x++) {
        int y = y0;
        if (numBytes == 0) {
          if (_inRange(y, 0, _maxRow)) writeData((255 >> (8 - height)) << shift, y, x, thisFill);
        } else {
          if (_inRange(y, 0, _maxRow)) writeData(255 << shift, y, x, thisFill);  // начальный кусок
          y++;
          for (byte i = 0; i < numBytes - 1; i++, y++)
            if (_inRange(y, 0, _maxRow)) writeData(255, y, x, thisFill);          // столбик
          if (_inRange(y, 0, _maxRow)) writeData(255 >> shift2, y, x, thisFill);  // нижний кусок
        }
      }
      if (!_BUFF) endTransm();
    }
  }

  // прямоугольник скруглённый (лев. верхн, прав. нижн)
  void roundRect(int x0, int y0, int x1, int y1, byte fill = OLED_FILL) {
    if (fill == OLED_STROKE) {
      fastLineV(x0, y0 + 2, y1 - 2);
      fastLineV(x1, y0 + 2, y1 - 2);
      fastLineH(y0, x0 + 2, x1 - 2);
      fastLineH(y1, x0 + 2, x1 - 2);
      dot(x0 + 1, y0 + 1);
      dot(x1 - 1, y0 + 1);
      dot(x1 - 1, y1 - 1);
      dot(x0 + 1, y1 - 1);
    } else {
      fastLineV(x0, y0 + 2, y1 - 2, fill);
      fastLineV(x0 + 1, y0 + 1, y1 - 1, fill);
      fastLineV(x1 - 1, y0 + 1, y1 - 1, fill);
      fastLineV(x1, y0 + 2, y1 - 2, fill);
      rect(x0 + 2, y0, x1 - 2, y1, fill);
    }
  }

  // окружность (центр х, центр у, радиус, заливка)
  void circle(int x, int y, int radius, byte fill = OLED_FILL) {
    //if (!_BUFF) createBuffer(x - radius, y - radius, x + radius + 1, y + radius);
    int f = 1 - radius;
    int ddF_x = 1;
    int ddF_y = -2 * radius;
    int x1 = 0;
    int y1 = radius;

    byte fillLine = (fill == OLED_CLEAR) ? 0 : 1;
    dot(x, y + radius, fillLine);
    dot(x, y - radius, fillLine);
    dot(x + radius, y, fillLine);
    dot(x - radius, y, fillLine);
    //if (fill != OLED_STROKE) fastLineH(y, x - radius, x + radius-1, fillLine);
    if (fill != OLED_STROKE) fastLineV(x, y - radius, y + radius - 1, fillLine);
    while (x1 < y1) {
      if (f >= 0) {
        y1--;
        ddF_y += 2;
        f += ddF_y;
      }
      x1++;
      ddF_x += 2;
      f += ddF_x;
      if (fill == OLED_STROKE) {
        dot(x + x1, y + y1);
        dot(x - x1, y + y1);
        dot(x + x1, y - y1);
        dot(x - x1, y - y1);
        dot(x + y1, y + x1);
        dot(x - y1, y + x1);
        dot(x + y1, y - x1);
        dot(x - y1, y - x1);
      } else {  // FILL / CLEAR

        fastLineV(x + x1, y - y1, y + y1, fillLine);
        fastLineV(x - x1, y - y1, y + y1, fillLine);
        fastLineV(x + y1, y - x1, y + x1, fillLine);
        fastLineV(x - y1, y - x1, y + x1, fillLine);
        /*
                fastLineH(y + y1, x - x1, x + x1-1, fillLine);
                fastLineH(y - y1, x - x1, x + x1-1, fillLine);
                fastLineH(y + x1, x - y1, x + y1-1, fillLine);
                fastLineH(y - x1, x - y1, x + y1-1, fillLine);    
                */
      }
    }
    //if (!_BUFF) sendBuffer();
  }
  void bezier(int* arr, uint8_t size, uint8_t dense, uint8_t fill = 1) {
    int a[size * 2];
    for (int i = 0; i < (1 << dense); i++) {
      for (int j = 0; j < size * 2; j++) a[j] = arr[j];
      for (int j = (size - 1) * 2 - 1; j > 0; j -= 2)
        for (int k = 0; k <= j; k++)
          a[k] = a[k] + (((a[k + 2] - a[k]) * i) >> dense);
      dot(a[0], a[1], fill);
    }
  }

  // вывести битмап
  void drawBitmap(int x, int y, const uint8_t* frame, int width, int height, uint8_t invert = 0, byte mode = 0) {
    _x = 0;
    _y = 0;
    if (invert) invert = 255;
    byte left = height & 0b111;
    if (left != 0) height += (8 - left);                              // округляем до ближайшего кратного степени 2
    int shiftY = (y >> 3) + (height >> 3);                            // строка (row) крайнего байта битмапа
    setWindowShift(x, y, width, height);                              // выделяем окно
    bool bottom = (_shift != 0 && shiftY >= 0 && shiftY <= _maxRow);  // рисовать ли нижний сдвинутый байт

    if (!_BUFF) beginData();
    for (int X = x, countX = 0; X < x + width; X++, countX++) {  // в пикселях
      byte prevData = 0;
      if (_inRange(X, 0, _maxX)) {                                                                              // мы внутри дисплея по X
        for (int Y = y >> 3, countY = 0; Y < shiftY; Y++, countY++) {                                           // в строках (пикс/8)
          byte data = pgm_read_word(&(frame[countY * width + countX])) ^ invert;                                // достаём байт
          if (_shift == 0) {                                                                                    // без сдвига по Y
            if (_inRange(Y, 0, _maxRow)) writeData(data, Y, X, mode);                                           // мы внутри дисплея по Y
          } else {                                                                                              // со сдвигом по Y
            if (_inRange(Y, 0, _maxRow)) writeData((prevData >> (8 - _shift)) | (data << _shift), Y, X, mode);  // задвигаем
            prevData = data;
          }
        }
        if (bottom) writeData(prevData >> (8 - _shift), shiftY, X, mode);  // нижний байт
      }
    }
    if (!_BUFF) endTransm();
  }

  // залить весь дисплей указанным байтом
  void fill(uint8_t data) {
    if (_BUFF) memset(_oled_buffer, data, _bufSize);
    else {
      if (_TYPE < 2 || 1) {  // для SSD1306
        setWindow(0, 0, _maxX, _maxRow);
        beginData();
        for (int i = 0; i < (_TYPE ? 1024 : 512); i++) sendByte(data);
        endTransm();
      } else {  // для SSH1108
      }
    }
    setCursorXY(_x, _y);
  }

  // шлёт байт в "столбик" setCursor() и setCursorXY()
  void drawByte(uint8_t data) {
    if (++_x > _maxX) return;
    if (_TYPE < 2 || 1) {  // для SSD1306
      if (!_BUFF) beginData();
      if (_shift == 0) {                     // если вывод без сдвига на строку
        writeData(data);                     // выводим
      } else {                               // со сдвигом
        writeData(data << _shift);           // верхняя часть
        writeData(data >> (8 - _shift), 1);  // нижняя часть со сдвигом на 1
      }
      if (!_BUFF) endTransm();
    } else {
      // для SSH1106
      /*            
            int h = y & 0x07;            
            if (_BUFF) {
                for (int p = 0; p < 2; p++) {
                    Wire.beginTransmission(_address);
                    continueCmd(0xB0 + (y >> 3) + p);        // Page
                    continueCmd(0x00 + ((x + 2) & 0x0F));    // Column low nibble
                    continueCmd(0x10 + ((x + 2) >> 4));      // Column high nibble
                    continueCmd(0xE0);            // Read modify write
                    Wire.write(OLED_ONE_DATA_MODE);
                    Wire.endTransmission();
                    Wire.requestFrom((int)_address, 2);
                    Wire.read();                                // Dummy read
                    int j = Wire.read();
                    Wire.beginTransmission(_address);
                    Wire.write(OLED_ONE_DATA_MODE);
                    Wire.write((data << h) >> (p << 3) | j);
                    continueCmd(0xEE);                       // Cancel read modify write
                    Wire.endTransmission();
                }
            } else {
                for (int p = 0; p < 2; p++) {
                    Wire.beginTransmission(_address);
                    continueCmd(0xB0 + (y >> 3) + p);        // Page
                    continueCmd(0x00 + ((x + 2) & 0x0F));    // Column low nibble
                    continueCmd(0x10 + ((x + 2) >> 4));      // Column high nibble
                    Wire.write(OLED_ONE_DATA_MODE);
                    Wire.write((data << h) >> (p << 3));
                    Wire.endTransmission();
                }
            }*/
    }
  }

  // вывести одномерный байтовый массив (линейный битмап высотой 8)
  void drawBytes(uint8_t* data, byte size) {
    if (!_BUFF) beginData();
    for (byte i = 0; i < size; i++) {
      if (++_x > _maxX) return;
      if (_shift == 0) {                        // если вывод без сдвига на строку
        writeData(data[i]);                     // выводим
      } else {                                  // со сдвигом
        writeData(data[i] << _shift);           // верхняя часть
        writeData(data[i] >> (8 - _shift), 1);  // нижняя часть со сдвигом на 1
      }
    }
    if (!_BUFF) endTransm();
  }

  // ================================== СИСТЕМНОЕ ===================================
  // полностью обновить дисплей из буфера
  void update() {
    if (_BUFF) {
      if (_TYPE < 2) {  // для 1306
        setWindow(0, 0, _maxX, _maxRow);
        beginData();
        for (int i = 0; i < (_TYPE ? 1024 : 512); i++) sendByte(_oled_buffer[i]);
        endTransm();
      } else {  // для 1106
        sendCommand(0x00);
        sendCommand(0x10);
        sendCommand(0x40);
        uint16_t ptr = 0;
        for (uint8_t i = 0; i < (64 >> 3); i++) {
          sendCommand(0xB0 + i + 0);  //set page address
          sendCommand(2 & 0xf);       //set lower column address
          sendCommand(0x10);          //set higher column address
          for (uint8_t a = 0; a < 8; a++) {
            beginData();
            for (uint8_t b = 0; b < (OLED_WIDTH >> 3); b++) {
              sendByteRaw(_oled_buffer[((ptr & 0x7F) << 3) + (ptr >> 7)]);
              ptr++;
            }
            endTransm();
          }
        }
      }
    }
  }

  // выборочно обновить дисплей из буфера (x0, y0, x1, y1)
  void update(int x0, int y0, int x1, int y1) {
    if (_BUFF) {
      y0 >>= 3;
      y1 >>= 3;
      setWindow(x0, y0, x1, y1);
      beginData();
      for (int x = x0; x < x1; x++)
        for (int y = y0; y < y1 + 1; y++)
          if (x >= 0 && x <= _maxX && y >= 0 && y <= _maxRow)
            sendByte(_oled_buffer[y + x * (_TYPE ? 8 : 4)]);
      endTransm();
    }
  }

  // отправить байт по i2с или в буфер
  void writeData(byte data, byte offsetY = 0, byte offsetX = 0, int mode = 0) {
    if (_BUFF) {
      switch (mode) {
        case 0:
          _oled_buffer[_bufIndex(_x + offsetX, _y) + offsetY] |= data;  // добавить
          break;
        case 1:
          _oled_buffer[_bufIndex(_x + offsetX, _y) + offsetY] &= ~data;  // вычесть
          break;
        case 2:
          _oled_buffer[_bufIndex(_x + offsetX, _y) + offsetY] = data;  // заменить
          break;
      }
    } else {
      if (_buf_flag) {
        int x = _x - _bufX;
        int y = _y - _bufY;
        if (x < 0 || x > _bufsizeX || y < 0 || y > (_bufsizeY << 3)) return;
        switch (mode) {
          case 0:
            _buf_ptr[(y >> 3) + x * _bufsizeY] |= data;  // добавить
            break;
          case 1:
            _buf_ptr[(y >> 3) + x * _bufsizeY] &= ~data;  // вычесть
            break;
          case 2:
            _buf_ptr[(y >> 3) + x * _bufsizeY] = data;  // заменить
            break;
        }
      } else {
        sendByte(data);
      }
    }
  }

  // окно со сдвигом. x 0-127, y 0-63 (31), ширина в пикселях, высота в пикселях
  void setWindowShift(int x0, int y0, int sizeX, int sizeY) {
    _shift = y0 & 0b111;
    if (!_BUFF) setWindow(x0, (y0 >> 3), x0 + sizeX, (y0 + sizeY - 1) >> 3);
  }

  // ================== ДИНАМИЧЕСКИЙ БУФЕР ================
  // создать
  bool createBuffer(int x0, int y0, int x1, int y1, byte fill = 0) {
    if (!_BUFF) {
      _bufX = x0;
      _bufY = y0;
      _bufsizeX = x1 - x0 + 1;
      _bufsizeY = ((y1 - y0) >> 3) + 1;

      int bufSize = _bufsizeX * _bufsizeY;
      _buf_ptr = (byte*)malloc(bufSize);
      if (_buf_ptr != NULL) {
        _buf_flag = true;
        memset(_buf_ptr, fill, bufSize);
        return true;
      } else {
        _buf_flag = false;
        return false;
      }
    }
  }

  // отправить
  void sendBuffer() {
    if (!_BUFF) {
      if (_buf_flag) {
        setWindow(_bufX, _bufY >> 3, _bufX + _bufsizeX, (_bufY >> 3) + _bufsizeY - 1);
        beginData();
        for (int i = 0; i < _bufsizeX * _bufsizeY; i++) {
          sendByte(_buf_ptr[i]);
        }
        endTransm();
        _buf_flag = false;
        free(_buf_ptr);
      }
    }
  }

  // ========= ЛОУ-ЛЕВЕЛ ОТПРАВКА =========

  // супер-костыль для либы Wire. Привет индусам!
  void sendByte(uint8_t data) {
    sendByteRaw(data);
#if !defined(microWire_h)
    if (!_CONN) {
      _writes++;
      if (_writes >= 16) {
        endTransm();
        beginData();
      }
    }
#endif
  }
  void sendByteRaw(uint8_t data) {
    Wire.write(data);
  }


  // отправить команду
  void sendCommand(uint8_t cmd1) {
    beginOneCommand();
    sendByteRaw(cmd1);
    endTransm();
  }

  // отправить код команды и команду
  void sendCommand(uint8_t cmd1, uint8_t cmd2) {
    beginCommand();
    sendByteRaw(cmd1);
    sendByteRaw(cmd2);
    endTransm();
  }

  // выбрать "окно" дисплея
  void setWindow(int x0, int y0, int x1, int y1) {
    beginCommand();
    sendByteRaw(OLED_COLUMNADDR);
    sendByteRaw(constrain(x0, 0, _maxX));
    sendByteRaw(constrain(x1, 0, _maxX));
    sendByteRaw(OLED_PAGEADDR);
    sendByteRaw(constrain(y0, 0, _maxRow));
    sendByteRaw(constrain(y1, 0, _maxRow));
    endTransm();
  }

  void beginData() {
    startTransm();
    if (_CONN) fastWrite(_DC, 1);
    else sendByteRaw(OLED_DATA_MODE);
  }

  void beginCommand() {
    startTransm();
    if (_CONN) fastWrite(_DC, 0);
    else sendByteRaw(OLED_COMMAND_MODE);
  }

  void beginOneCommand() {
    startTransm();
    if (_CONN) fastWrite(_DC, 0);
    else sendByteRaw(OLED_ONE_COMMAND_MODE);
  }

  void endTransm() {
    Wire.endTransmission();
    _writes = 0;
  }

  void startTransm() {
    Wire.beginTransmission(_address);
  }


  // получить "столбик-байт" буквы
  uint8_t getFont(uint8_t font, uint8_t row) {
#ifndef OLED_NO_PRINT
    if (row > 4) return 0;
    font = font - '0' + 16;  // перевод код символа из таблицы ASCII
    if (font <= 95) {
      return pgm_read_byte(&(_charMap[font][row]));  // для английских букв и символов
    } else if (font >= 96 && font <= 111) {          // и пизд*ц для русских
      return pgm_read_byte(&(_charMap[font + 47][row]));
    } else if (font <= 159) {
      return pgm_read_byte(&(_charMap[font - 17][row]));
    } else {
      return pgm_read_byte(&(_charMap[font - 1][row]));  // для кастомных (ё)
    }
#endif
  }

  // ==================== ПЕРЕМЕННЫЕ И КОНСТАНТЫ ====================
  const uint8_t _address = 0x3C;
  const uint8_t _maxRow = (_TYPE ? 8 : 4) - 1;
  const uint8_t _maxY = (_TYPE ? 64 : 32) - 1;
  const uint8_t _maxX = OLED_WIDTH - 1;  // на случай добавления мелких дисплеев

  // софт. буфер
  const int _bufSize = ((_BUFF == 1) ? (_TYPE ? BUFSIZE_128x64 : BUFSIZE_128x32) : 0);
  uint8_t _oled_buffer[((_BUFF == 1) ? (_TYPE ? BUFSIZE_128x64 : BUFSIZE_128x32) : 0)];
private:
  // всякое
  void fastWrite(const uint8_t pin, bool val) {
#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
    if (pin < 8) bitWrite(PORTD, pin, val);
    else if (pin < 14) bitWrite(PORTB, (pin - 8), val);
    else if (pin < 20) bitWrite(PORTC, (pin - 14), val);
#elif defined(__AVR_ATtiny85__) || defined(__AVR_ATtiny13__)
    bitWrite(PORTB, pin, val);
#else
  digitalWrite(pin, val);
#endif
  }
  // индекс в буфере
  int _bufIndex(int x, int y) {
    return ((y) >> 3) + ((x) << (_TYPE ? 3 : 2));  // _y / 8 + _x * (4 или 8)
  }
  void _swap(int& x, int& y) {
    int z = x;
    x = y;
    y = z;
  }
  bool _inRange(int x, int mi, int ma) {
    return x >= mi && x <= ma;
  }

  bool _invState = 0;
  bool _println = false;
  bool _getn = false;
  uint8_t _scaleX = 1, _scaleY = 8;
  int _x = 0, _y = 0;
  uint8_t _shift = 0;
  uint8_t _lastChar;
  uint8_t _writes = 0;
  uint8_t _mode = 2;

  // дин. буфер
  int _bufsizeX, _bufsizeY;
  int _bufX, _bufY;
  uint8_t* _buf_ptr;
  bool _buf_flag = false;
};
#endif