#include "tiled_image_item.h"

#include <QSGImageNode>

#include <QSGTexture>

TiledImageItem::TiledImageItem(QQuickItem *parent) : QQuickItem{parent} {

  setFlag(ItemHasContents, true);

  setFlag(ItemObservesViewport, true);

}

TiledImageItem::~TiledImageItem() {}

void TiledImageItem::setImageData(int width, int height, uchar *pixels,

                                  QImage::Format format) {

  m_texture = QImage{pixels, width, height, width * 4, format};

  setImplicitWidth(width / window()->effectiveDevicePixelRatio());

  setImplicitHeight(height / window()->effectiveDevicePixelRatio());

  buildTiles();

  update();

}

void TiledImageItem::buildTiles() {

  m_tiles.clear();

  if (m_texture.isNull()) {

    return;

  }

  const auto imageWidth = m_texture.width();

  const auto imageHeight = m_texture.height();

  for (int y = 0; y < imageHeight; y += m_tileSize) {

    for (int x = 0; x < imageWidth; x += m_tileSize) {

      int w = qMin(m_tileSize, imageWidth - x);

      int h = qMin(m_tileSize, imageHeight - y);

      QImage tileImage{&m_texture.scanLine(y)[x * m_texture.depth() / 8],

                       m_tileSize, m_tileSize, m_texture.bytesPerLine(),

                       m_texture.format()};

      QRectF tileRect = QRect{x, y, w, h}.toRectF();

      tileRect.setTopLeft(tileRect.topLeft() /

                          window()->effectiveDevicePixelRatio());

      tileRect.setBottomRight(tileRect.bottomRight() /

                              window()->effectiveDevicePixelRatio());

      Tile tile;

      tile.outRect = tileRect;

      tile.image = tileImage;

      tile.dirty = true;

      m_tiles.emplace_back(std::move(tile));

    }

  }

}

int TiledImageItem::tileSize() const { return m_tileSize; }

void TiledImageItem::setTileSize(int newTileSize) {

  if (m_tileSize == newTileSize) {

    return;

  }

  m_tileSize = newTileSize;

  m_tiles.clear();

  m_dirty = true;

  Q_EMIT tileSizeChanged();

}

void TiledImageItem::test(const QString &fileName) {

  auto image = new QImage(fileName);

  setImageData(image->width(), image->height(), image->bits(), image->format());

}

QSGNode *TiledImageItem::updatePaintNode(QSGNode *oldNode,

                                         UpdatePaintNodeData *) {

  auto rootNode = oldNode;

  if (!rootNode) {

    rootNode = new QSGNode{};

  }

  if (!window()) {

    return rootNode;

  }

  const auto rect = clipRect();

  for (auto &tile : m_tiles) {

    if (!rect.intersects(tile.outRect)) {

      if (tile.node) {

        rootNode->removeChildNode(tile.node.get());

        tile.node.reset();

      }

      continue;

    }

    if (tile.dirty) {

      tile.texture.reset(window()->createTextureFromImage(tile.image));

      if (tile.node) {

        tile.node->setTexture(tile.texture.get());

      }

      tile.dirty = false;

    }

    if (!tile.node) {

      tile.node.reset(window()->createImageNode());

      tile.node->setRect(tile.outRect);

      tile.node->setTexture(tile.texture.get());

      rootNode->appendChildNode(tile.node.get());

    }

  }

  return rootNode;

}

TiledImageItem::Tile::Tile(Tile &&other) noexcept

    : outRect{other.outRect},

      image{std::move(other.image)},

      dirty{other.dirty},

      texture{std::move(other.texture)} {}