/*!
 * 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("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
{
    Intersection i;
    double n1;
    double n2;
};

void fill_test_various(TestData *a_test, const Intersection &an_in, double a_n1, double a_n2)
{
    a_test->i = an_in;
    a_test->n1 = a_n1;
    a_test->n2 = a_n2;
}

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

SCENARIO("Finding n1 and n2 at various intersections", "[features/intersections.feature]")
{

    TestData the_tests[6];

    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 |
                        fill_test_various(&the_tests[0], Intersection(2.0, &A), 1.0, 1.5);
                        fill_test_various(&the_tests[1], Intersection(2.75, &B), 1.5, 2.0);
                        fill_test_various(&the_tests[2], Intersection(3.25, &C), 2.0, 2.5);
                        fill_test_various(&the_tests[3], Intersection(4.75, &B), 2.5, 2.5);
                        fill_test_various(&the_tests[4], Intersection(5.25, &C), 2.5, 1.5);
                        fill_test_various(&the_tests[5], Intersection(6.0, &A), 1.5, 1.0);

                        Intersections xs = Intersections({the_tests[0].i, the_tests[1].i, the_tests[2].i, the_tests[3].i,
                                                          the_tests[4].i, the_tests[5].i});

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