/*!
 * 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 <cmath>

#include <catch2/catch_test_macros.hpp>

#include "raytracing.h"

#include "common_data.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("r <- 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);
        }
    }
}

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

struct TestData
{
    double n1;
    double n2;
};

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

SCENARIO("Finding n1 and n2 at various intersections", "[features/intersections.feature]")
{
    GIVEN("A <- glass_sphere() with:")
    // | transform                 | scaling(2, 2, 2) |
    // | material.refractive_index | 1.5              |
    {
        Sphere A = Sphere::Glass();
        A.set_transform(Matrix::scaling(2, 2, 2));
        A.material().set_refractive_index(1.5);
        GIVEN("B <- glass_sphere() with:")
        // | transform                 | translation(0, 0, -0.25) |
        // | material.refractive_index | 2.0                      |
        {
            Sphere B = Sphere::Glass();
            B.set_transform(Matrix::translation(0, 0, -0.25));
            B.material().set_refractive_index(2.0);
            GIVEN("C <- glass_sphere() with:")
            // | transform                 | translation(0, 0, 0.25) |
            // | material.refractive_index | 2.5                     |
            {
                Sphere C = Sphere::Glass();
                C.set_transform(Matrix::translation(0, 0, 0.25));
                C.material().set_refractive_index(2.5);
                AND_GIVEN("r <- ray(point(0, 0, -4), vector(0, 0, 1)")
                {
                    Ray r(Tuple::Point(0, 0, -4), Tuple::Vector(0, 0, 1));

                    AND_GIVEN("xs <- intersections(2:A, 2.75:B, 3.25:C, 4.75:B, 5.25:C, 6:A)")
                    {
                        // Examples:
                        // | index | n1 | n2 |
                        // |   0   |1.0 |1.5 |
                        // |   1   |1.5 |2.0 |
                        // |   2   |2.0 |2.5 |
                        // |   3   |2.5 |2.5 |
                        // |   4   |2.5 |1.5 |
                        // |   5   |1.5 |1.0 |
                        TestData the_ns[6] = {
                            {1.0, 1.5},
                            {1.5, 2.0},
                            {2.0, 2.5},
                            {2.5, 2.5},
                            {2.5, 1.5},
                            {1.5, 1.0}
                        };

                        Intersections xs = Intersections({Intersection(2.0, &A),
                                                          Intersection(2.75, &B),
                                                          Intersection(3.25, &C),
                                                          Intersection(4.75, &B),
                                                          Intersection(5.25, &C),
                                                          Intersection(6.0, &A)});

                        WHEN("comps <- prepare_computations(xs[index], r, xs)")
                        {
                            for (int i = 0; i < 2; i++)
                            {
                                IntersectionData comps = xs[i].prepare_computations(r, &xs);
                                THEN("comps.n1 = <n1>")
                                {
                                    REQUIRE(comps.n1() == the_ns[i].n1);
                                }
                                AND_THEN("comps.n2 = <n2>")
                                {
                                    REQUIRE(comps.n2() == the_ns[i].n2);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The under point is offset below the surface", "[features/intersections.feature]")
{
    GIVEN("r <- ray(point(0, 0, -5), vector(0, 0, 1)")
    {
        Ray r(Tuple::Point(0, 0, -5), Tuple::Vector(0, 0, 1));
        AND_GIVEN("shape <- glass_sphere() with:")
        // | transform                 | translation(0, 0, 1)  |
        {
            Sphere shape = Sphere::Glass();
            shape.set_transform(Matrix::translation(0, 0, 1));
            AND_GIVEN("i <- intersection(5, shape)")
            {
                Intersection i(5, &shape);
                AND_GIVEN("xs <- intersections(i)")
                {
                    Intersections xs = Intersections({i});
                    WHEN("comps <- prepare_computations(i, r, xs)")
                    {
                        IntersectionData comps = i.prepare_computations(r, &xs);
                        THEN("comps.under_point.z > EPSILON / 2")
                        {
                            REQUIRE(comps.under_point().z() > kEpsilon / 2);
                        }
                        AND_THEN("comps.point.z < comps.under_point.z")
                        {
                            REQUIRE(comps.point().z() < comps.under_point().z());
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The refracted color with a, opaque surface", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("shape <- first object of w")
        {
            Shape *shape = w.objects(0);
            AND_GIVEN("r <- ray(point(0, 0, -5), vector(0, 0, 1))")
            {
                Ray r(Tuple::Point(0, 0, -5), Tuple::Vector(0, 0, 1));
                AND_GIVEN("xs <- intersections(4:shape, 6:shape)")
                {
                    Intersections xs = Intersections({Intersection(4.0, shape),
                                                      Intersection(6.0, shape)});
                    WHEN("comps <- prepare_computations(xs[0], r, xs)")
                    {
                        IntersectionData comps = xs[0].prepare_computations(r, &xs);
                        AND_WHEN("c <- refracted_color(w, comps, 5)")
                        {
                            Color c = w.refracted_color(comps, 5);
                            THEN("c = color(0, 0, 0)")
                            {
                                REQUIRE(c == Color(0, 0, 0));
                            }
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The refracted color at the maximum recursive depth", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("shape <- first object of w")
        {
            Shape *shape = w.objects(0);
            AND_GIVEN("shape has:")
            {
                // | material.transparency     | 1.0       |
                // | material.refractive_index | 1.5       |
                shape->material().set_transparency(1.0);
                shape->material().set_refractive_index(1.5);
                AND_GIVEN("r <- ray(point(0, 0, -5), vector(0, 0, 1))")
                {
                    Ray r(Tuple::Point(0, 0, -5), Tuple::Vector(0, 0, 1));
                    AND_GIVEN("xs <- intersections(4:shape, 6:shape)")
                    {
                        Intersections xs = Intersections({Intersection(4.0, shape),
                                                          Intersection(6.0, shape)});
                        WHEN("comps <- prepare_computations(xs[0], r, xs)")
                        {
                            IntersectionData comps = xs[0].prepare_computations(r, &xs);
                            AND_WHEN("c <- refracted_color(w, comps, 0)")
                            {
                                Color c = w.refracted_color(comps, 0);
                                THEN("c = color(0, 0, 0)")
                                {
                                    REQUIRE(c == Color(0, 0, 0));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The refracted color under total internal reflection", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("shape <- first object of w")
        {
            Shape *shape = w.objects(0);
            AND_GIVEN("shape has:")
            {
                // | material.transparency     | 1.0       |
                // | material.refractive_index | 1.5       |
                shape->material().set_transparency(1.0);
                shape->material().set_refractive_index(1.5);
                AND_GIVEN("r <- ray(point(0, 0, sqrt(2) / 2), vector(0, 1, 0))")
                {
                    Ray r(Tuple::Point(0, 0, sqrt(2) / 2), Tuple::Vector(0, 1, 0));
                    AND_GIVEN("xs <- intersections(-(sqrt(2) / 2):shape, sqrt(2) / 2:shape)")
                    {
                        Intersections xs = Intersections({Intersection(-(sqrt(2) / 2), shape),
                                                          Intersection(sqrt(2) / 2, shape)});
                        // NOTE: this time you're inside the sphere, so you need to look at the
                        // second intersection, xs[1] and not xs[0]
                        WHEN("comps <- prepare_computations(xs[1], r, xs)")
                        {
                            IntersectionData comps = xs[1].prepare_computations(r, &xs);
                            AND_WHEN("c <- refracted_color(w, comps, 5)")
                            {
                                Color c = w.refracted_color(comps, 5);
                                THEN("c = color(0, 0, 0)")
                                {
                                    REQUIRE(c == Color(0, 0, 0));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The refracted color with a refracted ray", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("A <- first object of w")
        {
            Shape *A = w.objects(0);
            AND_GIVEN("A has:")
            {
                // | material.ambient  | 1.0            |
                // | material.pattern  | test_pattern() |
                A->material().set_ambient(1.0);
                TestPattern the_pattern;
                A->material().set_pattern(&the_pattern);
                AND_GIVEN("B <- second object of w")
                {
                    Shape *B = w.objects(1);
                    AND_GIVEN("shape has:")
                    {
                        // | material.transparency     | 1.0       |
                        // | material.refractive_index | 1.5       |
                        B->material().set_transparency(1.0);
                        B->material().set_refractive_index(1.5);
                        AND_GIVEN("r <- ray(point(0, 0, 0.1, vector(0, 1, 0))")
                        {
                            Ray r(Tuple::Point(0, 0, 0.1), Tuple::Vector(0, 1, 0));
                            AND_GIVEN("xs <- intersections(-0.9899:A, -0.4899:B, 0.4899:B, 0.9899:A)")
                            {
                                Intersections xs = Intersections({
                                    Intersection(-0.9899, A),
                                    Intersection(-0.4899, B),
                                    Intersection(0.4899, B),
                                    Intersection(0.9899, A),
                                });
                                WHEN("comps <- prepare_computations(xs[2], r, xs)")
                                {
                                    IntersectionData comps = xs[2].prepare_computations(r, &xs);
                                    AND_WHEN("c <- refracted_color(w, comps, 5)")
                                    {
                                        Color c = w.refracted_color(comps, 5);
                                        THEN("c = color(0, 0.99888, 0.04725)")
                                        {
                                            REQUIRE(c == Color(0, 0.99888, 0.04725));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("shade_hit() with a transparent material", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("floor <- plane() with:")
        {
            // | transform                 | translation(0, -1, 0) |
            // | material.transparency     | 0.5                   |
            // | material.refractive_index | 1.5                   |
            Plane floor;
            floor.set_transform(Matrix::translation(0, -1, 0));
            floor.material().set_transparency(0.5);
            floor.material().set_refractive_index(1.5);
            AND_GIVEN("floor is added to w")
            {
                w.add_object(&floor);
                AND_GIVEN("ball <- sphere() with:")
                {
                    // | material.color    | (1, 0, 0)                  |
                    // | material.ambient  | 0.5                        |
                    // | transform         | translation(0, -3.5, -0.5) |
                    Sphere ball;
                    ball.material().set_color(Color(1, 0, 0));
                    ball.material().set_ambient(0.5);
                    ball.set_transform(Matrix::translation(0, -3.5, -0.5));
                    AND_GIVEN("ball is added to w")
                    {
                        w.add_object(&ball);
                        AND_GIVEN("r <- 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("xs <- intersections(sqrt(2):floor)")
                            {
                                Intersections xs = Intersections({Intersection(sqrt(2), &floor)});
                                WHEN("comps <- prepare_computations(xs[0], r, xs)")
                                {
                                    IntersectionData comps = xs[0].prepare_computations(r, &xs);
                                    AND_WHEN("color <- shade_hit(w, comps, 5)")
                                    {
                                        Color color = w.shade_hit(comps, 5);
                                        THEN("color = color(0.93642, 0.68642, 0.68642)")
                                        {
                                            REQUIRE(color == Color(0.93642, 0.68642, 0.68642));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The Schlick approximation under total internal reflection", "[features/intersections.feature]")
{
    GIVEN("shape <- glass_sphere()")
    {
        Sphere shape = Sphere::Glass();
        AND_GIVEN("r <- ray(point(0, 0, sqrt(2) / 2)), vector(0, 1, 0)")
        {
            Ray r(Tuple::Point(0, 0, sqrt(2) / 2), Tuple::Vector(0, 1, 0));
            AND_GIVEN("xs <- intersections(-sqrt(2) / 2):shape, sqrt(2) / 2):shape)")
            {
                Intersections xs = Intersections({Intersection(-sqrt(2) / 2, &shape),
                                                  Intersection(sqrt(2) / 2, &shape)});
                WHEN("comps <- prepare_computations(xs[1], r, xs)")
                {
                    IntersectionData comps = xs[1].prepare_computations(r, &xs);
                    AND_WHEN("reflectance <- schlick(comps)")
                    {
                        double reflectance = comps.schlick();
                        THEN("reflectance = 1.0")
                        {
                            REQUIRE(reflectance == 1.0);
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The Schlick approximation with a perpendicular viewing angle", "[features/intersections.feature]")
{
    GIVEN("shape <- glass_sphere()")
    {
        Sphere shape = Sphere::Glass();
        AND_GIVEN("r <- ray(point(0, 0, 0), vector(0, 1, 0)")
        {
            Ray r(Tuple::Point(0, 0, 0), Tuple::Vector(0, 1, 0));
            AND_GIVEN("xs <- intersections(-1:shape, 1:shape)")
            {
                Intersections xs = Intersections({Intersection(-1, &shape),
                                                  Intersection(1, &shape)});
                WHEN("comps <- prepare_computations(xs[1], r, xs)")
                {
                    IntersectionData comps = xs[1].prepare_computations(r, &xs);
                    AND_WHEN("reflectance <- schlick(comps)")
                    {
                        double reflectance = comps.schlick();
                        THEN("reflectance = 0.04")
                        {
                            REQUIRE(double_equal(reflectance, 0.04));
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("The Schlick approximation with a small angle and n2 > n1", "[features/intersections.feature]")
{
    GIVEN("shape <- glass_sphere()")
    {
        Sphere shape = Sphere::Glass();
        AND_GIVEN("r <- ray(point(0, 0.99, -2), vector(0, 0, 1)")
        {
            Ray r(Tuple::Point(0, 0.99, -2), Tuple::Vector(0, 0, 1));
            AND_GIVEN("xs <- intersections(1.8589:shape)")
            {
                Intersections xs = Intersections({Intersection(1.8589, &shape)});
                WHEN("comps <- prepare_computations(xs[0], r, xs)")
                {
                    IntersectionData comps = xs[0].prepare_computations(r, &xs);
                    AND_WHEN("reflectance <- schlick(comps)")
                    {
                        double reflectance = comps.schlick();
                        THEN("reflectance = 0.48873")
                        {
                            REQUIRE(double_equal(reflectance, 0.48873));
                        }
                    }
                }
            }
        }
    }
}

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

SCENARIO("shade_hit() with a reflective, transparent material", "[features/world.feature]")
{
    GIVEN("w <- default_world()")
    {
        World w = World::default_world();
        AND_GIVEN("r <- 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("floor <- plane() with:")
            {
                // | transform                 | translation(0, -1, 0) |
                // | material.reflective       | 0.5                   |
                // | material.transparency     | 0.5                   |
                // | material.refractive_index | 1.5                   |
                Plane floor;
                floor.set_transform(Matrix::translation(0, -1, 0));
                floor.material().set_reflective(0.5);
                floor.material().set_transparency(0.5);
                floor.material().set_refractive_index(1.5);
                AND_GIVEN("floor is added to w")
                {
                    w.add_object(&floor);
                    AND_GIVEN("ball <- sphere() with:")
                    {
                        // | material.color    | (1, 0, 0)                  |
                        // | material.ambient  | 0.5                        |
                        // | transform         | translation(0, -3.5, -0.5) |
                        Sphere ball;
                        ball.material().set_color(Color(1, 0, 0));
                        ball.material().set_ambient(0.5);
                        ball.set_transform(Matrix::translation(0, -3.5, -0.5));
                        AND_GIVEN("ball is added to w")
                        {
                            w.add_object(&ball);
                            AND_GIVEN("xs <- intersections(sqrt(2):floor)")
                            {
                                Intersections xs = Intersections({Intersection(sqrt(2), &floor)});
                                WHEN("comps <- prepare_computations(xs[0], r, xs)")
                                {
                                    IntersectionData comps = xs[0].prepare_computations(r, &xs);
                                    AND_WHEN("color <- shade_hit(w, comps, 5)")
                                    {
                                        Color color = w.shade_hit(comps, 5);
                                        THEN("color = color(0.93391, 0.69643, 0.69243)")
                                        {
                                            REQUIRE(color == Color(0.93391, 0.69643, 0.69243));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}