// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025 - 2026  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================

#ifndef FENNEC_TEST_CONTAINERS_OPTIONAL_H
#define FENNEC_TEST_CONTAINERS_OPTIONAL_H

#include "../../test.h"

#include <fennec/containers/optional.h>

namespace fennec::test
{

	enum opt_test_ : uint8_t {
		opt_test_none					= 0x1 << 0,
		opt_test_default_constructor	= 0x1 << 1,
		opt_test_destructor				= 0x1 << 2,
		opt_test_copy_constructor		= 0x1 << 3,
		opt_test_move_constructor		= 0x1 << 4,
		opt_test_copy_assignment		= 0x1 << 5,
		opt_test_move_assignment		= 0x1 << 6,
	};

	struct optional_helper {

		inline static uint8_t test = opt_test_none;

		optional_helper() : i(0) {
			fennec_test_run(bool(test & opt_test_default_constructor), true);
		}

		~optional_helper() {
			fennec_test_run(bool(test & opt_test_destructor), true);
		}

		optional_helper(const optional_helper&) : i(0) {
			fennec_test_run(bool(test & opt_test_copy_constructor), true);
		}

		optional_helper(optional_helper&&) noexcept : i(0) {
			fennec_test_run(bool(test & opt_test_move_constructor), true);
		}

		optional_helper& operator=(const optional_helper&) {
			fennec_test_run(bool(test & opt_test_copy_assignment), true);
			return *this;
		}

		optional_helper& operator=(optional_helper&&) noexcept {
			fennec_test_run(bool(test & opt_test_move_assignment), true);
			return *this;
		}

		int i;
	};

	inline void fennec_test_containers_optional() {
		static_assert(
			is_default_constructible_v<optional_helper>
			and is_copy_constructible_v<optional_helper>
			and is_move_constructible_v<optional_helper>
			and is_copy_assignable_v<optional_helper>
			and is_move_assignable_v<optional_helper>
		);

		optional<optional_helper> opt = optional<optional_helper>();

		optional_helper::test = opt_test_default_constructor;
		opt.emplace();

		fennec_test_spacer(1);

		optional_helper::test = opt_test_destructor;
		opt.reset();

		fennec_test_spacer(1);

		optional_helper::test = opt_test_default_constructor | opt_test_copy_constructor | opt_test_destructor;
		opt = copy(optional_helper());

		fennec_test_spacer(1);

		optional_helper::test = opt_test_destructor;
		opt.reset();

		fennec_test_spacer(1);

		optional_helper::test = opt_test_default_constructor | opt_test_move_constructor | opt_test_destructor;
		opt = optional_helper();

		fennec_test_spacer(1);

		optional_helper::test = opt_test_destructor;
		opt.reset();

		fennec_test_spacer(1);

		optional_helper::test = opt_test_default_constructor;
		opt.emplace();

		fennec_test_spacer(1);

		optional_helper::test = opt_test_default_constructor | opt_test_copy_assignment | opt_test_destructor;
		opt = copy(optional_helper());

		fennec_test_spacer(1);

		optional_helper::test = opt_test_default_constructor | opt_test_move_assignment | opt_test_destructor;
		opt = optional_helper();

		fennec_test_spacer(1);

		optional_helper::test = opt_test_destructor;
		opt.reset();

		std::cout << opt << std::endl;
		std::cout << "passed" << std::endl;
	}

}

#endif // FENNEC_TEST_CONTAINERS_OPTIONAL_H
