//POLIMORFISMO
#include <iostream>
using namespace std;

class MATRIZ 
{
public:
    MATRIZ();
    virtual void Genera_Matriz();
    void Imprime_Matriz();
    ~MATRIZ();
    
protected:
    int FIL, COL, i, j;
    float **mat;
};

class MATRIZ_M : public MATRIZ 
{
public:
    MATRIZ_M();
    ~MATRIZ_M();
    void Genera_Matriz();
};

class MATRIZ_I : public MATRIZ 
{
public:
    MATRIZ_I();
    ~MATRIZ_I();
    void Genera_Matriz();
};

class MATRIZ_R : public MATRIZ 
{
public:
    MATRIZ_R();
    ~MATRIZ_R();
    void Genera_Matriz();
};

MATRIZ::MATRIZ() 
{
    FIL = COL = 1;
    mat = NULL;
}

MATRIZ::~MATRIZ() 
{
    for (int i = 0; i < FIL; i++) 
    {
        delete[] mat[i];
    }
    delete[] mat;
}

void MATRIZ::Genera_Matriz() 
{
    cout << "======================================"<<endl;
    cout << "Introduce filas: ";
    while (!(cin >> FIL) || FIL <= 0)
    {
        cout << "Entrada invalida. Por favor, introduce un número positivo: ";
        cin.clear();
        cin.ignore(10000, '\n');
    }
    cout << "Introduce columnas: ";
    while (!(cin >> COL) || COL <= 0) {
        cout << "Entrada inválida. Por favor, introduce un número positivo: ";
        cin.clear();
        cin.ignore(10000, '\n');
    }
    mat = new float *[FIL];
    for (i = 0; i < FIL; i++) {
        mat[i] = new float[COL];
    }
    for (i = 0; i < FIL; i++) {
        for (j = 0; j < COL; j++) {
            mat[i][j] = 0;
        }
    }
}

void MATRIZ::Imprime_Matriz() {
    for (i = 0; i < FIL; i++) {
        for (j = 0; j < COL; j++) {
            cout << mat[i][j] << "\t";
        }
        cout << endl;
    }
}

MATRIZ_M::MATRIZ_M() : MATRIZ() {}

MATRIZ_M::~MATRIZ_M() {}

void MATRIZ_M::Genera_Matriz() {
    MATRIZ::Genera_Matriz();
    int n = 2;
    for (i = 0; i < FIL; i++) {
        for (j = 0; j < COL; j++) {
            mat[i][j] = n;
            n += 2;
        }
    }
}

MATRIZ_I::MATRIZ_I() : MATRIZ() {}

MATRIZ_I::~MATRIZ_I() {}

void MATRIZ_I::Genera_Matriz() {
    MATRIZ::Genera_Matriz();
    for (i = 0; i < FIL; i++) {
        for (j = 0; j < COL; j++) {
            mat[i][j] = (i == j) ? 1 : 0;
        }
    }
}

MATRIZ_R::MATRIZ_R() : MATRIZ() {}

MATRIZ_R::~MATRIZ_R() {}

void MATRIZ_R::Genera_Matriz() {
    MATRIZ::Genera_Matriz();
    int seed = 7; // Valor semilla fijo para simular "aleatoriedad"
    for (i = 0; i < FIL; i++) {
        for (j = 0; j < COL; j++) {
            seed = (seed * 3 + 7) % 100; // Operación para generar un patrón pseudoaleatorio
            mat[i][j] = static_cast<float>(seed);
        }
    }
}

void polimorfismo() 
{
    int opc;
    MATRIZ *matriz1 = new MATRIZ_M();
    MATRIZ *matriz2 = new MATRIZ_I();
    MATRIZ *matriz3 = new MATRIZ_R();
    do 
    {
        cout << "********************************"<<endl;
        cout << "[1]. Matriz de multiplos de 2" << endl;
        cout << "[2]. Matriz Identidad" << endl;
        cout << "[3]. Matriz Aleatoria" << endl;
        cout << "[4]. Salir" << endl;
        cout << "INTRODUCE UNA OPCION: ";
        while (!(cin >> opc) || opc < 1 || opc > 4) {
            cout << "NO SE PUEDE ES DE 1 AL 4";
            cin.clear();
            cin.ignore(10000, '\n');
        }

        switch (opc) 
        {
            case 1:
                matriz1->Genera_Matriz();
                matriz1->Imprime_Matriz();
                break;
            case 2:
                matriz2->Genera_Matriz();
                matriz2->Imprime_Matriz();
                break;
            case 3:
                matriz3->Genera_Matriz();
                matriz3->Imprime_Matriz();
                break;
            case 4:
                cout << "Salir..." << endl;
                break;
        }
    } while (opc != 4);

    delete matriz1;
    delete matriz2;
    delete matriz3;
}

int main() 
{
    polimorfismo();
    return 0;
}