#pragma once

#include <SDL3/SDL.h>  // Para SDL_FRect, SDL_FPoint, SDL_Texture, SDL_Renderer

#include <array>       // Para array
#include <cstddef>     // Para size_t
#include <functional>  // Para std::function
#include <memory>      // Para unique_ptr, shared_ptr
#include <vector>      // Para vector

#include "color.h"  // Para Color

class MovingSprite;
class Sprite;
class Texture;

/*
    Esta clase gestiona el fondo que aparece en la sección jugable.

    Maneja internamente su progresión a través de diferentes estados del día/noche,
    controlando las transiciones entre gradientes, posiciones del sol/luna y velocidad de nubes.

    Estados:
    - NORMAL: Progresión normal del día
    - COMPLETED: Reducción gradual de la actividad (nubes más lentas)

    Métodos clave:
    - incrementProgress() -> Avanza la progresión del fondo
    - setState() -> Cambia el estado del fondo
    - setColor/setAlpha -> Efectos de atenuación
*/

class Background {
    public:
        // Enumeración de estados
        enum class State {
            NORMAL,
            COMPLETED
        };

        // Constructor y Destructor
        Background(float total_progress_to_complete = 6100.0f);
        ~Background();

        // Actualización y renderizado
        void update();  // Actualiza la lógica del objeto
        void render();  // Dibuja el objeto

        // Configuración de posición
        void setPos(SDL_FRect pos);  // Establece la posición del objeto

        // Control de progresión
        void incrementProgress(float amount = 1.0f);  // Incrementa la progresión interna
        void setProgress(float absolute_progress);    // Establece la progresión absoluta
        void setState(State new_state);               // Cambia el estado del fondo
        void reset();                                 // Reinicia la progresión

        // Sistema de callback para sincronización automática
        using ProgressCallback = std::function<void(float)>;
        void setProgressCallback(ProgressCallback callback);  // Establece callback para sincronización
        void removeProgressCallback();                        // Elimina el callback

        // Configuración manual (para uso fuera del juego principal)
        void setManualMode(bool manual);          // Activa/desactiva el modo manual
        void setCloudsSpeed(float value);         // Ajusta la velocidad de las nubes
        void setGradientNumber(int value);        // Establece el degradado de fondo
        void setTransition(float value);          // Ajusta la transición entre texturas
        void setSunProgression(float progress);   // Establece la posición del sol
        void setMoonProgression(float progress);  // Establece la posición de la luna

        // Configuración de efectos visuales
        void setColor(Color color);  // Establece el color de atenuación
        void setAlpha(int alpha);    // Ajusta la transparencia del fondo

        // Getters para información del estado
        float getProgress() const { return progress_; }
        State getState() const { return state_; }
        int getCurrentGradient() const { return static_cast<int>(gradient_number_); }

    private:
        // Constantes de configuración
        static constexpr size_t STAGES = 4;
        static constexpr float COMPLETED_REDUCTION_RATE = 25.0f;
        static constexpr float MINIMUM_COMPLETED_PROGRESS = 200.0f;
        static constexpr float SUN_COMPLETION_FACTOR = 0.5f;  // El sol completa su recorrido a la mitad del progreso total

        // Configuración paramétrica
        const float total_progress_to_complete_;
        const float progress_per_stage_;
        const float sun_completion_progress_;

        // Objetos y punteros
        SDL_Renderer *renderer_;  // Renderizador de la ventana

        // Texturas
        std::shared_ptr<Texture> buildings_texture_;
        std::shared_ptr<Texture> top_clouds_texture_;
        std::shared_ptr<Texture> bottom_clouds_texture_;
        std::shared_ptr<Texture> grass_texture_;
        std::shared_ptr<Texture> gradients_texture_;
        std::shared_ptr<Texture> sun_texture_;
        std::shared_ptr<Texture> moon_texture_;

        // Sprites
        std::unique_ptr<MovingSprite> top_clouds_sprite_a_;
        std::unique_ptr<MovingSprite> top_clouds_sprite_b_;
        std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_;
        std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_;
        std::unique_ptr<Sprite> buildings_sprite_;
        std::unique_ptr<Sprite> gradient_sprite_;
        std::unique_ptr<Sprite> grass_sprite_;
        std::unique_ptr<Sprite> sun_sprite_;
        std::unique_ptr<Sprite> moon_sprite_;

        // Buffers de renderizado
        SDL_Texture *canvas_;         // Textura para componer el fondo
        SDL_Texture *color_texture_;  // Textura para atenuar el fondo

        // Variables de estado y progresión
        State state_ = State::NORMAL;
        float progress_ = 0.0f;               // Progresión interna (0 a total_progress_to_complete_)
        bool manual_mode_ = false;            // Si está en modo manual, no actualiza automáticamente
        ProgressCallback progress_callback_;  // Callback para notificar cambios de progreso

        // Variables de renderizado
        SDL_FRect rect_;                               // Tamaño del objeto
        SDL_FRect src_rect_;                           // Parte del objeto para copiar en pantalla
        SDL_FRect dst_rect_;                           // Posición en pantalla donde se copia el objeto
        std::array<SDL_FRect, STAGES> gradient_rect_;  // Fondos degradados
        std::array<SDL_FRect, 4> top_clouds_rect_;     // Nubes superiores
        std::array<SDL_FRect, 4> bottom_clouds_rect_;  // Nubes inferiores
        Color attenuate_color_;                        // Color de atenuación

        std::vector<SDL_FPoint> sun_path_;   // Recorrido del sol
        std::vector<SDL_FPoint> moon_path_;  // Recorrido de la luna

        float clouds_speed_ = 0;  // Velocidad de las nubes
        float transition_ = 0;    // Porcentaje de transición

        size_t gradient_number_ = 0;               // Índice de fondo degradado
        size_t counter_ = 0;                       // Contador interno
        size_t alpha_color_texture_ = 0;           // Transparencia de atenuación
        size_t previous_alpha_color_texture_ = 0;  // Transparencia anterior
        size_t sun_index_ = 0;                     // Índice del recorrido del sol
        size_t moon_index_ = 0;                    // Índice del recorrido de la luna
        int base_ = 0;                             // Posición base del fondo

        Uint8 alpha_ = 0;  // Transparencia entre fases

        // Métodos internos
        void initializePaths();             // Inicializa las rutas del sol y la luna
        void initializeRects();             // Inicializa los rectángulos de gradientes y nubes
        void initializeSprites();           // Crea los sprites
        void initializeSpriteProperties();  // Configura las propiedades iniciales de los sprites
        void initializeTextures();          // Inicializa las texturas de renderizado
        void updateProgression();           // Actualiza la progresión y calcula transiciones
        void updateCloudsSpeed();           // Actualiza la velocidad de las nubes según el estado
        void renderGradient();              // Dibuja el gradiente de fondo
        void renderTopClouds();             // Dibuja las nubes superiores
        void renderBottomClouds();          // Dibuja las nubes inferiores
        void fillCanvas();                  // Compone todos los elementos en la textura
        void updateAlphaColorTexture();     // Actualiza el alpha de la textura de atenuación
        void updateClouds();                // Actualiza el movimiento de las nubes
        void createSunPath();               // Precalcula el recorrido del sol
        void createMoonPath();              // Precalcula el recorrido de la luna
};