/*opération que l'on doit pouvoir faire sur T:
    empiler dessus
    trouver le pivot
    le trier par angle croissant
    savoit si un de ses elément est a droite d'un segment
    
    sur S:
    le depiler*/

struct point {
    int x;
    int y;
};
typedef struct point point;

point p; //global variable (c'est le mal mais il faut que la fonction comp ait seulement deux arguments pour l'utiliser dans qsort)

/*Find the pivot of a table( which is the point with the lowest ordonnée (and lowest absisse if egality))
*@param table T
*@param size of T*/
point pivot(T[],size_t size){
    piv = T[0];
    for (int i=1;i<size,i++){
        if (piv.y>T[i].y) piv = T[i]
        if (piv.y=T[i].y) {
            if (piv.x=T[i].x) piv = T[i]
        }
    }
}

int main() {
  size_t n = 1000;
  size_t elem_size = sizeof(int);
  int* tab = malloc(elem_size * n);

  // Create an array of random integers
  printf("initial = [ ");
  for(int i = 0; i < n; i++)  {
    tab[i] = rand() % n;
    printf("%d ", tab[i]);
  }
  printf("]\n");

  // Then Sort it
  qsort(tab, n, elem_size, compareInt);

  printf("sorted = [ ");
  for(int i = 0; i < n; i++)  {
    printf("%d ", tab[i]);
  }
  printf("]\n");
}

/**
 * @brief Affiche les points ainsi que l'nveloppe convexe
 * 
 * @param T L'ensemble des points
 * @param S Les points dans l'ordre de l'enveloppe convexe
 */
void draw_point(dynarray* T, dynarray* S) {
    ClearBackground(WHITE);
    for (int i = 0; i < T->size; ++i) {
        DrawCircle(T->begin[i].x, T->begin[i].y, 3, BLUE);
    }
    for (int i = 0; i < S->size; ++i) {
        DrawLineV(S->begin[i], S->begin[(i+1)%S->size], RED);
    }
}

/**
 * @brief Ajoute un élément à la fin du tableau
 * 
 * @param array Le tableau
 * @param x L'élément à ajouter
 */
void push(dynarray* array, element x) {
    if (array->capacity < array->size + 1) {
        int new_capacity = 9 * array->capacity / 8 + 4;
        element* new_begin = malloc(sizeof(*new_begin) * new_capacity);
        for (int i = 0; i < array->capacity; ++i) {
            new_begin[i] = array->begin[i];
        }
        free(array->begin);
        array->begin = new_begin;
        array->capacity = new_capacity;
    }
    array->begin[array->size++] = x;
}

void exo1(){
	float div(int a, int b){return (float) a / b;}
	float x=7;
	/*int n=3.5;*/
	int* px=(int*) &x;
	/*float* pn=(float*) &n;*/
	const int n=7;
	const int* p=&n;}

float theta_point(point p){
    float theta;

    theta = acosf(p.x/(norm(p)));
    
    if (p.y < 0){
        theta = 2*M_PI -theta;
    }
    return theta;
}

void trie_tab_points(point* tab, int len, point pivot){
    PIVOT = pivot;
    qsort(tab, len, sizeof(point), comparePoints);
}

void tri(point tab[],int n, point p){
    qsort(tab,n,sizeof(point),compare_angle);
}

void push(dynarray* tab, int x){
    if ((*tab).capacity==0){ //si le tableau est vide on lui alloue ses premières cases mémoire
        (*tab).begin = malloc(1);
        (*tab).capacity=1;
        (*tab).size=1;
        *((*tab).begin)=x;
    }
    else{
        if ((*tab).size+1>(*tab).capacity){ // si il est rempli on en construit un plus grand et on recopie les valeurs déjà présentes
            int n = 9*((*tab).capacity)/8+4;
            int* p = malloc(n);
            for (int i = 0;i<(*tab).capacity;i++){
                *(p+i)=*((*tab).begin+i);
            }
            (*tab).begin=p;
            (*tab).capacity=n;
            (*tab).size=(*tab).size+1;
        }
        else{ // sinon on rajoute simplement une valeur au bout
            *((*tab).begin+(*tab).size)=x;
            (*tab).size=(*tab).size+1;
        }
    }
}

/**
 * @brief remove the top element from the stack and free the memory
 * 
 * @param the current (top of) stack 
 * @return the new (top of) stack
 */
tStack pop(tStack s)
{
    tStack next = s->next;
    free(s);
    return s->next;
}


VS

/**
 * @brief remove the top element from the stack and modify in place the stack to point the next element
 * 
 * @param a pointer (to the top of) the stack
 */
void pop(tStack * const s)
{
    tStack next = (*s)->next;
    free(*s);
    *s = next;
}