Full Feature Array of Struct

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

/* definisi struct */
struct inventory
{
    char namaBarang[30],
         jenis[20],
         supplier[30];

    int stok;
};

/* prototype fungsi */
void inisialisasi( struct inventory giant[] );
void clearBuffer( void );
void menu( void );
int banyakData( struct inventory giant[] );
void lihatData( struct inventory giant[] );
void urutkanNama( struct inventory giant[], struct inventory temp);
void urutkanStok( struct inventory giant[], struct inventory temp);
void cariJenis( struct inventory giant[] );
void cariStok( struct inventory tempGiant[], struct inventory temp);
int binarySearch( struct inventory giant[], int n, int stok);
void tambahData( struct inventory giant[] );
int cariIndex( struct inventory giant[], char namaBarang[], int n);
void updateStok( struct inventory giant[] );
void hapusData( struct inventory giant[] );
void simpan( struct inventory giant[] );

int main( void )
{
    /* deklarasi array bertipe struct (array of struct)
       struct tempGiant digunakan untuk melakukan operasi algoritma binary search agar data utama kita di giant tidak berubah
       karena untuk melakukan binary search harus melakukan  sorting terlebih dahulu
    */
    struct inventory giant[200],
                     tempGiant[200],
                     temp;
    int choice;
    inisialisasi( giant );

    do {
        system("clear");
        menu();
        printf("masukkan pilihan kamu [1-6] : "); scanf("%d", &choice); clearBuffer();
        if (choice == 1) lihatData( giant );
        if (choice == 2) urutkanNama( giant, temp );
        if (choice == 3) urutkanStok( giant, temp );
        if (choice == 4) cariJenis( giant );
        if (choice == 5){
            memcpy(tempGiant, giant, sizeof(giant));
            cariStok( tempGiant, temp );
        };
        if (choice == 6) tambahData( giant );
        if (choice == 7) updateStok( giant );
        if (choice == 8) hapusData( giant );
        if (choice == 9) simpan( giant );
    } while(choice != 0);

    return 0;
}

void clearBuffer( void )
{
    char ch;
    while ((ch = getchar()) != '\n' && ch != EOF);
}

void inisialisasi( struct inventory giant[] )
{
    /* buka file dengan mode read */
    FILE *inventory;
    inventory = fopen("inventory.txt", "r");
    if (!inventory)
    {
        printf("file tidak ada\n");
        exit(EXIT_FAILURE);
    }

    /* variabel untuk menentukan maks baris yg mau dibaca */
    char baris[255];
    int indeks = 0;

    /* membaca tiap baris dari file dengan maks 225 karakter tiap baris
    dari file yang ditunjuk oleh pointer inventory */
    while (fgets(baris, 255, inventory))
    {
        int i = 0;
        char delimiter[] = "|",
             data[3][20];

        /* pecah kalimat menjadi kata kata, lalu tiap kata masukkan ke variabel data*/
        char *token = strtok(baris, delimiter);
        while (token)
        {
            strcpy(data[i++], token);
            token = strtok(NULL, delimiter);
        }

        /* masukkan nilai dari variabel data ke dalam array of struct */
        strcpy(giant[indeks].namaBarang, data[0]);
        strcpy(giant[indeks].jenis, data[1]);
        strcpy(giant[indeks].supplier, data[2]);

        giant[indeks].stok = atoi(data[3]);

        /* setelah selesai memasukkan data ke baris pertama kita lalu menaikkan indeksnya
        supaya data yg berikutnya bisa disimpan di row berikutnya */
        indeks++;
    }

    /* tutup file*/
    fclose(inventory);
}

void menu( void )
{
    printf("===== GIANT INVENTORY =====\n\n");
    printf("1. Lihat Data\n");
    printf("2. Urutkan Data Nama Barang\n");
    printf("3. Urutkan Data Stok\n");
    printf("4. Cari Jenis Barang\n");
    printf("5. Cari Stok Terkecil\n");
    printf("6. Tambah Data\n");
    printf("7. Update Stok\n");
    printf("8. Hapus Data\n");
    printf("9. Simpan\n");
    printf("0. keluar\n\n");
}

int banyakData( struct inventory giant[] )
{
    int n = 0,
        i = 0;

    /* looping data nama barang sampai tidak ada karakter, jika menemukan karakter nilai i bertambah 1*/
    while (strcmp(giant[i].namaBarang,""))
        n++, i++;

    return n;
}

void lihatData( struct inventory giant[] )
{
    int n = banyakData( giant ),
        halaman = n/10, //untuk melimit data yang ditampilkan, data yang dilimit untuk ditampoilkan berjumlah 10
        sisa = n%10, //sisa data
        dataPage = 1; //halaman sekarang yang ditampilkan, dimulai dari nomor satu
    if( sisa != 0) halaman++; //jika ada sisa data maka tambahkan 1 halaman

    do {
        system("clear");
        printf("\t\t\t        *****************************\n");
        printf("\t\t\t\t*JUMLAH DATA GIANT INVENTORY*\n");
        printf("\t\t\t        *****************************\n\n");
        printf("============================================================================================\n");
        printf("%s \t\t: %s \t\t: %s \t\t: %s\t\t   |\n", "NAMA BARANG", "JENIS", "SUPPLIER", "STOK");
        printf("============================================================================================\n");
        for (int i = (dataPage*10) - 10; i < (dataPage*10); i++)
            printf("%s \t\t: %s \t\t: %s \t\t: %d\t\t   |\n", giant[i].namaBarang, giant[i].jenis, giant[i].supplier, giant[i].stok);
        printf("============================================================================================\n\n");
        printf("halaman : %d, dari total %d halaman\n", dataPage, halaman);
        printf("masukkan halaman [0 = keluar] : "); scanf("%d", &dataPage); clearBuffer();
    } while(dataPage != 0);

    printf("tekan ENTER untuk kembali ke menu..."); clearBuffer();
}

void urutkanNama( struct inventory giant[], struct inventory temp )
{
    int n = banyakData( giant ),
        i,
        j;

    /* mengapa ada variable2 temp seperti itu..? karena pada dasarnya bubble sort membandingkan dua nilai lalu di tukar(swap)
       --- proses swap apabila nilai yang sebelah kiri lebih besar dari yang kanan ---
       left -> temp (artinya nilai yang sebelah kiri dimasukkan ke tempat sementara)
       kanan -> kiri (artinya nilai yang sebelah kanan dimasukkan ke nilai yang sebelah kiri)
       temp -> kanan (artinya nilai dari tempat sementara dimasukkan ke nilai yang sebelah kiri)
    */

    // /* bubble sort */
    for ( i = 0; i < n - 1; i++ ) {
        for ( j = i + 1; j < n; j++) {
            if (strcmp(giant[i].namaBarang, giant[j].namaBarang) > 0) {
                temp = giant[j];
                giant[j] = giant[i];
                giant[i] = temp;
            }
        }
    }
}

void urutkanStok( struct inventory giant[], struct inventory temp )
{
    int n = banyakData( giant ),
        i,
        j;

    /* insertion sort */
    for (i = 1; i < n; i++) {
        temp = giant[i];

        for ( j = i; j > 0 && giant[j-1].stok > temp.stok; j--)
            giant[j] = giant[j-1];

        giant[j] = temp;
    }
}

void cariJenis( struct inventory giant[] )
{
    system("clear");
    char jenis[20];
    int n = banyakData( giant ),
        i,
        banyakKategori = 0;
    printf("masukkan jenis barang yang ingin kamu cari : "); scanf("%s", jenis); clearBuffer();
    printf("\n============================================================================================\n");
    printf("%s \t\t: %s \t\t: %s \t\t: %s\t\t   |\n", "NAMA BARANG", "JENIS", "SUPPLIER", "STOK");
    printf("============================================================================================\n");

    /* linear search */
    /* looping seluruh data, apabila ditemukan data yang dicari langsung tampilkan */
    for ( i = 0; i < n; i++) {
        if (strcmp(giant[i].jenis, jenis) == 0){
            printf("%s \t\t: %s \t\t: %s \t\t: %d\t\t   |\n", giant[i].namaBarang, giant[i].jenis, giant[i].supplier, giant[i].stok);
            banyakKategori++;
        }
    }
    if (banyakKategori == 0)
        printf("kategori yang anda cari tidak ada\n");
    printf("============================================================================================\n\n");
    printf("\ntekan ENTER untuk kembali ke menu..."); clearBuffer();
}

void cariStok( struct inventory tempGiant[], struct inventory temp )
{
    system("clear");
    int stok,
        end = banyakData(tempGiant),
        maks,
        j;
    printf("masukkan stok maksimal yang ingin dicari : "); scanf("%d", &stok); clearBuffer();
    urutkanStok( tempGiant, temp ); //sorting stok array of struct tempGiant
    /* binary search */
    maks = binarySearch( tempGiant, end, stok); //variabel maks menampung nilai kembalian dari fungsi binary search

    printf("\n============================================================================================\n");
    printf("%s \t\t: %s \t\t: %s \t\t: %s\t\t   |\n", "NAMA BARANG", "JENIS", "SUPPLIER", "STOK");
    printf("============================================================================================\n");
    for (j = 0; j <= maks; j++)
        printf("%s \t\t: %s \t\t: %s \t\t: %d\t\t   |\n", tempGiant[j].namaBarang, tempGiant[j].jenis, tempGiant[j].supplier, tempGiant[j].stok);
    printf("============================================================================================\n");
    if (maks < 0)
        printf("stok yang anda cari tidak ada\n");
    printf("tekan ENTER untuk kembali ke menu..."); clearBuffer();
}

int binarySearch( struct inventory tempGiant[], int end, int stok)
{
    int start = 0;

    while(start < end)
    {
        int mid = (start + end) / 2;
        if (tempGiant[mid].stok == stok) {
            return mid;
        } else if (tempGiant[mid].stok < stok) {
            start = mid + 1;
        } else {
            end = mid;
        }
    }

    return -1;
}

void tambahData( struct inventory giant[] )
{
    int n = banyakData( giant ); //indeks terakhir

    /* semuanya non validasi, silahkan tambahkan validasi sendiri*/
    printf("\nmasukkan nama barang : "); scanf("%[^\n]", giant[n].namaBarang); clearBuffer();
    printf("masukkan kategori barang : "); scanf("%[^\n]", giant[n].jenis); clearBuffer();
    printf("masukkan supplier : "); scanf("%[^\n]", giant[n].supplier); clearBuffer();
    printf("masukkan stok : "); scanf("%d", &giant[n].stok); clearBuffer();

    printf("\ndata berhasil ditambahkan\n");
    printf("tekan ENTER untuk melanjutkan..."); clearBuffer();
}

int cariIndex( struct inventory giant[], char namaBarang[], int n)
{
    int indeks;

    //looping sampai ketemu nama barang yang dicari, apabila ditemukan kembalikan indeksnya
    for ( indeks = 0; indeks < n; indeks++)
        if (strcmp(giant[indeks].namaBarang, namaBarang) == 0)
            return indeks;

    return -1;
}

void updateStok( struct inventory giant[] )
{
    char namaBarang[30];
    int posisi,
        n = banyakData( giant );

    do {
        printf("masukkan nama barang : "); scanf("%[^\n]", namaBarang); clearBuffer();
        posisi = cariIndex( giant, namaBarang, n);
        if (posisi < 0) printf("nama barang tidak ditemukan\n");
    } while(posisi < 0);
    printf("stok %s saat ini : %d\n", namaBarang, giant[posisi].stok);
    printf("masukkan stok barang : "); scanf("%d", &giant[posisi].stok); clearBuffer(); //non validasi

    printf("\nstok %s berhasil diupdate\n", namaBarang);
    printf("tekan ENTER untuk melanjutkan..."); clearBuffer();
}

void hapusData( struct inventory giant[] )
{
    char namaBarang[30];
    int posisi,
        n = banyakData( giant );

    do {
        printf("masukkan nama barang : "); scanf("%[^\n]", namaBarang); clearBuffer();
        posisi = cariIndex( giant, namaBarang, n);
        if (posisi < 0) printf("nama barang tidak ditemukan\n");
    } while(posisi < 0);

    for (int i = posisi; i <= n-1; i++)
        giant[i] = giant[i+1];

    printf("\ndata berhasil dihapus\n");
    printf("tekan ENTER untuk melanjutkan..."); clearBuffer();
}

void simpan( struct inventory giant[] )
{
    /* buka file dengan mode write */
    FILE *inventory;
    inventory = fopen("inventory.txt", "w");
    if (!inventory)
    {
        printf("file tidak ada\n");
        exit(EXIT_FAILURE);
    }

    /* memasukkan data maksimal perbaris sebanyak 255 karakter*/
    char baris[255];
    int n = banyakData( giant );

    /* masukkan data dari array of struct ke file */
    for (int i = 0; i < n; i++)
    {
        sprintf(baris, "%s|%s|%s|%d\n", giant[i].namaBarang, giant[i].jenis, giant[i].supplier, giant[i].stok);
        fputs(baris, inventory);
    }

    /* tutup file*/
    fclose(inventory);
}