D:/Drive/Professionnel/ETS/Enseignement/GPA675/2024_01_Hiver/lab/01/GPA675Lab1App/GOLEngine/GOL.h

#pragma once
#ifndef GOL_INTERFACE_H
#define GOL_INTERFACE_H
 
 
#include <string>
#include <vector>
#include <optional>
 
 
//
//  ___ __  __ ____   ___  ____ _____  _    _   _ _____ 
// |_ _|  \/  |  _ \ / _ \|  _ \_   _|/ \  | \ | |_   _|
//  | || |\/| | |_) | | | | |_) || | / _ \ |  \| | | |  
//  | || |  | |  __/| |_| |  _ < | |/ ___ \| |\  | | |  
// |___|_|  |_|_|    \___/|_| \_\|_/_/   \_\_| \_| |_|  
//                                                        
// 
// Attention, vous ne pouvez pas modifier ce fichier.
// 
 
 
 
class GOL
{
public:
    //    ____    __  __ _       _ _   _                   _             _                         
    //   |  _ \  /_/ / _(_)_ __ (_) |_(_) ___  _ __     __| | ___  ___  | |_ _   _ _ __   ___  ___ 
    //   | | | |/ _ \ |_| | '_ \| | __| |/ _ \| '_ \   / _` |/ _ \/ __| | __| | | | '_ \ / _ \/ __|
    //   | |_| |  __/  _| | | | | | |_| | (_) | | | | | (_| |  __/\__ \ | |_| |_| | |_) |  __/\__ \
    //   |____/ \___|_| |_|_| |_|_|\__|_|\___/|_| |_|  \__,_|\___||___/  \__|\__, | .__/ \___||___/
    //                                                                       |___/|_|              
    // 
    enum class State : uint8_t {
        dead = 0,  
        alive = 1, 
    };
    //
    using IterationType = uint32_t;
    // 
    enum class BorderManagement : uint8_t {
        immutableAsIs = 0,  
        foreverDead,        
        foreverAlive,       
        warping,            
        mirror,             
    };
    //
    using ColorChannelType = uint8_t;
    //
    struct Color {
        ColorChannelType red = 0;   
        ColorChannelType green = 0; 
        ColorChannelType blue = 0;  
    };
    //
    struct Statistics {
        std::optional<std::string> rule;                    
        std::optional<BorderManagement> borderManagement;   
        std::optional<size_t> width;                        
        std::optional<size_t> height;                       
        std::optional<size_t> totalCells;                   
        std::optional<IterationType> iteration;             
        std::optional<size_t> totalDeadAbs;                 
        std::optional<size_t> totalAliveAbs;                
        std::optional<float> totalDeadRel;                  
        std::optional<float> totalAliveRel;                 
        std::optional<int> tendencyAbs;                     
        std::optional<float> tendencyRel;                   
    };
    //
    struct Author {
        std::string lastName;       
        std::string firstName;      
        std::string studentEmail;    
    };
    //
    struct ImplementationInformation {
        std::string title;                          
        std::vector<Author> authors;                
        std::vector<std::string> answers;           
        std::vector<std::string> optionnalComments; 
    };
 
 
 
    //
    //     ____                _                   _                           __  ____            _                   _                  
    //    / ___|___  _ __  ___| |_ _ __ _   _  ___| |_ ___ _   _ _ __ ___     / / |  _ \  ___  ___| |_ _ __ _   _  ___| |_ ___ _   _ _ __ 
    //   | |   / _ \| '_ \/ __| __| '__| | | |/ __| __/ _ \ | | | '__/ __|   / /  | | | |/ _ \/ __| __| '__| | | |/ __| __/ _ \ | | | '__|
    //   | |__| (_) | | | \__ \ |_| |  | |_| | (__| ||  __/ |_| | |  \__ \  / /   | |_| |  __/\__ \ |_| |  | |_| | (__| ||  __/ |_| | |   
    //    \____\___/|_| |_|___/\__|_|   \__,_|\___|\__\___|\__,_|_|  |___/ /_/    |____/ \___||___/\__|_|   \__,_|\___|\__\___|\__,_|_|   
    //                                                                                                                                    
    // 
    // Les classes héritant de GOL doivent réaliser :
    //  - le constructeur par défaut : _class_()
    //  - le constructeur d'initialisation proposé : _class_(size_t width, size_t height, State defaultState = State::dead)
    //  - le destructeur : ~_class_()
    // 
    GOL() = default;
    // 
    GOL(size_t width, size_t height, State defaultState = State::dead) {}
    // 
    virtual ~GOL() = default;
    // 
    // Les 4 autres fonctions spéciales sont laissées à votre discrétion.
    // Toutefois, un simple -delete- est suffisant pour ce premier laboratoire.
    // _class_(_class_ const &) = delete;
    // _class_(_class_ &&) = delete;
    // _class_& operator=(_class_ const &) = delete;
    // _class_& operator=(_class_ &&) = delete;
 
 
    // 
    //       _                                             
    //      / \   ___ ___ ___  ___ ___  ___ _   _ _ __ ___ 
    //     / _ \ / __/ __/ _ \/ __/ __|/ _ \ | | | '__/ __|
    //    / ___ \ (_| (_|  __/\__ \__ \  __/ |_| | |  \__ \
    //   /_/   \_\___\___\___||___/___/\___|\__,_|_|  |___/
    //                                                                                                           
    //
    virtual size_t width() const = 0;
    //
    virtual size_t height() const = 0;
    //
    virtual size_t size() const = 0;
    //
    virtual State state(int x, int y) const = 0;
    //
    //
    virtual std::string rule() const = 0;
    //
    //
    virtual BorderManagement borderManagement() const = 0; 
    //
    //
    virtual Color color(State state) const = 0;
    //
    //
    virtual Statistics statistics() const = 0;
    //
    // 
    virtual ImplementationInformation information() const = 0;
    //
    //   
    //    __  __       _        _                      
    //   |  \/  |_   _| |_ __ _| |_ ___ _   _ _ __ ___ 
    //   | |\/| | | | | __/ _` | __/ _ \ | | | '__/ __|
    //   | |  | | |_| | || (_| | ||  __/ |_| | |  \__ \
    //   |_|  |_|\__,_|\__\__,_|\__\___|\__,_|_|  |___/
    // 
    // 
    virtual void resize(size_t width, size_t height, State defaultState = State::dead) = 0;
    //
    //
    virtual bool setRule(std::string const & rule) = 0;
    //
    //
    virtual void setBorderManagement(BorderManagement borderManagement) = 0;
    //
    // 
    virtual void setState(int x, int y, State state) = 0;
    //
    //
    virtual void fill(State state = State::dead) = 0;
    //
    //
    virtual void fillAlternately(State firstCell = State::dead) = 0;
    //
    //
    virtual void randomize(double percentAlive = 0.5) = 0;
    //
    //
    virtual bool setFromPattern(std::string const & pattern, int centerX, int centerY) = 0;
    //
    //
    virtual bool setFromPattern(std::string const & pattern) = 0;
    //
    //
    virtual void setSolidColor(State state, Color const & color) = 0;
 
 
    //
    //
    //    __  __           _ _  __ _           _                      
    //   |  \/  | ___   __| (_)/ _(_) ___ __ _| |_ ___ _   _ _ __ ___ 
    //   | |\/| |/ _ \ / _` | | |_| |/ __/ _` | __/ _ \ | | | '__/ __|
    //   | |  | | (_) | (_| | |  _| | (_| (_| | ||  __/ |_| | |  \__ \
    //   |_|  |_|\___/ \__,_|_|_| |_|\___\__,_|\__\___|\__,_|_|  |___/
    //                                                                
    virtual void processOneStep() = 0;
    //
    // 
    virtual void updateImage(uint32_t * buffer, size_t buffer_size) const = 0;
 
};
 
 
 
 
 
 
 
//
//    _                            _              _   
//   (_)_ __ ___  _ __   ___  _ __| |_ __ _ _ __ | |_ 
//   | | '_ ` _ \| '_ \ / _ \| '__| __/ _` | '_ \| __|
//   | | | | | | | |_) | (_) | |  | || (_| | | | | |_ 
//   |_|_| |_| |_| .__/ \___/|_|   \__\__,_|_| |_|\__|
//               |_|                                  
// 
// Attention, vous devez implémenter et utiliser une classe Grid.
// 
// L'ébauche sous forme de commentaire plus bas est un guide 
// semi-contraignant.
// 
// Toutefois :
//  - Vous DEVEZ implémenter l'interface présentée.
//  - Vous POUVEZ ajouter des éléments comme vous le voulez.
//
//  > Autrement dit, l'interface proposé est minimum. 
//  > NÉANMOINS, vous devez garder en tête l'intention générique de 
//    cette classe et ne pas la spécialiser pour le contexte du projet 
//    de GOL. Par exemple, si on faisait un copier/coller du code et 
//    qu'on modifiait le CellType pour autre chose (un Vect2D par exemple), 
//    alors, tout fonctionnerait et la classe serait encore pertinente.
//    D'ailleurs, vous remarquez que c'est le seul endroit où il existe un 
//    lien entre cette classe et le projet courant.
//
// De plus, vous devez gérer manuellement l'allocation dynamique de la mémoire.
//
//
//  class Grid                                                                      // Classe facilitant la gestion d'un tableau dynamique 2d.
//  {                                                                               // 
//  public:                                                                         // 
//      // Définition des types                                                     //
//      using CellType = GOL::State;                                                // Correspond au type fondamental de chaque cellule de la grille. 
//      using DataType = ...;                                                       // Correspond à la grille, au conteneur de cellules. À vous de déterminer la structure de données à utiliser.
//                                                                                  //
//      // Définition des cosntructeurs / destructeur                               //
//      Grid();                                                                     // 
//      Grid(size_t width, size_t height, CellType initValue = CellType{});         // 
//      Grid(Grid const&) = delete;                                                 // 
//      Grid(Grid&&) = delete;                                                      // 
//      Grid& operator=(Grid const&) = delete;                                      // 
//      Grid& operator=(Grid&&) = delete;                                           // 
//      ~Grid();                                                                    // 
//                                                                                  //
//      // Accesseurs et mutateurs de la grille                                     // 
//      size_t width() const;                                                       // Accesseur retournant la largeur de la grille.
//      size_t height() const;                                                      // Accesseur retournant la hauteur de la grille.
//      size_t size() const;                                                        // Accesseur retournant le nombre de cellule de la grille.
//                                                                                  // 
//      void resize(size_t width, size_t height, CellType initValue = CellType{});  // Mutateur modifiant la taille de la grille et initialise le contenu par la valeur spécifiée.
//                                                                                  //
//      // Accesseurs et mutateurs des cellules                                     //
//      CellType value(int column, int row) const;                                  // Accesseur retournant la valeur d'une cellule à une certaine coordonnée. Pour une raison de performance, cette fonction NE VALIDE PAS ses entrées. Autrement dit, c'est la responsabilité du programmeur utilisateur de faire ses validations, au risque de 'crasher' le programme.
//      void setValue(int column, int row, CellType value);                         // Mutateur modifiant la valeur d'une cellule à une certaine coordonnée. Pour une raison de performance, cette fonction NE VALIDE PAS ses entrées. Autrement dit, c'est la responsabilité du programmeur utilisateur de faire ses validations, au risque de 'crasher' le programme.
//                                                                                  // 
//      std::optional<CellType> at(int column, int row) const;                      // Accesseur retournant la valeur d'une cellule à une certaine coordonnée. Cette fonction VALIDE ses entrées et retourne un optional nul si la coordonnée est invalide. 
//      void setAt(int column, int row, CellType value);                            // Mutateur modifiant la valeur d'une cellule à une certaine coordonnée. Cette fonction VALIDE ses entrées et ne fait rien si la coordonnée est invalide. 
//                                                                                  // 
//      // Accesseurs du "buffer" de la grille.                                     //
//      DataType const & data() const;                                              // Accesseur en lecture seule sur le "buffer" de la grille.
//      DataType & data();                                                          // Accesseur en lecture/écriture sur le "buffer" de la grille.
//                                                                                  // 
//  private:                                                                        // 
//      // ...                                                                      // Il y a des attributs essentiels au fonctionnement de cette classe.
//      // ...                                                                      // À vous de les déterminer. 
//      // ...                                                                      // 
//  };                                                                              //  
//                                                                                  // 
//                                                                                  // 
//                                                                                  // 
 
 
 
#endif // GOL_INTERFACE_H