#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<limits.h>
#include <pthread.h>


pthread_t *tid; //recebe os identificadores das threads

void *organizadorDeCestas(void *indice_cesta_void);
int comparar(const void *a, const void *b);

int in_numeros[300], qtd_numeros, qtd_threads, qtd_cestas, menor_numero, maior_numero;
int **cestas, diferenca_por_cesta, *num_item_por_cesta, i, j;


//argv[1] = numeros de threads
//argv[2] = numeros de cestas (total)
int main (int argc, char *argv[])
{
    FILE *in;
    qtd_numeros = 0;
    menor_numero = INT_MAX;
    maior_numero = INT_MIN;
    if (argc < 3)
    {
      printf("[ERRO] quantidade insuficiente de parâmetros.\n");
       return -1;
    }
    qtd_threads = atoi(argv[1]);
    qtd_cestas  = atoi(argv[2]);
    //linha adicionada para "simplificar" o problema
    qtd_cestas = qtd_threads;
    printf("qtd_cestas %d\n", qtd_cestas);
    //tratar erro aqui de qtds ser não válido
    tid = (pthread_t*)malloc(sizeof(pthread_t)*qtd_threads);
    cestas = (int**)malloc(sizeof(int*)*qtd_cestas);
    memset(cestas, 0x00, sizeof(int*)*qtd_cestas);
    num_item_por_cesta = (int*)malloc(sizeof(int)*qtd_cestas);
    memset(num_item_por_cesta, 0x00, sizeof(int)*qtd_cestas);
    in = fopen("entrada.txt", "r");
    if (!in)
    {
       printf("[ERRO] erro ao abrir arquivo de entrada.\n");
       return -1;
    }
    //pegando entrada
    //considera-se que nao haverá mais de 300 numeros no arquivo
    while (!feof(in))
    {
          fscanf(in, "%d\n", &in_numeros[qtd_numeros]);
           printf("numero %d\n", in_numeros[qtd_numeros]);
          if (in_numeros[qtd_numeros] < menor_numero)
             menor_numero = in_numeros[qtd_numeros];
          if (in_numeros[qtd_numeros] > maior_numero)
             maior_numero = in_numeros[qtd_numeros];
          qtd_numeros++;
    }

    //organizando cestas
    diferenca_por_cesta = (maior_numero - menor_numero)/qtd_cestas;
     printf("diferenca_por_cesta %d = (%d -%d)/%d\n", diferenca_por_cesta,maior_numero,menor_numero,qtd_cestas);
    if (diferenca_por_cesta <= 0)
    {
       printf("[ERRO] erro no maior_valor e menor_valor.\n");
       return -1;
    }

    //por favor, nao me mate... vou melhorar isso... vou mudar nao.. time que ta ganhando nao se mexe
    for (i = 0; i < qtd_numeros; i++)
    {
//        printf("menor numero %d\n", menor_numero);
        printf("item n %d valor %d, diferenca por cesta %d\n", i,in_numeros[i],diferenca_por_cesta);
        int cesta_alvo = (in_numeros[i] - menor_numero)/diferenca_por_cesta;
        printf("cesta_alvo %d\n", cesta_alvo);
        cestas[cesta_alvo] = (int*)realloc(cestas[cesta_alvo],(num_item_por_cesta[cesta_alvo]+1)*sizeof(int));
        printf("aumentando de %d para %d\n",num_item_por_cesta[cesta_alvo],num_item_por_cesta[cesta_alvo]+1);
        if (cestas[cesta_alvo] == NULL)
           printf("loucura...\n");
        printf("adicionando na posicao %d o valor de %d\n", num_item_por_cesta[cesta_alvo],in_numeros[i]);
        cestas[cesta_alvo][num_item_por_cesta[cesta_alvo]] = in_numeros[i];//será que nao fura o limite?
        num_item_por_cesta[cesta_alvo]++;
    }
    //dividindo as cestas
    printf("dividindo as cestas\n");
    for (i=0; i<qtd_threads; i++)
    {
        pthread_create(&tid[i], NULL, organizadorDeCestas, (void *) (&i));
    }
    for (i = 0; i < qtd_threads; i++)
    {
        pthread_join(tid[i], NULL);
    }
    for (i = 0; i < qtd_cestas; i++)
    {
        for (j = 0; j < num_item_por_cesta[i]; j++)
        {
                 printf("%d\n", cestas[i][j]);
        }
    }
    scanf("%d", qtd_numeros);
    return 0;
}

void *organizadorDeCestas(void *indice_cesta_void)
{
        int indice_cesta = *((int*)indice_cesta_void);
        qsort( cestas[indice_cesta], num_item_por_cesta[indice_cesta], sizeof(int), comparar);
}

int comparar(const void *a, const void *b)
{
  return(*(int*)a - *(int*)b);
}