/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   Array.hpp                                          :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2025/04/09 15:36:40 by adjoly            #+#    #+#             */
/*   Updated: 2025/04/14 18:52:43 by adjoly           ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#pragma once

#include <cstddef>
#include <exception>
#include <iterator>
#include <string>

static void _log(std::string emoji, std::string what, std::string who,
		  std::string str) {
#ifdef VERBOSE
	if (who.empty())
		std::cout << "「" << emoji << "」" << what << ": " << str << std::endl;
	else
		std::cout << "「" << emoji << "」" << what << "(" << who << "): " << str
				  << std::endl;
#else
	(void)emoji, (void)what, (void)who, (void)str;
#endif
}

template <typename T> class Array {
  public:
	Array(void) : _arr(new T[0]), _size(0) {
		_log("➕", "Array", "", "default constructor called");
	}
	Array(unsigned int n) : _arr(new T[n]), _size(n) {
		_log("➕", "Array", "", "size constructor called");
	}
	Array(const Array &cpy) {
		_log("➕", "Array", "", "copy constructor called");
		*this = cpy;
	}
	~Array(void) {
		_log("➖", "Array", "", "destructor called");
		delete[] _arr;
	}

	Array &operator=(const Array &cpy) {
		_log("➕", "Array", "", "assignement constructor called");
		if (this != &cpy) {
			_size = cpy._size;
			_arr = new T[_size];
			if (_arr) {
				for (std::size_t i = 0; i < _size; i++) {
					_arr[i] = cpy._arr[i];
				}
			}
		}
		return (*this);
	}

	T &operator[](const size_t &where) {
		if (where >= _size)
			throw outOfBoundException();

		return _arr[where];
	}

	T		   *getArray(void) const { return _arr; }
	std::size_t getSize(void) const { return _size; }

	class outOfBoundException : public std::exception {
		virtual const char *what() const throw() { return ("out of bound"); }
	};

  private:
	T		   *_arr;
	std::size_t _size;

	T *_clone(void) {}
};

template <typename T>
std::ostream &operator<<(std::ostream &os, const Array<T> &arr) {
	for (std::size_t i = 0; i < arr.getSize(); i++) {
		os << arr.getArray()[i];
	}
	return os;
}