Create a new version of paste:

#include <stdio.h>
#include <vector>
#include <iostream>
#include <memory>
#include <string>
#include <algorithm>
#include <ctime>
#include <random>


enum Colors {
    white = 0,
    yellow = 1,
    red = 2,
    green = 3,
    orange = 4,
    blue = 5
};

enum Directions {
    x = 0,
    y = 1,
    z = 2
};

enum Movements {
    R = 0,
    Rp = 1,
    L = 2,
    Lp = 3,
    U = 4,
    Up = 5,
    D = 6,
    Dp = 7,
    F = 8,
    Fp = 9,
    B = 10,
    Bp = 11
};


class Piece {
    
    protected:
    
    
    public:
    
    virtual std::shared_ptr<Piece> copy() {}
    virtual int getColor() {}
    virtual int getColor(int i) {}
    virtual std::ostream& getStream(std::ostream& stream) {return stream;}
    virtual void rotate() {}
    virtual void rotate(int unchangedDirection) {}
    virtual std::vector<int> getAllColors() {}
    
};

class Corner : public Piece {
    
    private:
    int m_xColor;
    int m_yColor;
    int m_zColor;
    
    public:
    
    Corner(int xColor, int yColor, int zColor);
    virtual std::shared_ptr<Piece> copy();
    virtual int getColor(int i);
    virtual std::ostream& getStream(std::ostream& stream) override;
    virtual void rotate(int unchangedDirection);
    virtual std::vector<int> getAllColors();
};

class Edge : public Piece {
    
    private:
    int m_color1;
    int m_color2;

    public:
    
    // color1 is the color oriented to the white side or the yellow side.
    // If there is not, this is the color oriented to the red or the orange side.
    // color2 is the other color
    Edge(int color1, int color2);
    virtual std::shared_ptr<Piece> copy();
    virtual int getColor(int i);
    virtual std::ostream& getStream(std::ostream& stream) override;
    virtual void rotate();
    virtual std::vector<int> getAllColors();
};

class Center : public Piece {
    
    private:
    int m_color;
    
    public:
    
    Center(int color);
    virtual std::shared_ptr<Piece> copy();
    virtual int getColor();
    virtual std::ostream& getStream(std::ostream& stream) override;
    virtual std::vector<int> getAllColors();
};

typedef std::vector<std::vector<std::shared_ptr<Piece>>> vectorOfPieces;

class Sequence {
    
};

class RubiksCube {
    
    private:
    vectorOfPieces m_possibility;
    void move(int corners[4][2], int edges[4][2], bool prime, bool doEdgesRotate, int cornerUnchangedDirection);
    void moveInterior(int edges[4][2], int centers[4][2], bool prime);
    bool isPieceWellPlaced(vectorOfPieces objective, std::shared_ptr<Piece> piece);
    std::vector<int> findPlaceOfPiece(std::shared_ptr<Piece> piece, vectorOfPieces possibility);
    // RESOLUTION
    // FIRST CROSS (WHITE FACE)
    void solveFirstCross(vectorOfPieces objective);
    void putEdgeDown(std::shared_ptr<Piece> edge);
    void placeEdge(vectorOfPieces objective, std::shared_ptr<Piece> edge);
    // 1st FACE (WHITE) = CORNERS
    void finishFirstFace(vectorOfPieces objective);
    void putCornerDown(std::shared_ptr<Piece> corner);
    void placeCorner(vectorOfPieces objective, std::shared_ptr<Piece> corner);
    void silentMovex();
    void silentMovexp();
    void silentMovey();
    void silentMoveyp();
    void silentMovez();
    void silentMovezp();
    

    public:
    static RubiksCube askForCube();
    static RubiksCube makeRandomCube();
    static RubiksCube makeRandomCube(vectorOfPieces possibility);
    static RubiksCube makeRandomCube(vectorOfPieces possibility, int seed);
    RubiksCube(vectorOfPieces possibility);
    void moveR();
    void moveRp();
    void moveL();
    void moveLp();
    void moveU();
    void moveUp();
    void moveD();
    void moveDp();
    void moveF();
    void moveFp();
    void moveB();
    void moveBp();
    void moveM();
    void movem();
    void moveE();
    void movee();
    void moveS();
    void moves();
    void movex();
    void movexp();
    void movey();
    void moveyp();
    void movez();
    void movezp();
    int getFaceColor();
    std::shared_ptr<Piece> getPiece(int ring, int i);
    Sequence goTo(vectorOfPieces objective);
    void getStats();
    void test();
};


// CONSTANTS

vectorOfPieces RUBIKS_CUBE_FINISHED = {
    {
        std::shared_ptr<Piece>(new Center(Colors::white)),
        std::shared_ptr<Piece>(new Corner(Colors::green, Colors::white, Colors::red)),
        std::shared_ptr<Piece>(new Edge(Colors::white, Colors::green)),
        std::shared_ptr<Piece>(new Corner(Colors::green, Colors::white, Colors::orange)),
        std::shared_ptr<Piece>(new Edge(Colors::white, Colors::orange)),
        std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::white, Colors::orange)),
        std::shared_ptr<Piece>(new Edge(Colors::white, Colors::blue)),
        std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::white, Colors::red)),
        std::shared_ptr<Piece>(new Edge(Colors::white, Colors::red))
    },
    {
        std::shared_ptr<Piece>(new Edge(Colors::red, Colors::green)),
        std::shared_ptr<Piece>(new Center(Colors::green)),
        std::shared_ptr<Piece>(new Edge(Colors::orange, Colors::green)),
        std::shared_ptr<Piece>(new Center(Colors::orange)),
        std::shared_ptr<Piece>(new Edge(Colors::orange, Colors::blue)),
        std::shared_ptr<Piece>(new Center(Colors::blue)),
        std::shared_ptr<Piece>(new Edge(Colors::red, Colors::blue)),
        std::shared_ptr<Piece>(new Center(Colors::red))
    },
    {
        std::shared_ptr<Piece>(new Center(Colors::yellow)),
        std::shared_ptr<Piece>(new Corner(Colors::green, Colors::yellow, Colors::red)),
        std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::green)),
        std::shared_ptr<Piece>(new Corner(Colors::green, Colors::yellow, Colors::orange)),
        std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::orange)),
        std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::yellow, Colors::orange)),
        std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::blue)),
        std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::yellow, Colors::red)),
        std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::red))
    }
};


std::ostream& Corner::getStream(std::ostream& stream) {
    stream << "Corner(";
    int color;
    for (int i = 0; i < 3; i++) {
        stream << "Colors::";
        color = getColor(i);
        switch (color) {
            case Colors::white : stream << "white" ; break;
            case Colors::yellow : stream << "yellow" ; break;
            case Colors::red : stream << "red" ; break;
            case Colors::green : stream << "green" ; break;
            case Colors::orange : stream << "orange" ; break;
            case Colors::blue : stream << "blue" ; break;
        }
        stream << ", ";
    }
    stream << ")";
    return stream;
}

std::ostream& Edge::getStream(std::ostream& stream) {
    stream << "Edge(";
    int color;
    for (int i = 0; i < 2; i++) {
        stream << "Colors::";
        color = getColor(i);
        switch (color) {
            case Colors::white : stream << "white" ; break;
            case Colors::yellow : stream << "yellow" ; break;
            case Colors::red : stream << "red" ; break;
            case Colors::green : stream << "green" ; break;
            case Colors::orange : stream << "orange" ; break;
            case Colors::blue : stream << "blue" ; break;
        }
        stream << ", ";
    }
    stream << ")";
    return stream;
}

std::ostream& Center::getStream(std::ostream& stream) {
    stream << "Center(";
    stream << "Colors::";
    int color = getColor();
    switch (color) {
        case Colors::white : stream << "white" ; break;
        case Colors::yellow : stream << "yellow" ; break;
        case Colors::red : stream << "red" ; break;
        case Colors::green : stream << "green" ; break;
        case Colors::orange : stream << "orange" ; break;
        case Colors::blue : stream << "blue" ; break;
        default: stream << "oullalala la ya un pb la... color=" << color << std::endl;
    }
    stream << ", ";
    stream << ")";
    return stream;
}

std::ostream& operator<<(std::ostream& sortie, std::shared_ptr<Piece> piece) {
    return piece->getStream(sortie);
}

std::ostream& operator<<(std::ostream& stream, RubiksCube cube) {
    stream << "{" << std::endl;
    stream << "\t{" << std::endl;
    for (int i = 0; i < 9; i++) {
        stream << "\t\t" << cube.getPiece(0, i) << "," << std::endl;
    }
    stream << "\t}," << std::endl;
    stream << "\t{" << std::endl;
    for (int i = 0; i < 8; i++) {
        stream << "\t\t" << cube.getPiece(1, i) << "," << std::endl;
    }
    stream << "\t}," << std::endl;
    stream << "\t{" << std::endl;
    for (int i = 0; i < 9; i++) {
        stream << "\t\t" << cube.getPiece(2, i) << "," << std::endl;
    }
    stream << "\t}" << std::endl;
    stream << "}" << std::endl;
    return stream;
}

bool operator==(std::shared_ptr<Piece> piece1, std::shared_ptr<Piece> piece2) {
    std::vector<int> piece1Colors = piece1->getAllColors();
    std::vector<int> piece2Colors = piece2->getAllColors();
    if (piece1Colors.size() != piece2Colors.size()) return false;
    for (int i = 0; i < piece2Colors.size(); i++) {
        if (piece1Colors[i] != piece2Colors[i]) return false;
    } return true;
}

bool operator!=(std::shared_ptr<Piece> piece1, std::shared_ptr<Piece> piece2) {
    std::vector<int> piece1Colors = piece1->getAllColors();
    std::vector<int> piece2Colors = piece2->getAllColors();
    if (piece1Colors.size() != piece2Colors.size()) return true;
    for (int i = 0; i < piece2Colors.size(); i++) {
        if (std::find(piece1Colors.begin(), piece1Colors.end(), piece2Colors[i]) == piece1Colors.end()) {
            return true;
        }
    } return false;
}

Corner::Corner(int xColor, int yColor, int zColor) :
m_xColor(xColor),
m_yColor(yColor),
m_zColor(zColor) {}

Edge::Edge(int color1, int color2) :
m_color1(color1),
m_color2(color2) {}

Center::Center(int color) :
m_color(color) {}

std::shared_ptr<Piece> Corner::copy() {
    return std::shared_ptr<Piece> (new Corner(m_xColor, m_yColor, m_zColor));
}

std::shared_ptr<Piece> Edge::copy() {
    return std::shared_ptr<Piece> (new Edge(m_color1, m_color2));
}

std::shared_ptr<Piece> Center::copy() {
    return std::shared_ptr<Piece> (new Center(m_color));
}

int Corner::getColor(int color) {
    switch (color) {
        case 0: return m_xColor;
        case 1: return m_yColor;
        case 2: return m_zColor;
    }
}

int Edge::getColor(int color) {
    switch (color) {
        case 0: return m_color1;
        case 1: return m_color2;
    }
}

int Center::getColor() {
    return m_color;
}

std::vector<int> Corner::getAllColors() {
    std::vector<int> colors = {m_xColor, m_yColor, m_zColor};
    return colors;
}

std::vector<int> Edge::getAllColors() {
    std::vector<int> colors = {m_color1, m_color2};
    return colors;
}

std::vector<int> Center::getAllColors() {
    std::vector<int> colors = {m_color};
    return colors;
}

void Corner::rotate(int unchangedDirection) {
    int directionsToChange[2];
    if (unchangedDirection == Directions::x) {
        int color = m_yColor;
        m_yColor = m_zColor;
        m_zColor = color;
    }
    if (unchangedDirection == Directions::y) {
        int color = m_xColor;
        m_xColor = m_zColor;
        m_zColor = color;
    }
    if (unchangedDirection == Directions::z) {
        int color = m_xColor;
        m_xColor = m_yColor;
        m_yColor = color;
    }
    
}

void Edge::rotate() {
    int color1 = m_color1;
    m_color1 = m_color2;
    m_color2 = color1;
}

RubiksCube::RubiksCube(vectorOfPieces possibility) :
m_possibility(possibility) {}

std::shared_ptr<Piece> RubiksCube::getPiece(int ring, int i) {
    return m_possibility[ring][i];
}

int RubiksCube::getFaceColor() {
    return m_possibility[1][7]->getColor();
}


void RubiksCube::move(int corners[4][2], int edges[4][2], bool prime, bool doEdgesRotate, int cornerUnchangedDirection) {
    std::vector<std::shared_ptr<Piece>> cornersVector = {
        m_possibility[corners[0][0]][corners[0][1]],
        m_possibility[corners[1][0]][corners[1][1]],
        m_possibility[corners[2][0]][corners[2][1]],
        m_possibility[corners[3][0]][corners[3][1]]
    };
    std::vector<std::shared_ptr<Piece>> edgesVector = {
        m_possibility[edges[0][0]][edges[0][1]],
        m_possibility[edges[1][0]][edges[1][1]],
        m_possibility[edges[2][0]][edges[2][1]],
        m_possibility[edges[3][0]][edges[3][1]]
    };
    if (!prime) {
        m_possibility[corners[0][0]][corners[0][1]] = cornersVector[3];
        m_possibility[corners[1][0]][corners[1][1]] = cornersVector[0];
        m_possibility[corners[2][0]][corners[2][1]] = cornersVector[1];
        m_possibility[corners[3][0]][corners[3][1]] = cornersVector[2];
        m_possibility[edges[0][0]][edges[0][1]] = edgesVector[3];
        m_possibility[edges[1][0]][edges[1][1]] = edgesVector[0];
        m_possibility[edges[2][0]][edges[2][1]] = edgesVector[1];
        m_possibility[edges[3][0]][edges[3][1]] = edgesVector[2];
    } else {
        m_possibility[corners[0][0]][corners[0][1]] = cornersVector[1];
        m_possibility[corners[1][0]][corners[1][1]] = cornersVector[2];
        m_possibility[corners[2][0]][corners[2][1]] = cornersVector[3];
        m_possibility[corners[3][0]][corners[3][1]] = cornersVector[0];
        m_possibility[edges[0][0]][edges[0][1]] = edgesVector[1];
        m_possibility[edges[1][0]][edges[1][1]] = edgesVector[2];
        m_possibility[edges[2][0]][edges[2][1]] = edgesVector[3];
        m_possibility[edges[3][0]][edges[3][1]] = edgesVector[0];
    }
    if (doEdgesRotate) {
        for (int i = 0; i < 4; i++) {
            m_possibility[edges[i][0]][edges[i][1]]->rotate();
        }
    }
    for (int i = 0; i < 4; i++) {
        m_possibility[corners[i][0]][corners[i][1]]->rotate(cornerUnchangedDirection);
    }
}

void RubiksCube::moveInterior(int edges[4][2], int centers[4][2], bool prime) {
    std::vector<std::shared_ptr<Piece>> edgesVector = {
        m_possibility[edges[0][0]][edges[0][1]],
        m_possibility[edges[1][0]][edges[1][1]],
        m_possibility[edges[2][0]][edges[2][1]],
        m_possibility[edges[3][0]][edges[3][1]]
    };
    std::vector<std::shared_ptr<Piece>> centersVector = {
        m_possibility[centers[0][0]][centers[0][1]],
        m_possibility[centers[1][0]][centers[1][1]],
        m_possibility[centers[2][0]][centers[2][1]],
        m_possibility[centers[3][0]][centers[3][1]]
    };
    if (!prime) {
        m_possibility[edges[0][0]][edges[0][1]] = edgesVector[3];
        m_possibility[edges[1][0]][edges[1][1]] = edgesVector[0];
        m_possibility[edges[2][0]][edges[2][1]] = edgesVector[1];
        m_possibility[edges[3][0]][edges[3][1]] = edgesVector[2];
        m_possibility[centers[0][0]][centers[0][1]] = centersVector[3];
        m_possibility[centers[1][0]][centers[1][1]] = centersVector[0];
        m_possibility[centers[2][0]][centers[2][1]] = centersVector[1];
        m_possibility[centers[3][0]][centers[3][1]] = centersVector[2];
    } else {
        m_possibility[edges[0][0]][edges[0][1]] = edgesVector[1];
        m_possibility[edges[1][0]][edges[1][1]] = edgesVector[2];
        m_possibility[edges[2][0]][edges[2][1]] = edgesVector[3];
        m_possibility[edges[3][0]][edges[3][1]] = edgesVector[0];
        m_possibility[centers[0][0]][centers[0][1]] = centersVector[1];
        m_possibility[centers[1][0]][centers[1][1]] = centersVector[2];
        m_possibility[centers[2][0]][centers[2][1]] = centersVector[3];
        m_possibility[centers[3][0]][centers[3][1]] = centersVector[0];
    }
    for (int i = 0; i < 4; i++) {
        m_possibility[edges[i][0]][edges[i][1]]->rotate();
    }
}

void RubiksCube::moveR() {
    int corners[4][2] = {{0,7}, {0,5}, {2,5}, {2,7}};
    int edges[4][2] = {{0,6}, {1,4}, {2,6}, {1,6}};
    int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
    move(corners, edges, false, doEdgesRotate, Directions::x);
}

void RubiksCube::moveRp() {
    int corners[4][2] = {{0,7}, {0,5}, {2,5}, {2,7}};
    int edges[4][2] = {{0,6}, {1,4}, {2,6}, {1,6}};
    int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
    move(corners, edges, true, doEdgesRotate, Directions::x);
}


void RubiksCube::moveL() {
    int corners[4][2] = {{0,3}, {0,1}, {2,1}, {2,3}};
    int edges[4][2] = {{0,2}, {1,0}, {2,2}, {1,2}};
    int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
    move(corners, edges, false, doEdgesRotate, Directions::x);
}

void RubiksCube::moveLp() {
    int corners[4][2] = {{0,3}, {0,1}, {2,1}, {2,3}};
    int edges[4][2] = {{0,2}, {1,0}, {2,2}, {1,2}};
    int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
    move(corners, edges, true, doEdgesRotate, Directions::x);
}

void RubiksCube::moveU() {
    int corners[4][2] = {{0,1}, {0,3}, {0,5}, {0,7}};
    int edges[4][2] = {{0,2}, {0,4}, {0,6}, {0,8}};
    int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
    move(corners, edges, false, doEdgesRotate, Directions::y);
}

void RubiksCube::moveUp() {
    int corners[4][2] = {{0,1}, {0,3}, {0,5}, {0,7}};
    int edges[4][2] = {{0,2}, {0,4}, {0,6}, {0,8}};
    int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
    move(corners, edges, true, false, Directions::y);
}

void RubiksCube::moveD() {
    int corners[4][2] = {{2,7}, {2,5}, {2,3}, {2,1}};
    int edges[4][2] = {{2,8}, {2,6}, {2,4}, {2,2}};
    int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
    move(corners, edges, false, false, Directions::y);
}

void RubiksCube::moveDp() {
    int corners[4][2] = {{2,7}, {2,5}, {2,3}, {2,1}};
    int edges[4][2] = {{2,8}, {2,6}, {2,4}, {2,2}};
    int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
    move(corners, edges, true, false, Directions::y);
}

void RubiksCube::moveF() {
    int corners[4][2] = {{0,1}, {0,7}, {2,7}, {2,1}};
    int edges[4][2] = {{0,8}, {1,6}, {2,8}, {1,0}};
    int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::red;
    move(corners, edges, false, doEdgesRotate, Directions::z);
}

void RubiksCube::moveFp() {
    int corners[4][2] = {{0,1}, {0,7}, {2,7}, {2,1}};
    int edges[4][2] = {{0,8}, {1,6}, {2,8}, {1,0}};
    int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::orange;
    move(corners, edges, true, doEdgesRotate, Directions::z);
}

void RubiksCube::moveB() {
    int corners[4][2] = {{0,3}, {2,3}, {2,5}, {0,5}};
    int edges[4][2] = {{0,4}, {1,2}, {2,4}, {1,4}};
    int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::orange;
    move(corners, edges, false, doEdgesRotate, Directions::z);
}

void RubiksCube::moveBp() {
    int corners[4][2] = {{0,3}, {2,3}, {2,5}, {0,5}};
    int edges[4][2] = {{0,4}, {1,2}, {2,4}, {1,4}};
    int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::orange;
    move(corners, edges, true, doEdgesRotate, Directions::z);
}

void RubiksCube::moveM() {
    int edges[4][2] = {{0,8}, {2,8}, {2,4}, {0,4}};
    int centers[4][2] = {{0,0}, {1,7}, {2,0}, {1,3}};
    moveInterior(edges, centers, false);
}

void RubiksCube::movem() {
    int edges[4][2] = {{0,8}, {2,8}, {2,4}, {0,4}};
    int centers[4][2] = {{0,0}, {1,7}, {2,0}, {1,3}};
    moveInterior(edges, centers, true);
}

void RubiksCube::moveE() {
    int edges[4][2] = {{1,0}, {1,2}, {1,4}, {1,6}};
    int centers[4][2] = {{1,7}, {1,1}, {1,3}, {1,5}};
    moveInterior(edges, centers, false);
}

void RubiksCube::movee() {
    int edges[4][2] = {{1,0}, {1,2}, {1,4}, {1,6}};
    int centers[4][2] = {{1,7}, {1,1}, {1,3}, {1,5}};
    moveInterior(edges, centers, true);
}

void RubiksCube::moveS() {
    int edges[4][2] = {{0,6}, {2,6}, {2,2}, {0,2}};
    int centers[4][2] = {{0,0}, {1,5}, {2,0}, {1,1}};
    moveInterior(edges, centers, false);
}

void RubiksCube::moves() {
    int edges[4][2] = {{0,6}, {2,6}, {2,2}, {0,2}};
    int centers[4][2] = {{0,0}, {1,5}, {2,0}, {1,1}};
    moveInterior(edges, centers, true);
}

void RubiksCube::movex() {
    moveR();
    movem();
    moveLp();
}

void RubiksCube::movexp() {
    moveRp();
    moveM();
    moveL();
}

void RubiksCube::movey() {
    moveU();
    moveE();
    moveDp();
}

void RubiksCube::moveyp() {
    moveUp();
    movee();
    moveD();
}

void RubiksCube::movez() {
    moveF();
    moveS();
    moveBp();
}


void RubiksCube::movezp() {
    moveFp();
    moveS();
    moveB();
}

void RubiksCube::silentMovex() {
    moveR();
    movem();
    moveLp();
}

void RubiksCube::silentMovexp() {
    moveRp();
    moveM();
    moveL();
}

void RubiksCube::silentMovey() {
    moveU();
    moveE();
    moveDp();
}

void RubiksCube::silentMoveyp() {
    moveUp();
    movee();
    moveD();
}

void RubiksCube::silentMovez() {
    moveF();
    moveS();
    moveBp();
}

void RubiksCube::silentMovezp() {
    moveFp();
    moveS();
    moveB();
}

RubiksCube RubiksCube::askForCube() {
    int faces[6][9];
    std::cout << "Les couleurs"
    << std::endl << "\t- Blanc : 0"
    << std::endl << "\t- Jaune : 1"
    << std::endl << "\t- Rouge : 2"
    << std::endl << "\t- Vert : 3"
    << std::endl << "\t- Orange : 4"
    << std::endl << "\t- Bleu : 5" << std::endl;
    std::string facesNames[6] = {"blanche", "jaune", "rouge", "verte", "orange", "bleue"};
    for (int face = 0; face < 6; face++) {
        std::cout << "Entrez la face " << facesNames[face] << " : (centre en premier)" << std::endl;
        for (int i = 0; i < 9; i++) {
            std::cout << "\t> ";
            std::cin >> faces[face][i];
        }
    }
    vectorOfPieces possibility = {
        {
            std::shared_ptr<Piece>(new Center(faces[0][0])),
            std::shared_ptr<Piece>(new Corner(faces[3][5], faces[0][1], faces[2][3])),
            std::shared_ptr<Piece>(new Edge(faces[0][2], faces[3][4])),
            std::shared_ptr<Piece>(new Corner(faces[3][3], faces[0][3], faces[4][5])),
            std::shared_ptr<Piece>(new Edge(faces[0][4], faces[4][4])),
            std::shared_ptr<Piece>(new Corner(faces[5][5], faces[0][5], faces[4][3])),
            std::shared_ptr<Piece>(new Edge(faces[0][6], faces[5][4])),
            std::shared_ptr<Piece>(new Corner(faces[5][3], faces[0][7], faces[2][5])),
            std::shared_ptr<Piece>(new Edge(faces[0][8], faces[2][4])),
        },
        {
            std::shared_ptr<Piece>(new Edge(faces[2][2], faces[3][6])),
            std::shared_ptr<Piece>(new Center(faces[3][0])),
            std::shared_ptr<Piece>(new Edge(faces[4][6], faces[3][2])),
            std::shared_ptr<Piece>(new Center(faces[4][0])),
            std::shared_ptr<Piece>(new Edge(faces[4][2], faces[5][6])),
            std::shared_ptr<Piece>(new Center(faces[5][0])),
            std::shared_ptr<Piece>(new Edge(faces[2][6], faces[5][2])),
            std::shared_ptr<Piece>(new Center(faces[2][0])),
        },
        {
            std::shared_ptr<Piece>(new Center(faces[1][0])),
            std::shared_ptr<Piece>(new Corner(faces[3][7], faces[1][3], faces[2][1])),
            std::shared_ptr<Piece>(new Edge(faces[1][2], faces[3][8])),
            std::shared_ptr<Piece>(new Corner(faces[3][1], faces[1][1], faces[4][7])),
            std::shared_ptr<Piece>(new Edge(faces[1][8], faces[4][8])),
            std::shared_ptr<Piece>(new Corner(faces[5][7], faces[1][7], faces[4][1])),
            std::shared_ptr<Piece>(new Edge(faces[1][6], faces[5][8])),
            std::shared_ptr<Piece>(new Corner(faces[5][1], faces[1][5], faces[2][7])),
            std::shared_ptr<Piece>(new Edge(faces[1][4], faces[2][8])),
        }
    };
    RubiksCube cube(possibility);
    return cube;
}

RubiksCube RubiksCube::makeRandomCube(vectorOfPieces possibility, int seed) {
    for (int i = 0; i < 9; i++) {
        possibility[0][i] = possibility[0][i]->copy();
    }
    for (int i = 0; i < 8; i++) {
        possibility[1][i] = possibility[1][i]->copy();
    }
    for (int i = 0; i < 9; i++) {
        possibility[2][i] = possibility[2][i]->copy();
    }
    srand(seed);
    RubiksCube cube(possibility);
    for (int i = 0; i < 100; i++) {
        switch(rand() % 11) {
            case Movements::R: cube.moveR();break;
            case Movements::Rp: cube.moveRp();break;
            case Movements::L: cube.moveL();break;
            case Movements::Lp: cube.moveLp();break;
            case Movements::U: cube.moveU();break;
            case Movements::Up: cube.moveUp();break;
            case Movements::D: cube.moveD();break;
            case Movements::Dp: cube.moveDp();break;
            case Movements::F: cube.moveF();break;
            case Movements::Fp: cube.moveFp();break;
            case Movements::B: cube.moveB();break;
            case Movements::Bp: cube.moveBp();break;
        }
    } return cube;
}

RubiksCube RubiksCube::makeRandomCube(vectorOfPieces possibility) {
    return makeRandomCube(possibility, time(NULL));
}

RubiksCube RubiksCube::makeRandomCube() {
    return makeRandomCube(RUBIKS_CUBE_FINISHED, time(NULL));
}

std::vector<int> RubiksCube::findPlaceOfPiece(std::shared_ptr<Piece> piece, vectorOfPieces possibility) {
    for (int i = 0; i < 9; i++) {
        if (!(possibility[0][i] != piece)) return std::vector<int> {0, i};
    }
    for (int i = 0; i < 8; i++) {
        if (!(possibility[1][i] != piece)) return std::vector<int> {1, i};
    }
    for (int i = 0; i < 9; i++) {
        if (!(possibility[2][i] != piece)) return std::vector<int> {2, i};
    }
    std::cout << "ERROR : Piece not found " << piece << std::endl;
    return std::vector<int> {-1, -1};
}

bool RubiksCube::isPieceWellPlaced(vectorOfPieces objective, std::shared_ptr<Piece> piece) {
    std::vector<int> movements;
    if (m_possibility[1][1]->getColor() == Colors::white || m_possibility[1][5]->getColor() == Colors::white) {
        silentMovex();
        movements.push_back(Directions::x);
    }
    while (m_possibility[0][0]->getColor() != Colors::white) {
        silentMovex();
        movements.push_back(Directions::x);
    }
    while (m_possibility[1][7]->getColor() != Colors::red) {
        silentMovey();
        movements.push_back(Directions::y);
    }
    std::vector<int> placeOnObjective = findPlaceOfPiece(piece, objective);
    std::vector<int> placeOnPossibility =  findPlaceOfPiece(piece, m_possibility);
    bool response = placeOnObjective == placeOnPossibility;
    for (int i = movements.size() - 1; i >= 0; i--) {
        switch (movements[i]) {
            case Directions::x: silentMovexp();break;
            case Directions::y: silentMoveyp();break;
            case Directions::z: silentMovezp();break;
        }
    }
    return response;
}

Sequence RubiksCube::goTo(vectorOfPieces objective) {
    solveFirstCross(objective);
    finishFirstFace(objective);
    Sequence s;
    return s;
}

void RubiksCube::solveFirstCross(vectorOfPieces objective) {
    std::vector<std::shared_ptr<Piece>> edges = {
        objective[0][2],
        objective[0][4],
        objective[0][6],
        objective[0][8]
    };
    for (int i = 0; i < 4; i++) {
        moveyp();
        if (!isPieceWellPlaced(objective, edges[i])) {
            putEdgeDown(edges[i]);
            placeEdge(objective, edges[i]);
        }
    }
}

void RubiksCube::putEdgeDown(std::shared_ptr<Piece> edge) {
    std::vector<int> pos = findPlaceOfPiece(edge, m_possibility);
    for (int i = 0; i < pos[1] / 2; i++) {
        moveyp();
    }
    if (pos[0] == 0) {
        moveM();
        moveDp();
        movem();
        moveD();
    } else if (pos[0] == 1) {
        moveL();
        moveD();
        moveLp();
    }
    for (int i = 0; i < pos[1] / 2; i++) {
        movey();
        moveD();
    }
}

void RubiksCube::placeEdge(vectorOfPieces objective, std::shared_ptr<Piece> edge) {
    if (m_possibility[2][8]->getColor(1) == objective[0][findPlaceOfPiece(edge, objective)[1]]->getColor(0)) {   // GOOD ORIENTATION
        moveDp();
        moveM();
        moveD();
        movem();
    } else {    // BAD ORIENTATION
        moveM();
        moveD();
        moveD();
        movem();
    }
}


void RubiksCube::finishFirstFace(vectorOfPieces objective) {
    std::vector<std::shared_ptr<Piece>> corners = {
        objective[0][1],
        objective[0][3],
        objective[0][5],
        objective[0][7]
    };
    for (int i = 0; i < 4; i++) {
        moveyp();
        if (!isPieceWellPlaced(objective, corners[i])) {
            putCornerDown(corners[i]);
            placeCorner(objective, corners[i]);
        }
    }
}

void RubiksCube::putCornerDown(std::shared_ptr<Piece> corner) {
    std::vector<int> pos = findPlaceOfPiece(corner, m_possibility);
    for (int i = 0; i < (pos[1] + 1) / 2; i++) {
        moveyp();
    }
    if (pos[0] == 0) {
        moveRp();
        moveDp();
        moveR();
        moveD();
    }
    for (int i = 0; i < (pos[1] + 1) / 2; i++) {
        movey();
        moveD();
    }
}


void RubiksCube::placeCorner(vectorOfPieces objective, std::shared_ptr<Piece> corner) {
    int color = objective[0][findPlaceOfPiece(corner, objective)[1]]->getColor(1);      // COLOR OF WHITE FACE
    //std::cout << objective << std::endl;
    //std::cout << color << findPlaceOfPiece(corner, objective)[0] << findPlaceOfPiece(corner, objective)[1];
    //std::cout << m_possibility[2][7] << std::endl;
    if (m_possibility[2][7]->getColor(0) == color) {
        moveRp();
        moveDp();
        moveR();
    } else if (m_possibility[2][7]->getColor(1) == color) {
        moveRp();
        moveD();
        moveD();
        moveR();
        moveD();
        moveRp();
        moveDp();
        moveR();
    } else if (m_possibility[2][7]->getColor(2) == color) {
        moveDp();
        moveRp();
        moveD();
        moveR();
    }
}

void RubiksCube::test() {
    std::cout << m_possibility.size() << m_possibility[0].size() << m_possibility[1].size() << m_possibility[2].size();
}

void getStats(bool debug) {
    std::vector<std::vector<int>> TO_VERIFY {
        {0, 0},
        {0, 1},
        {0, 2},
        {0, 3},
        {0, 4},
        {0, 5},
        {0, 6},
        {0, 7},
        {0, 8},
    };
    srand(time(NULL));
    int rights = 0;
    int tests = 1000;
    double startTime = time(NULL);
    for (int i = 0; i < tests; i++) {
        int seed = rand();
        RubiksCube cube = RubiksCube::makeRandomCube(RUBIKS_CUBE_FINISHED, seed);
        cube.goTo(RUBIKS_CUBE_FINISHED);
        bool error = false;
        for (int j = 0; j < TO_VERIFY.size(); j++) {
            if (cube.getPiece(TO_VERIFY[j][0], TO_VERIFY[j][1]) != RUBIKS_CUBE_FINISHED[TO_VERIFY[j][0]][TO_VERIFY[j][1]]) {
                error = true;
            }
        }
        if (!error) {
            rights += 1;
        } else if (debug) {
            std::cout << "FAILURE WITH SEED : " << seed << std::endl;
        }
        if (tests / 100 != 0 && i % (tests/100) == 0) {
            std::cout << i / (tests/100) << "% made" << std::endl;
        }
    }
    double endTime = time(NULL);
    std::cout << std::endl << std::endl;
    std::cout << "\t- Number of tests : " << tests << std::endl;
    std::cout << "\t- " << (((double)rights)/tests) * 100 << "% tests successfull (" << tests - rights << " failed)" << std::endl;
    std::cout << "\t- Execution time : " << endTime - startTime << "s" << std::endl;
    std::cout << "\t- " << (endTime - startTime) / tests << " s/test" << std::endl;
    std::cout << "\t- " << tests / (endTime - startTime) << " tests/s" << std::endl;
}


int main() {
    //RubiksCube cube = RubiksCube::makeRandomCube();
    //cube.goTo(RUBIKS_CUBE_FINISHED);
    //std::cout << cube;
    getStats(false);
    return 0;
}