First aid service through binary heap

//basic.h
#ifndef BASIC_H
#define BASIC_H

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdint.h>

typedef struct {
    char Nome[20];
    char CF[17];
    char Referto[100];
    char CodiceAccesso;
    uint32_t OraArrivo;
} Persona;

int lang;

typedef Persona element;

extern element *toDynamic(const element v[], int n);
extern bool isLeaf(element *v, int i, uint32_t heap_size);
extern void swap(element *v, uint32_t a, uint32_t b);
extern int left(int i);
extern int right(int i);
extern int parent(int i);
extern element Max(element a, element b);
extern void moveDown(element *v, int i, uint32_t heap_size);
extern void moveUp(element *v, uint32_t i);
extern element *deleteNode(element *v, int i, uint32_t *heap_size);
extern element *insertNode(element *v, element e, uint32_t *heap_size);
extern bool isGreater(element lhs, element rhs);
extern bool isLess(element lhs, element rhs);
extern bool isEqual(element lhs, element rhs);
extern void print(char *s_en, char *s_it);
extern void showHeap(element *v, int i, uint32_t heap_size);
extern void printElement(element e);
extern char *establishCode(int CodiceAccesso);

#endif // !BASIC_H

//basic.c

element *toDynamic(const element v[], int n)
{
    element *ret = malloc(n * sizeof(element));
    memcpy(ret, v, n * sizeof(element));
    return ret;
}

element *copyHeap(element *v, uint32_t heap_size)
{
    element *copied = malloc((heap_size + 1) * sizeof(element));

    memcpy(copied, v, (heap_size + 1) * sizeof(element));
    return copied;
}

bool isLeaf(element *v, int i, uint32_t heap_size)
{
    return i > parent(heap_size);
}

void swap(element *v, uint32_t a, uint32_t b)
{
    element *temp = malloc(sizeof(element));
    memcpy(temp, &v[a], sizeof(element));
    memcpy(&v[a], &v[b], sizeof(element));
    memcpy(&v[b], temp, sizeof(element));
}

int left(int i)
{
    return 2 * i;
}

int right(int i)
{
    return 2 * i + 1;
}

int parent(int i)
{
    return (i != 1 && i != 0) ? i / 2 : -1;
}

bool isGreater(element lhs, element rhs)
{
    if (lhs.CodiceAccesso > rhs.CodiceAccesso) return true;

    if (lhs.CodiceAccesso == rhs.CodiceAccesso)
    {
        if (lhs.OraArrivo < rhs.OraArrivo) return true;

        return false;
    }

    return false;
}

bool isLess(element lhs, element rhs)
{
    return !isEqual(lhs, rhs) && !isGreater(lhs, rhs);
}

bool isEqual(element lhs, element rhs)
{
    return lhs.CodiceAccesso == rhs.CodiceAccesso && lhs.OraArrivo == rhs.OraArrivo;
}

element Max(element a, element b)
{
    if (isGreater(a, b)) return a;
    else if (isLess(a, b)) return b;

    return a;
}

void moveUp(element *v, uint32_t i)
{
    while (i != 1 && (isGreater(v[i], v[parent(i)]) || isEqual(v[i], v[parent(i)])))
    {
        int father = parent(i);

        swap(v, i, father);
        i = father;
    }
}

void moveDown(element *v, int i, uint32_t heap_size)
{
    int l, r, largest = i;
    l = left(i);
    r = right(i);

    if ((l <= heap_size) && isGreater(v[l], v[r]))
        largest = l;

    if ((r <= heap_size) && isGreater(v[r], v[largest]))
        largest = r;

    if (largest != i)
    {
        swap(v, i, largest);
        moveDown(v, largest, heap_size);
    }

    return;
}

void heapify(element *v, int heap_size)
{
    int i;
    for (i = heap_size / 2; i >= 1; i--)
        moveDown(v, i, heap_size);
}

element *deleteNode(element *v, int i, uint32_t *heap_size)
{
    if (*heap_size > 1) swap(v, 1, *heap_size);
    (*heap_size)--;
    v = realloc(v, (*heap_size + 1) * sizeof(element));
    if (*heap_size > 1) moveDown(v, 1, *heap_size);

    return v;
}

void heapsort(element *v, int dim)
{
    int i, heap_size = dim;
    for (i = dim; i >= 2; i--)
    {
        swap(v, 1, i);
        moveDown(v, 1, --heap_size);
    }
}

element *insertNode(element *v, element e, uint32_t *heap_size)
{
    (*heap_size)++;
    v = realloc(v, (*heap_size + 1) * sizeof(element));
    v[*heap_size] = e;
    moveUp(v, *heap_size);

    return v;
}

char *establishCode(int CodiceAccesso)
{
    switch (CodiceAccesso)
    {
    case 1:
        if (lang == 1) return "white"; else return "bianco";
        break;

    case 2:
        if (lang == 1) return "green"; else return "verde";
        break;

    case 3:
        if (lang == 1) return "yellow"; else return "giallo";
        break;

    case 4:
        if (lang == 1) return "red"; else return "rosso";
        break;

    case 5:
        if (lang == 1) return "blue"; else return "blu";
        break;

    default:
        if (lang == 1) return "unknown"; else return "sconosciuto";
        break;
    }
}

void printElement(element e)
{
    char *code = establishCode(e.CodiceAccesso);

    switch (lang)
    {
    case 1:
        printf(" Priority code: %s", code);
        printf("\n Name: %s", e.Nome);
        printf("\n ID: %s", e.CF);
        printf("\n Medical report: %s", e.Referto);
        printf("\n Arrived at %u \n\n", e.OraArrivo);
        break;

    case 2:
        printf(" Codice di priorita': %s", code);
        printf("\n Nome : %s", e.Nome);
        printf("\n Codice Fiscale : %s", e.CF);
        printf("\n Referto: %s", e.Referto);
        printf("\n Arrivato alle %u \n\n", e.OraArrivo);
        break;

    default:
        break;
    }
}

void quicksort(element *v, int first, int last)
{
    if (first < last)
    {
        int i = first, j = last;
        element pivot = v[(first + last) / 2];

        do
        {
            while (isGreater(v[i], pivot)) i++;
            while (isLess(v[j], pivot)) j--;
            if (i <= j)
            {
                swap(v, i, j);
                i++, j--;
            }
        } while (i <= j);

        quicksort(v, first, j);
        quicksort(v, i, last);
    }
}

void showHeap(element *v, int i, uint32_t heap_size)
{
    element *copied = copyHeap(v, heap_size);
    quicksort(copied, 1, heap_size);
    for (uint32_t i = 1; i <= heap_size; i++) printElement(copied[i]);
    free(copied);
}

void print(char *s_en, char *s_it)
{
    switch (lang)
    {
    case 1:
        printf(s_it);
        break;

    case 2:
        printf(s_en);
        break;
    }
}

int main(void)
{
    uint32_t heap_size = 0;

    printf("\n 1) English\n 2) Italiano\n\n");
    printf(" Choose your language : ");
    do { scanf("%i", &lang); } while (lang < 1 || lang > 2);

    system("cls");
    element *v = malloc(sizeof(element));
    int dest;

    do
    {
        system("cls");

        print(" ***** PAZIENTI ATTUALI *****\n\n", " ***** ACTUAL PATIENTS *****\n\n");
        if (heap_size > 0) showHeap(v, 1, heap_size);

        print("\n ****** PORTALE OSPEDALIERO ******\n\n", "\n ****** FIRST AID SERVICE ******\n\n");
        print(" 1) Inserisci un nuovo paziente\n", " 1) Insert a new patient\n");
        if (heap_size > 0) print(" 2) Servi il paziente con maggiore priorita'\n", " 2) Heal the most important patient\n");
        print(" 0) Esci\n\n", " 0) Bye bye\n\n");

        print("\n\n Seleziona la tua destinazione : ", "\n\n Choose your destination : ");
        scanf("%u", &dest);



        switch (dest)
        {
        case 1:
            system("cls");
            element e;

            print(" Inserire il nome del paziente : ", " Patient's name : "); scanf("%s", e.Nome);
            print(" Inserire il codice fiscale del paziente : ", " Patient's ID : "); scanf("%s", e.CF);
            print(" Inserire il referto del paziente : ", " Patient's medical report : "); scanf("%s", e.Referto);
            print(" Inserire il codice di accesso del paziente (da 1 a 5) : ", " Patient's priority code (from 1 to 5) : ");
            do { scanf("%hhd", &e.CodiceAccesso); } while (e.CodiceAccesso > 5);
            print(" Inserire l'ora di arrivo del paziente (da 0 e 23) : ", " Patient's arrival (from 0 to 23) : ");
            do { scanf("%u", &e.OraArrivo); } while (e.OraArrivo > 23);
            v = insertNode(v, e, &heap_size);
            break;

        case 2:
            v = deleteNode(v, 1, &heap_size);
            break;

        case 3:
            break;
        }
    } while (dest != 0);

    free(v);

    return EXIT_SUCCESS;
}