/*!
 * 11_reflection_refraction.cpp
 *
 * Copyright (c) 2015-2024, NADAL Jean-Baptiste. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301 USA
 *
 * @Author:  NADAL Jean-Baptiste
 * @Date: 05/03/2024
 *
 */

/*---------------------------------------------------------------------------*/

#include <catch.hpp>

#include "raytracing.h"

using namespace Raytracer;

/* ------------------------------------------------------------------------- */

SCENARIO("Reflectivity for the default material", "[features/materials.feature]")
{
    GIVEN("m <- material()")
    {
        Material m;
        THEN("m.reflective = 0.0")
        {
            REQUIRE(m.reflective() == 0);
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("Precomputing the reflection vector", "[features/intersections.feature]")
{
    GIVEN("shape <- plane()")
    {
        Plane shape;
        AND_GIVEN("r <- ray(point(0, 1, -1), vector(0, -sqrt(2)/2, sqrt(2)/2))")
        {
            Ray r(Tuple::Point(0, 1, -1), Tuple::Vector(0, -sqrt(2) / 2, sqrt(2) / 2));
            AND_GIVEN("i <- intersection(sqrt(2), shape)")
            {
                Intersection i(sqrt(2), &shape);
                WHEN("comps <- prepare_computation(i, r)")
                {
                    IntersectionData comps = i.prepare_computations(r);
                    THEN("comps.reflectv = vector(0, sqrt(2) / 2, sqrt(2) / 2)")
                    {
                        REQUIRE(comps.reflectv() == Tuple::Vector(0, sqrt(2) / 2, sqrt(2) / 2));
                    }
                }
            }
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("The reflected color for a non reflective material", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("ray(point(0, 0, 0), vector(0, 0, 1)")
        {
            Ray r(Tuple::Point(0, 0, 0), Tuple::Vector(0, 0, 1));
            AND_GIVEN("shape <-the second object in w")
            {
                Shape *shape = w.objects(1);
                AND_GIVEN("shape.material.ambient <- 1")
                {
                    shape->material().set_ambient(1);
                    AND_GIVEN("i <- intersection(1, shape)")
                    {
                        Intersection i(1, shape);
                        WHEN("comps <- prepare_computation(i, r)")
                        {
                            IntersectionData comps = i.prepare_computations(r);
                            AND_WHEN("color <- reflected_color(w, comps)")
                            {
                                Color color = w.reflected_color(comps);
                                THEN("color = color(0, 0, 0)")
                                {
                                    REQUIRE(color == Color(0, 0, 0));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("The reflected color for a reflective material", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("shape <- plane() with:")
        // | material.reflective | 0.5                   |
        // | transform           | translation(0, -1, 0) |
        {
            Plane shape;
            shape.material().set_reflective(0.5);
            shape.set_transform(Matrix::translation(0, -1, 0));
            AND_GIVEN("shape is added to w")
            {
                w.add_object(&shape);
                AND_GIVEN("ray(point(0, 0, -3), vector(0, -sqrt(2) / 2, sqrt(2) / 2)")
                {
                    Ray r(Tuple::Point(0, 0, -3), Tuple::Vector(0, -sqrt(2) / 2, sqrt(2) / 2));
                    AND_GIVEN("i <- intersection(sqrt(2), shape)")
                    {
                        Intersection i(sqrt(2), &shape);
                        WHEN("comps <- prepare_computation(i, r)")
                        {
                            IntersectionData comps = i.prepare_computations(r);
                            AND_WHEN("color <- reflected_color(w, comps)")
                            {
                                Color color = w.reflected_color(comps);
                                THEN("color = color(0.19032, 0.2379, 0.14274)")
                                {
                                    REQUIRE(color == Color(0.19032, 0.2379, 0.14274));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("shade_it() with a reflective material", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("shape <- plane() with:")
        // | material.reflective | 0.5                   |
        // | transform           | translation(0, -1, 0) |
        {
            Plane shape;
            shape.material().set_reflective(0.5);
            shape.set_transform(Matrix::translation(0, -1, 0));
            AND_GIVEN("shape is added to w")
            {
                w.add_object(&shape);
                AND_GIVEN("ray(point(0, 0, -3), vector(0, -sqrt(2) / 2, sqrt(2) / 2)")
                {
                    Ray r(Tuple::Point(0, 0, -3), Tuple::Vector(0, -sqrt(2) / 2, sqrt(2) / 2));
                    AND_GIVEN("i <- intersection(sqrt(2), shape)")
                    {
                        Intersection i(sqrt(2), &shape);
                        WHEN("comps <- prepare_computation(i, r)")
                        {
                            IntersectionData comps = i.prepare_computations(r);
                            AND_WHEN("color <- shade_hit(w, comps)")
                            {
                                Color color = w.shade_hit(comps);
                                THEN("color = color(0.87677, 0.92436, 0.82918)")
                                {
                                    REQUIRE(color == Color(0.87677, 0.92436, 0.82918));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("color_at() with mutually reflective surfaces", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("w.light <- point_light(point(0, 0, 0), color(1, 1, 1))")
        {
            w.set_light(PointLight(Tuple::Point(0, 0, 0), Color(1, 1, 1)));
            AND_GIVEN("lower <- plane() with:")
            // | material.reflective | 1                   |
            // | transform           | translation(0, -1, 0) |
            {
                Plane lower;
                lower.material().set_reflective(1);
                lower.set_transform(Matrix::translation(0, -1, 0));
                AND_GIVEN("lower is added to w")
                {
                    w.add_object(&lower);
                    AND_GIVEN("upper <- plane() with:")
                    // | material.reflective | 1                   |
                    // | transform           | translation(0, 1, 0) |
                    {
                        Plane upper;
                        upper.material().set_reflective(1);
                        upper.set_transform(Matrix::translation(0, 1, 0));
                        AND_GIVEN("upper is added to w")
                        {
                            w.add_object(&upper);
                            AND_GIVEN("ray(point(0, 0, 0), vector(0, 1, 0)")
                            {
                                Ray r(Tuple::Point(0, 0, 0), Tuple::Vector(0, 1, 0));
                                THEN("color_at(w, r) terminate successfully")
                                {
                                    w.color_at(r);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("The reflected color at the maximum recursive depth", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("shape <- plane() with:")
        // | material.reflective | 0.5                   |
        // | transform           | translation(0, -1, 0) |
        {
            Plane shape;
            shape.material().set_reflective(0.5);
            shape.set_transform(Matrix::translation(0, -1, 0));
            AND_GIVEN("shape is added to w")
            {
                w.add_object(&shape);
                AND_GIVEN("ray(point(0, 0, -3), vector(0, -sqrt(2) / 2, sqrt(2) / 2)")
                {
                    Ray r(Tuple::Point(0, 0, -3), Tuple::Vector(0, -sqrt(2) / 2, sqrt(2) / 2));
                    AND_GIVEN("i <- intersection(sqrt(2), shape)")
                    {
                        Intersection i(sqrt(2), &shape);
                        WHEN("comps <- prepare_computation(i, r)")
                        {
                            IntersectionData comps = i.prepare_computations(r);
                            AND_WHEN("color <- reflected_color(w, comps, 0)")
                            {
                                Color color = w.reflected_color(comps, 0);
                                THEN("color = color(0.19032, 0.2379, 0.14274)")
                                {
                                    REQUIRE(color == Color(0, 0, 0));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("Transparency and Refractive Index for the default material", "[features/materials.feature]")
{
    GIVEN("m <- material()")
    {
        Material m;
        THEN("m.transparency = 0.0")
        {
            REQUIRE(m.transparency() == 0.0);
        }
        AND_THEN("m.refractive_index = 1.0")
        {
            REQUIRE(m.refractive_index() == 1.0);
        }
    }
}

/* ------------------------------------------------------------------------- */

SCENARIO("A helper for producing a sphere with a glassy material", "[features/spheres.feature]")
{
    GIVEN("s <- glass_sphere()")
    {
        Sphere s = Sphere::Glass();
        THEN("s.transform = identity_matrix")
        {
            REQUIRE(s.transform() == Matrix::identity());
        }
        AND_THEN("s.material.transparency = 1.0")
        {
            REQUIRE(s.material().transparency() == 1.0);
        }
        AND_THEN("s.material.refractive_index = 1.5")
        {
            REQUIRE(s.material().refractive_index() == 1.5);
        }
    }
}