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

enum { Cmd, Itm, Val };

void *items_new();
void *items_load(const char *);
void items_save(void *, const char *);
int items_do(void **, const char **);
int bsrch(const void *, const void *, size_t, size_t,
          int (*)(const void *, const void *));

int main(int argc, char **argv)
{
    void *items = items_load(argv[1]);

    if (argv[2+Cmd][0] == 'i')
    {
        while (1)
        {
            char cmd[0x40],
                 itm[0x40],
                 val[0x40],
                 *args[] = {cmd, itm, val};

            scanf("%s", cmd);
            if (cmd[0] == '+' || cmd[0] == '-') {
                scanf("%s", itm);
                scanf("%s", val);
            }
            if (items_do(&items, args)) break;
        }
    }
    else items_do(&items, argv + 2);

    items_save(items, argv[1]);
}

#define SZREALLOC 0x40

typedef struct {
    char name[0x40];
    int32_t val;
} item_t;

typedef struct {
    int32_t num;
    item_t item[];
} items_t;

void *items_new()
{
    return calloc(1, sizeof(items_t));
}

void *items_load(const char *path)
{
    FILE *file = fopen(path, "r");

    if (!file) return items_new();

    int32_t nitems;
    fread(&nitems, sizeof(int32_t), 1, file);

    int nalloc = nitems + (-nitems % SZREALLOC);
    items_t *items = malloc(sizeof(items_t) + nalloc * sizeof(item_t));

    items->num = nitems;
    fread(items->item, sizeof(item_t), nitems, file);

    fclose(file);

    return items;
}

void items_save(void *_items, const char *path)
{
    items_t *items = _items;

    FILE *file = fopen(path, "w");
    fwrite(&items->num, sizeof(int32_t), 1, file);
    fwrite(items->item, sizeof(item_t), items->num, file);
    fclose(file);
}

int items_do(void **pitems, const char **args)
{
    items_t *items = *pitems;

    const char *cmd = args[Cmd],
               *itm = args[Itm],
               *val = args[Val];

    switch (cmd[0]) {
    case '+': case '-': {
        int idx = bsrch(itm, items->item, items->num, sizeof(item_t), strcmp);
        if (strcmp(items->item[idx].name, itm))
        {
            if (items->num % SZREALLOC == 0)
            {
                int nalloc = items->num + SZREALLOC;
                items = realloc(items,
                                sizeof(items_t) + nalloc * sizeof(item_t));
                *pitems = items;
            }
            size_t nbytes = (items->num++ - idx) * sizeof(item_t);
            memmove(items->item + idx + 1, items->item + idx, nbytes);
            strcpy(items->item[idx].name, itm);
            items->item[idx].val = 0;
        }
        items->item[idx].val += cmd[0] == '+' ? atoi(val) : -atoi(val);
        return 0;
    }
    case 'l':
        for (int i = 0; i < items->num; ++i)
            printf("%-64s - %12d\n", items->item[i].name, items->item[i].val);
        return 0;
    default:
        return -1;
    }
}

int bsrch(const void *key, const void *_base,
           size_t num, size_t sz, int (*cmp)(const void *, const void *))
{
    const char (*base)[sz] = _base;

    int l = 0, r = num, m, c;
    while (l < r) {
        m = (l + r) / 2;
        c = cmp(key, base[m]);
        if (c == 0) return m;
        if (c < 0) r = m;
              else l = m + 1;
    }
    return l;
}