#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
/* Time in seconds from some point in the past */

/*****************************************************************/

double dwalltime()
{
    double sec;
    struct timeval tv;

    gettimeofday(&tv, NULL);
    sec = tv.tv_sec + tv.tv_usec / 1000000.0;
    return sec;
}

//FIN de calcular tiempo

int N = 4;
/*Variables pertenecientes a los hilos*/
int P = 0;
pthread_mutex_t s = PTHREAD_MUTEX_INITIALIZER;
/*Variables a reemplazar por argumentos*/
int Min = 999;
int Max = -1;
int check = 1;

/*matriz A por fila y por columnas*/
int *A,*RESULT;
double timetick;
//funcion para poder visualizar matriz
void vermatriz(int *m, int modo)
{
    /*LE DA EL FORMATO A LA COLUMNA*/
    printf(" \t Columna |\t");
    for (int k = 0; k < N; k++)
    {
        printf(" %d \t", k);
    }
    printf("\n");
    printf("\t -------------------------------------------");
    printf("\n");

    printf("\t");
    for (int i = 0; i < N; i++)
    {
        printf(" Fila %d  |\t", i);
        for (int j = 0; j < N; j++)
        {
            if (modo == 0)
            {
                printf(" %d \t", m[i * N + j]); //recorre por fila
            }
            else
            {
                printf(" %d \t", m[i + j * N]); //recorre por columna
            }
        }
        printf("\n \t");
    }
}

void *Funcion_maxmin(void *arg)
{

    int tid = *(int *)arg;
    int ini = tid * (P);
    int fin = (tid + 1) * (P);
    int min = 999;
    int max = -1; // es mejor calcular los minimos y maximos de manera local
    // y al final pasarselos a una variable global minimo y maximo. Esto es debido a la rapidez
    printf(" \n ");
    printf(" ESTOY EN LA FUNCION DE H %d", tid);
    printf(" \n ");
    printf(" INI %d FIN  %d", ini, fin);
    printf(" \n ");

    for (int i = ini; i < fin; i++)
    {
        for (int j = ini; j < fin; j++)
        {
            if (A[i * fin + j] < min)
                min = A[i * N + j];
            if (A[i * fin + j] > max)
                max = A[i * N + j];
        }
    }
    // se lo pasamos a la variable global

    pthread_mutex_lock(&s);
    if (min < Min)
        Min = min;
    pthread_mutex_unlock(&s);

    pthread_mutex_lock(&s);
    if (max > Max)
        Max = max;

    pthread_mutex_unlock(&s);
    pthread_exit(NULL); //finalizacion del hilo
}

int main(int argc, char *argv[])
{
    int H = 2; // es un valor por defecto en el caso de que no se
    // introduzca ningun valor por consola.

    //Controla los argumentos al programa
    if ((argc != 3) || ((N = atoi(argv[1])) <= 0) || ((H = atoi(argv[2])) <= 0))
    {
        printf("\nUsar: %s n\n  h: cant hilos  \n", argv[0]);
        exit(1);
    }

    /*Declarar e inicializaciones*/
    N = atoi(argv[1]); // Inicializa valor de mi arreglo de N elementos
    H = atoi(argv[2]); //incializar valor de hilos

    //calculamos la proporcion
    P = N / H;

    /*Matriz A original*/
    A = (int *)malloc(N * N * sizeof(int));

    RESULT = (int *)malloc(N * N * sizeof(int));

    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            A[i * N + j] = i;
        }
    }
    vermatriz(A, 0);
    //Reservo memoria para el vector de hilos
    pthread_t *tid = (pthread_t *)(malloc(sizeof(pthread_t) * H)); // por esto me daba error!
    int *threads_ids = (int *)(malloc(sizeof(int) * H));
    pthread_mutex_init(&s, NULL); // inicializacion s

    //Realiza el tiempo inicial para la busqueda y calclulo
    timetick = dwalltime();
    for (int t = 0; t < H; t++)
    {
        threads_ids[t] = t;
        pthread_create(&tid[t], NULL, Funcion_maxmin, (void *)&threads_ids[t]);
    }
    for (int t = 0; t < H; t++)
        pthread_join(tid[t], NULL);
    //Destruccion de s
    pthread_mutex_destroy(&s);


    //Realiza el tiempo iniial para la busqueda y calclulo
    timetick = dwalltime();
    printf("Tiempo en segundos %f\n", dwalltime() - timetick);

    if (check)
        printf("Multiplicacion de matrices resultado correcto\n");
    else
        printf("Multiplicacion de matrices resultado erroneo\n");

    printf("resultado max es: %d \n", Max);
    printf("resultado min es: %d \n", Min);

    /*Matriz A original*/
    free(A);
    free(RESULT);

    return (0);
}

//NOTA AVERIGUAR POR QUE SE DESBORDA