#include "rendering/celestial.hpp"
#include "rendering/shader.hpp"
#include "rendering/camera.hpp"
#include "core/logger.hpp"
#include <GL/glew.h>
#include <glm/gtc/matrix_transform.hpp>
#include <cmath>

namespace wowee {
namespace rendering {

Celestial::Celestial() = default;

Celestial::~Celestial() {
    shutdown();
}

bool Celestial::initialize() {
    LOG_INFO("Initializing celestial renderer");

    // Create celestial shader
    celestialShader = std::make_unique<Shader>();

    // Vertex shader - billboard facing camera
    const char* vertexShaderSource = R"(
        #version 330 core
        layout (location = 0) in vec3 aPos;
        layout (location = 1) in vec2 aTexCoord;

        uniform mat4 model;
        uniform mat4 view;
        uniform mat4 projection;

        out vec2 TexCoord;

        void main() {
            TexCoord = aTexCoord;

            // Billboard: remove rotation from view matrix, keep only translation
            mat4 viewNoRotation = view;
            viewNoRotation[0][0] = 1.0; viewNoRotation[0][1] = 0.0; viewNoRotation[0][2] = 0.0;
            viewNoRotation[1][0] = 0.0; viewNoRotation[1][1] = 1.0; viewNoRotation[1][2] = 0.0;
            viewNoRotation[2][0] = 0.0; viewNoRotation[2][1] = 0.0; viewNoRotation[2][2] = 1.0;

            gl_Position = projection * viewNoRotation * model * vec4(aPos, 1.0);
        }
    )";

    // Fragment shader - disc with glow and moon phase support
    const char* fragmentShaderSource = R"(
        #version 330 core
        in vec2 TexCoord;

        uniform vec3 celestialColor;
        uniform float intensity;
        uniform float moonPhase;  // 0.0 = new moon, 0.5 = full moon, 1.0 = new moon

        out vec4 FragColor;

        void main() {
            // Create circular disc
            vec2 center = vec2(0.5, 0.5);
            float dist = distance(TexCoord, center);

            // Core disc
            float disc = smoothstep(0.5, 0.4, dist);

            // Glow around disc
            float glow = smoothstep(0.7, 0.0, dist) * 0.3;

            float alpha = (disc + glow) * intensity;

            // Apply moon phase shadow (only for moon, indicated by low intensity)
            if (intensity < 0.5) {  // Moon has lower intensity than sun
                // Calculate phase position (-1 to 1, where 0 is center)
                float phasePos = (moonPhase - 0.5) * 2.0;

                // Distance from phase terminator line
                float x = (TexCoord.x - 0.5) * 2.0;  // -1 to 1

                // Create shadow using smoothstep
                float shadow = 1.0;

                if (moonPhase < 0.5) {
                    // Waning (right to left shadow)
                    shadow = smoothstep(phasePos - 0.1, phasePos + 0.1, x);
                } else {
                    // Waxing (left to right shadow)
                    shadow = smoothstep(phasePos - 0.1, phasePos + 0.1, -x);
                }

                // Apply elliptical terminator for 3D effect
                float y = (TexCoord.y - 0.5) * 2.0;
                float ellipse = sqrt(1.0 - y * y);
                float terminatorX = phasePos / ellipse;

                if (moonPhase < 0.5) {
                    shadow = smoothstep(terminatorX - 0.15, terminatorX + 0.15, x);
                } else {
                    shadow = smoothstep(terminatorX - 0.15, terminatorX + 0.15, -x);
                }

                // Darken shadowed area (not completely black, slight glow remains)
                alpha *= mix(0.05, 1.0, shadow);
            }

            FragColor = vec4(celestialColor, alpha);
        }
    )";

    if (!celestialShader->loadFromSource(vertexShaderSource, fragmentShaderSource)) {
        LOG_ERROR("Failed to create celestial shader");
        return false;
    }

    // Create billboard quad
    createCelestialQuad();

    LOG_INFO("Celestial renderer initialized");
    return true;
}

void Celestial::shutdown() {
    destroyCelestialQuad();
    celestialShader.reset();
}

void Celestial::render(const Camera& camera, float timeOfDay) {
    if (!renderingEnabled || vao == 0 || !celestialShader) {
        return;
    }

    // Enable blending for celestial glow
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // Disable depth writing (but keep depth testing)
    glDepthMask(GL_FALSE);

    // Render sun and moon
    renderSun(camera, timeOfDay);
    renderMoon(camera, timeOfDay);

    // Restore state
    glDepthMask(GL_TRUE);
    glDisable(GL_BLEND);
}

void Celestial::renderSun(const Camera& camera, float timeOfDay) {
    // Sun visible from 5:00 to 19:00
    if (timeOfDay < 5.0f || timeOfDay >= 19.0f) {
        return;
    }

    celestialShader->use();

    // Get sun position
    glm::vec3 sunPos = getSunPosition(timeOfDay);

    // Create model matrix
    glm::mat4 model = glm::mat4(1.0f);
    model = glm::translate(model, sunPos);
    model = glm::scale(model, glm::vec3(50.0f, 50.0f, 1.0f));  // 50 unit diameter

    // Set uniforms
    glm::mat4 view = camera.getViewMatrix();
    glm::mat4 projection = camera.getProjectionMatrix();

    celestialShader->setUniform("model", model);
    celestialShader->setUniform("view", view);
    celestialShader->setUniform("projection", projection);

    // Sun color and intensity
    glm::vec3 color = getSunColor(timeOfDay);
    float intensity = getSunIntensity(timeOfDay);

    celestialShader->setUniform("celestialColor", color);
    celestialShader->setUniform("intensity", intensity);
    celestialShader->setUniform("moonPhase", 0.5f);  // Sun doesn't use this, but shader expects it

    // Render quad
    glBindVertexArray(vao);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
    glBindVertexArray(0);
}

void Celestial::renderMoon(const Camera& camera, float timeOfDay) {
    // Moon visible from 19:00 to 5:00 (night)
    if (timeOfDay >= 5.0f && timeOfDay < 19.0f) {
        return;
    }

    celestialShader->use();

    // Get moon position
    glm::vec3 moonPos = getMoonPosition(timeOfDay);

    // Create model matrix
    glm::mat4 model = glm::mat4(1.0f);
    model = glm::translate(model, moonPos);
    model = glm::scale(model, glm::vec3(40.0f, 40.0f, 1.0f));  // 40 unit diameter (smaller than sun)

    // Set uniforms
    glm::mat4 view = camera.getViewMatrix();
    glm::mat4 projection = camera.getProjectionMatrix();

    celestialShader->setUniform("model", model);
    celestialShader->setUniform("view", view);
    celestialShader->setUniform("projection", projection);

    // Moon color (pale blue-white) and intensity
    glm::vec3 color = glm::vec3(0.8f, 0.85f, 1.0f);

    // Fade in/out at transitions
    float intensity = 1.0f;
    if (timeOfDay >= 19.0f && timeOfDay < 21.0f) {
        // Fade in (19:00-21:00)
        intensity = (timeOfDay - 19.0f) / 2.0f;
    }
    else if (timeOfDay >= 3.0f && timeOfDay < 5.0f) {
        // Fade out (3:00-5:00)
        intensity = 1.0f - (timeOfDay - 3.0f) / 2.0f;
    }

    celestialShader->setUniform("celestialColor", color);
    celestialShader->setUniform("intensity", intensity);
    celestialShader->setUniform("moonPhase", moonPhase);

    // Render quad
    glBindVertexArray(vao);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
    glBindVertexArray(0);
}

glm::vec3 Celestial::getSunPosition(float timeOfDay) const {
    // Sun rises at 6:00, peaks at 12:00, sets at 18:00
    float angle = calculateCelestialAngle(timeOfDay, 6.0f, 18.0f);

    const float radius = 800.0f;  // Distance from origin
    const float height = 600.0f;  // Maximum height

    // Arc across sky
    float x = radius * std::sin(angle);
    float z = height * std::cos(angle);
    float y = 0.0f;  // Y is horizontal in WoW coordinates

    return glm::vec3(x, y, z);
}

glm::vec3 Celestial::getMoonPosition(float timeOfDay) const {
    // Moon rises at 18:00, peaks at 0:00 (24:00), sets at 6:00
    // Adjust time for moon (opposite to sun)
    float moonTime = timeOfDay + 12.0f;
    if (moonTime >= 24.0f) moonTime -= 24.0f;

    float angle = calculateCelestialAngle(moonTime, 6.0f, 18.0f);

    const float radius = 800.0f;
    const float height = 600.0f;

    float x = radius * std::sin(angle);
    float z = height * std::cos(angle);
    float y = 0.0f;

    return glm::vec3(x, y, z);
}

glm::vec3 Celestial::getSunColor(float timeOfDay) const {
    // Sunrise/sunset: orange/red
    // Midday: bright yellow-white

    if (timeOfDay >= 5.0f && timeOfDay < 7.0f) {
        // Sunrise: orange
        return glm::vec3(1.0f, 0.6f, 0.2f);
    }
    else if (timeOfDay >= 7.0f && timeOfDay < 9.0f) {
        // Morning: blend to yellow
        float t = (timeOfDay - 7.0f) / 2.0f;
        glm::vec3 orange = glm::vec3(1.0f, 0.6f, 0.2f);
        glm::vec3 yellow = glm::vec3(1.0f, 1.0f, 0.9f);
        return glm::mix(orange, yellow, t);
    }
    else if (timeOfDay >= 9.0f && timeOfDay < 16.0f) {
        // Day: bright yellow-white
        return glm::vec3(1.0f, 1.0f, 0.9f);
    }
    else if (timeOfDay >= 16.0f && timeOfDay < 18.0f) {
        // Evening: blend to orange
        float t = (timeOfDay - 16.0f) / 2.0f;
        glm::vec3 yellow = glm::vec3(1.0f, 1.0f, 0.9f);
        glm::vec3 orange = glm::vec3(1.0f, 0.5f, 0.1f);
        return glm::mix(yellow, orange, t);
    }
    else {
        // Sunset: deep orange/red
        return glm::vec3(1.0f, 0.4f, 0.1f);
    }
}

float Celestial::getSunIntensity(float timeOfDay) const {
    // Fade in at sunrise (5:00-6:00)
    if (timeOfDay >= 5.0f && timeOfDay < 6.0f) {
        return (timeOfDay - 5.0f);  // 0 to 1
    }
    // Full intensity during day (6:00-18:00)
    else if (timeOfDay >= 6.0f && timeOfDay < 18.0f) {
        return 1.0f;
    }
    // Fade out at sunset (18:00-19:00)
    else if (timeOfDay >= 18.0f && timeOfDay < 19.0f) {
        return 1.0f - (timeOfDay - 18.0f);  // 1 to 0
    }
    else {
        return 0.0f;
    }
}

float Celestial::calculateCelestialAngle(float timeOfDay, float riseTime, float setTime) const {
    // Map time to angle (0 to PI)
    // riseTime: 0 radians (horizon east)
    // (riseTime + setTime) / 2: PI/2 radians (zenith)
    // setTime: PI radians (horizon west)

    float duration = setTime - riseTime;
    float elapsed = timeOfDay - riseTime;

    // Normalize to 0-1
    float t = elapsed / duration;

    // Map to 0 to PI (arc from east to west)
    return t * M_PI;
}

void Celestial::createCelestialQuad() {
    // Simple quad centered at origin
    float vertices[] = {
        // Position         // TexCoord
        -0.5f,  0.5f, 0.0f,  0.0f, 1.0f,  // Top-left
         0.5f,  0.5f, 0.0f,  1.0f, 1.0f,  // Top-right
         0.5f, -0.5f, 0.0f,  1.0f, 0.0f,  // Bottom-right
        -0.5f, -0.5f, 0.0f,  0.0f, 0.0f   // Bottom-left
    };

    uint32_t indices[] = {
        0, 1, 2,  // First triangle
        0, 2, 3   // Second triangle
    };

    // Create OpenGL buffers
    glGenVertexArrays(1, &vao);
    glGenBuffers(1, &vbo);
    glGenBuffers(1, &ebo);

    glBindVertexArray(vao);

    // Upload vertex data
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // Upload index data
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    // Set vertex attributes
    // Position
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // Texture coordinates
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);

    glBindVertexArray(0);
}

void Celestial::destroyCelestialQuad() {
    if (vao != 0) {
        glDeleteVertexArrays(1, &vao);
        vao = 0;
    }
    if (vbo != 0) {
        glDeleteBuffers(1, &vbo);
        vbo = 0;
    }
    if (ebo != 0) {
        glDeleteBuffers(1, &ebo);
        ebo = 0;
    }
}

void Celestial::update(float deltaTime) {
    if (!moonPhaseCycling) {
        return;
    }

    // Update moon phase timer
    moonPhaseTimer += deltaTime;

    // Moon completes full cycle in MOON_CYCLE_DURATION seconds
    moonPhase = std::fmod(moonPhaseTimer / MOON_CYCLE_DURATION, 1.0f);
}

void Celestial::setMoonPhase(float phase) {
    // Clamp phase to 0.0-1.0
    moonPhase = glm::clamp(phase, 0.0f, 1.0f);

    // Update timer to match phase
    moonPhaseTimer = moonPhase * MOON_CYCLE_DURATION;
}

} // namespace rendering
} // namespace wowee