// This file is part of the 64k demo project.
// It implements the Hybrid3DEffect.

#include "gpu/effects/hybrid_3d_effect.h"
#include "generated/assets.h"
#include "util/asset_manager.h"
#include <cassert>
#include <cmath>
#include <iostream>

Hybrid3DEffect::Hybrid3DEffect(WGPUDevice device, WGPUQueue queue,
                               WGPUTextureFormat format)
    : Effect(device, queue), width_(1280), height_(720) {
  (void)format; // Passed to base, not directly used here.
}

void Hybrid3DEffect::init(MainSequence* demo) {
  (void)demo;
  WGPUTextureFormat format =
      demo->format; // Get current format from MainSequence (might be different
                    // than constructor if resized)

  renderer_.init(device_, queue_, format);
  renderer_.resize(width_, height_);

  // Texture Manager
  texture_manager_.init(device_, queue_);

  // Load Noise Asset
  size_t size = 0;
  const uint8_t* noise_data = GetAsset(AssetId::ASSET_NOISE_TEX, &size);
  if (noise_data && size == 256 * 256 * 4) {
    texture_manager_.create_texture("noise", 256, 256, noise_data);
    renderer_.set_noise_texture(texture_manager_.get_texture_view("noise"));
  } else {
    std::cerr << "Failed to load NOISE_TEX asset." << std::endl;
  }

  // Setup Scene
  scene_.clear();
  Object3D center(ObjectType::BOX); // Use BOX for bumps
  center.position = vec3(0, 0, 0);
  center.color = vec4(1, 0, 0, 1);
  scene_.add_object(center);

  for (int i = 0; i < 8; ++i) {
    ObjectType type = ObjectType::SPHERE;
    if (i % 3 == 1)
      type = ObjectType::TORUS;
    if (i % 3 == 2)
      type = ObjectType::BOX;

    Object3D obj(type);
    float angle = (i / 8.0f) * 6.28318f;
    obj.position = vec3(std::cos(angle) * 4.0f, 0, std::sin(angle) * 4.0f);
    obj.scale = vec3(0.5f, 0.5f, 0.5f);

    if (type == ObjectType::SPHERE)
      obj.color = vec4(0, 1, 0, 1);
    else if (type == ObjectType::TORUS)
      obj.color = vec4(0, 0.5, 1, 1);
    else
      obj.color = vec4(1, 1, 0, 1);

    scene_.add_object(obj);
  }
}

void Hybrid3DEffect::render(WGPURenderPassEncoder pass, float time, float beat,
                            float intensity, float aspect_ratio) {
  // Animate Objects
  for (size_t i = 1; i < scene_.objects.size(); ++i) {
    scene_.objects[i].rotation =
        quat::from_axis(vec3(0, 1, 0), time * 2.0f + i);
    scene_.objects[i].position.y = std::sin(time * 3.0f + i) * 1.5f;
  }

  // Animate Camera
  float cam_radius = 10.0f + std::sin(time * 0.3f) * 4.0f;
  float cam_height = 5.0f + std::cos(time * 0.4f) * 3.0f;
  camera_.set_look_at(vec3(std::sin(time * 0.5f) * cam_radius, cam_height,
                           std::cos(time * 0.5f) * cam_radius),
                      vec3(0, 0, 0), vec3(0, 1, 0));

  camera_.aspect_ratio = aspect_ratio;

  // Draw
  renderer_.draw(pass, scene_, camera_, time);
}