#include "renderer.h"
#include "consts.h"
#include "game.h"
#include "map.h"
#include "transform_system.h"
#include "camera_system.h"

Renderer::Renderer() {
  win_ = window_ptr(
    SDL_CreateWindow(
      "Tanetane",
      100,
      100,
      GAME_WIDTH,
      GAME_HEIGHT,
      SDL_WINDOW_SHOWN));

  if (!win_)
  {
    throw sdl_error();
  }

  ren_ = renderer_ptr(
    SDL_CreateRenderer(
      win_.get(),
      -1,
      SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC));

  if (!ren_)
  {
    throw sdl_error();
  }
}

texture_ptr Renderer::renderMapLayer(const Map& map, int layer) {
  vec2i mapBounds = map.getMapSize() * map.getTileSize();

  texture_ptr canvas(
    SDL_CreateTexture(
      ren_.get(),
      SDL_PIXELFORMAT_RGBA8888,
      SDL_TEXTUREACCESS_TARGET,
      mapBounds.w(),
      mapBounds.h()));

  SDL_SetTextureBlendMode(canvas.get(), SDL_BLENDMODE_BLEND);

  SDL_SetRenderTarget(ren_.get(), canvas.get());
  SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_BLEND);
  SDL_SetRenderDrawColor(ren_.get(), 255, 255, 255, 0);
  SDL_RenderClear(ren_.get());

  const std::vector<Tile>& tiles = map.getLayers().at(layer);
  for (int y = 0; y < map.getMapSize().h(); y++) {
    for (int x = 0; x < map.getMapSize().w(); x++) {
      const Tile& tile = tiles.at(x + y * map.getMapSize().w());

      SDL_Rect srcRect {
        static_cast<int>((tile.id % map.getTilesetColumns()) * map.getTileSize().w()),
        static_cast<int>((tile.id / map.getTilesetColumns()) * map.getTileSize().h()),
        map.getTileSize().w(),
        map.getTileSize().h() };

      SDL_Rect destRect {
        x * map.getTileSize().w(),
        y * map.getTileSize().h(),
        map.getTileSize().w(),
        map.getTileSize().h() };

      SDL_RendererFlip flip = SDL_FLIP_NONE;
      if (tile.flipHorizontal && tile.flipVertical) {
        flip = static_cast<SDL_RendererFlip>(SDL_FLIP_HORIZONTAL | SDL_FLIP_VERTICAL);
      } else if (tile.flipHorizontal) {
        flip = SDL_FLIP_HORIZONTAL;
      } else if (tile.flipVertical) {
        flip = SDL_FLIP_VERTICAL;
      }
      SDL_RenderCopyEx(ren_.get(), textures_[map.getTilesetTextureId()].get(), &srcRect, &destRect, 0, nullptr, flip);
    }
  }

  return canvas;
}

void Renderer::render(Game& game) {
  if (!renLay1_) {
    renLay1_ = renderMapLayer(game.getMap(), 0);
  }
  if (!renLay0_) {
    renLay0_ = renderMapLayer(game.getMap(), 1);
  }

  vec2i mapBounds = game.getMap().getMapSize() * game.getMap().getTileSize();

  texture_ptr canvas(
    SDL_CreateTexture(
      ren_.get(),
      SDL_PIXELFORMAT_RGBA8888,
      SDL_TEXTUREACCESS_TARGET,
      mapBounds.w(),
      mapBounds.h()));

  if (!canvas) {
    throw sdl_error();
  }

  SDL_SetRenderTarget(ren_.get(), canvas.get());
  SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_NONE);
  SDL_SetRenderDrawColor(ren_.get(), 255, 255, 255, 255);
  SDL_RenderClear(ren_.get());

  SDL_RenderCopy(ren_.get(), renLay1_.get(), nullptr, nullptr);

  for (const Sprite& sprite : game.getSystem<TransformSystem>().getSpritesByY() | game.spriteView()) {
    const SpriteFrame& frame = sprite.getFrame();
    const SDL_Rect& src = frame.srcRect;
    SDL_Rect dest { sprite.loc().x() - frame.center.x(), sprite.loc().y() - frame.center.y(), frame.size.w(), frame.size.h() };
    SDL_RenderCopy(ren_.get(), textures_.at(sprite.getTextureId()).get(), &src, &dest);
  }

  SDL_RenderCopy(ren_.get(), renLay0_.get(), nullptr, nullptr);

  SDL_Rect cameraField {
    game.getSystem<CameraSystem>().getCameraPosition().x(),
    game.getSystem<CameraSystem>().getCameraPosition().y(),
    game.getSystem<CameraSystem>().getFieldOfView().w(),
    game.getSystem<CameraSystem>().getFieldOfView().h()
  };

  SDL_SetRenderTarget(ren_.get(), nullptr);
  SDL_RenderCopy(ren_.get(), canvas.get(), &cameraField, nullptr);
  SDL_RenderPresent(ren_.get());
}

int Renderer::loadImageFromFile(std::string_view filename) {
  surface_ptr pfs(IMG_Load(filename.data()));
  if (!pfs)
  {
    throw img_error();
  }

  texture_ptr tex = texture_ptr(SDL_CreateTextureFromSurface(ren_.get(), pfs.get()));
  //SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);

  int texId = textures_.size();
  textures_.push_back(std::move(tex));

  return texId;
}