// This file is part of the 64k demo project.
// It declares the concrete effects used in the demo.

#pragma once
#include "3d/camera.h"
#include "3d/renderer.h"
#include "3d/scene.h"
#include "effect.h"
#include "gpu/effects/circle_mask_effect.h"
#include "gpu/effects/fade_effect.h"  // FadeEffect with full definition
#include "gpu/effects/flash_effect.h" // FlashEffect with params support
#include "gpu/effects/post_process_helper.h"
#include "gpu/effects/rotating_cube_effect.h"
#include "gpu/effects/shaders.h"
#include "gpu/effects/theme_modulation_effect.h" // ThemeModulationEffect with full definition
#include "gpu/gpu.h"
#include "gpu/texture_manager.h"
#include "gpu/uniform_helper.h"
#include <memory>

static const int NUM_PARTICLES = 10000;

struct Particle {
  float pos[4];
  float vel[4];
  float rot[4];
  float color[4];
};

class HeptagonEffect : public Effect {
 public:
  HeptagonEffect(const GpuContext& ctx);
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;

 private:
  RenderPass pass_;
};

class ParticlesEffect : public Effect {
 public:
  ParticlesEffect(const GpuContext& ctx);
  void compute(WGPUCommandEncoder encoder, float time, float beat,
               float intensity, float aspect_ratio) override;
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;

 private:
  ComputePass compute_pass_;
  RenderPass render_pass_;
  GpuBuffer particles_buffer_;
  UniformBuffer<CommonPostProcessUniforms> uniforms_;
};

class PassthroughEffect : public PostProcessEffect {
 public:
  PassthroughEffect(const GpuContext& ctx);
  void update_bind_group(WGPUTextureView input_view) override;

 private:
  UniformBuffer<CommonPostProcessUniforms> uniforms_;
};

class MovingEllipseEffect : public Effect {
 public:
  MovingEllipseEffect(const GpuContext& ctx);
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;

 private:
  RenderPass pass_;
};

class ParticleSprayEffect : public Effect {
 public:
  ParticleSprayEffect(const GpuContext& ctx);
  void compute(WGPUCommandEncoder encoder, float time, float beat,
               float intensity, float aspect_ratio) override;
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;

 private:
  ComputePass compute_pass_;
  RenderPass render_pass_;
  GpuBuffer particles_buffer_;
  UniformBuffer<CommonPostProcessUniforms> uniforms_;
};

// Parameters for GaussianBlurEffect (set at construction time)
struct GaussianBlurParams {
  float strength = 2.0f; // Default: 2.0 pixel blur radius
  float _pad = 0.0f;
};
static_assert(sizeof(GaussianBlurParams) == 8,
              "GaussianBlurParams must be 8 bytes for WGSL alignment");

class GaussianBlurEffect : public PostProcessEffect {
 public:
  // Backward compatibility constructor (uses default params)
  GaussianBlurEffect(const GpuContext& ctx);
  // New parameterized constructor
  GaussianBlurEffect(const GpuContext& ctx, const GaussianBlurParams& params);
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;
  void update_bind_group(WGPUTextureView input_view) override;

 private:
  GaussianBlurParams params_;
  UniformBuffer<CommonPostProcessUniforms> uniforms_;
  UniformBuffer<GaussianBlurParams> params_buffer_;
};

class SolarizeEffect : public PostProcessEffect {
 public:
  SolarizeEffect(const GpuContext& ctx);
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;
  void update_bind_group(WGPUTextureView input_view) override;

 private:
  UniformBuffer<CommonPostProcessUniforms> uniforms_;
};

// Parameters for VignetteEffect
struct VignetteParams {
  float radius = 0.5f;   // Radius of the clear center
  float softness = 0.5f; // Softness of the vignette edge
};

class VignetteEffect : public PostProcessEffect {
 public:
  VignetteEffect(const GpuContext& ctx);
  VignetteEffect(const GpuContext& ctx, const VignetteParams& params);
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;
  void update_bind_group(WGPUTextureView input_view) override;

 private:
  VignetteParams params_;
  UniformBuffer<CommonPostProcessUniforms> uniforms_;
  UniformBuffer<VignetteParams> params_buffer_;
};

// Parameters for ChromaAberrationEffect (set at construction time)
struct ChromaAberrationParams {
  float offset_scale = 0.02f; // Default: 2% screen offset
  float angle = 0.0f;         // Default: horizontal (0 radians)
};

class ChromaAberrationEffect : public PostProcessEffect {
 public:
  // Backward compatibility constructor (uses default params)
  ChromaAberrationEffect(const GpuContext& ctx);
  // New parameterized constructor
  ChromaAberrationEffect(const GpuContext& ctx,
                         const ChromaAberrationParams& params);
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;
  void update_bind_group(WGPUTextureView input_view) override;

 private:
  ChromaAberrationParams params_;
  UniformBuffer<CommonPostProcessUniforms> uniforms_;
  UniformBuffer<ChromaAberrationParams> params_buffer_;
};

class Hybrid3DEffect : public Effect {
 public:
  Hybrid3DEffect(const GpuContext& ctx);
  void init(MainSequence* demo) override;
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;

 private:
  Renderer3D renderer_;
  TextureManager texture_manager_;
  Scene scene_;
  Camera camera_;
  int width_ = 1280;
  int height_ = 720;
};

class FlashCubeEffect : public Effect {
 public:
  FlashCubeEffect(const GpuContext& ctx);
  void init(MainSequence* demo) override;
  void resize(int width, int height) override;
  void render(WGPURenderPassEncoder pass, float time, float beat,
              float intensity, float aspect_ratio) override;

 private:
  Renderer3D renderer_;
  TextureManager texture_manager_;
  Scene scene_;
  Camera camera_;
  int width_ = 1280;
  int height_ = 720;
  float last_beat_;
  float flash_intensity_;
};

// ThemeModulationEffect now defined in gpu/effects/theme_modulation_effect.h
// (included above) FadeEffect now defined in gpu/effects/fade_effect.h
// (included above) FlashEffect now defined in gpu/effects/flash_effect.h
// (included above)

// Auto-generated functions
void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx);
float GetDemoDuration(); // Returns demo end time in seconds, or -1 if not
                         // specified