gym-tracker/app.cpp

#include <math.h>
#include <memory.h>
#include <time.h>
#include "./djstdlib/core.cpp"

const string LOG_FILE_LOCATION = "./log.gtl"_s;
const string DB_FILE_LOCATION = "./db.gtd"_s;

struct GymLogDbHeader {
    uint32 nextId;
};

struct GymLogDbEntry {
    uint32 id;
    uint32 nameLength;
};

struct GymLogDbParsedEntry {
    uint32 id;
    string name;
};

typedef GymLogDbParsedEntry Exercise;

struct GymLogDbParsed {
    GymLogDbHeader header;
    list<GymLogDbParsedEntry> entries;
};

struct WeightRepsInfo {
    uint8 reps;
    real32 weight;
};

struct GymLogEntry {
    uint64 timestamp;
    uint32 exerciseId;
    union {
        WeightRepsInfo weightRepsInfo;
    };
};

struct WorkSummary {
    real32 totalWork;
    uint32 restTime;
};

GymLogDbParsed *parseDb(Arena *arena, string database) {
    GymLogDbParsed *dbParsed = PushStruct(arena, GymLogDbParsed);

    dbParsed->header = *((GymLogDbHeader *)database.str);

    size_t head = sizeof(GymLogDbHeader);
    uint32 entriesLeft = dbParsed->header.nextId - 1;
    dbParsed->entries = PushList(arena, GymLogDbParsedEntry, entriesLeft);

    while (entriesLeft > 0 && head < database.length) {
        GymLogDbEntry *currentEntry = (GymLogDbEntry *)((byte *)database.str + head);
        GymLogDbParsedEntry parsedEntry = { currentEntry->id, PushString(arena, currentEntry->nameLength) };
        head += sizeof(GymLogDbEntry);
        memcpy(parsedEntry.name.str, database.str + head, currentEntry->nameLength);
        appendList(&dbParsed->entries, parsedEntry);
        head += currentEntry->nameLength;
    }

    return dbParsed;
}

list<GymLogEntry> loadEntryLog(Arena *arena, string fileLocation) {
    list<GymLogEntry> result = {0};
    string logfile = os_readEntireFile(arena, LOG_FILE_LOCATION);

    if (logfile.length % sizeof(GymLogEntry) != 0) {
        log("Log file corrupted.\n");
    } else {
        size_t entryCount = logfile.length / sizeof(GymLogEntry);
        result = { (GymLogEntry *)logfile.str, entryCount, entryCount };
    }

    return result;
}

WorkSummary workSummaryForExercise(list<GymLogEntry> entries, Exercise exercise) {
    WorkSummary result = {0};
    UnixTimestamp lastTimestamp = 0;
    for (EachInReversed(entries, i)) {
        if (entries.data[i].exerciseId == exercise.id) {
            GymLogEntry logEntry = entries.data[i];
            result.totalWork += logEntry.weightRepsInfo.weight * logEntry.weightRepsInfo.reps;
            if (lastTimestamp > 0) {
                result.restTime += (uint32)(lastTimestamp - logEntry.timestamp);
            }
            lastTimestamp = logEntry.timestamp;
        }
    }
    
    return result;
}

int gymTrackerLogWorkToday(Arena *arena, Exercise exercise) {
    int statusCode = 0;
    string logfile = os_readEntireFile(arena, LOG_FILE_LOCATION);

    if (logfile.length % sizeof(GymLogEntry) != 0) {
        log("Log file corrupted.\n");
        statusCode = 1;
    } else {
        size_t entryCount = logfile.length / sizeof(GymLogEntry);
        list<GymLogEntry> logEntries = { (GymLogEntry *)logfile.str, entryCount, entryCount };

        UnixTimestamp todayUnix = getSystemUnixTime();
        Timestamp todayTs = timestampFromUnixTime(&todayUnix);
        list<GymLogEntry> todaysEntries = {0};
        todaysEntries.data = logEntries.data;
        for (EachInReversed(logEntries, i)) {
            GymLogEntry logEntry = logEntries.data[i];
            Timestamp logTs = timestampFromUnixTime(&logEntry.timestamp);
            if (logTs.tm_yday == todayTs.tm_yday && todayTs.tm_year == logTs.tm_year) {
                todaysEntries.head += 1;
                todaysEntries.data = &logEntries.data[i];
            }
        }

        if (todaysEntries.data) {
            todaysEntries.length = todaysEntries.head;
            WorkSummary summary = workSummaryForExercise(todaysEntries, exercise);
            log("Total work today for %S:\n%.2fkg in ~%.2fmin.\n", exercise.name, summary.totalWork, (real32)summary.restTime / 60.0f);
        }
        
    }

    return statusCode;
}

int gymTrackerStatus(Arena *arena, list<string> args) {
    int statusCode = 0;
    string file = os_readEntireFile(arena, LOG_FILE_LOCATION);

    if (file.length % sizeof(GymLogEntry) != 0) {
        puts("Log file corrupted.");
        statusCode = 1;
    } else {
        GymLogDbParsed *db = parseDb(arena, os_readEntireFile(arena, DB_FILE_LOCATION));

        Timestamp startTs = {0};
        ParsePositiveIntResult numDays = {1, true};
        bool showAll = args.length == 1 && strEql(args.data[0], "--all"_s);
        if (!showAll) {
            if (args.length == 2 && (strEql(args.data[0], "--days"_s) || strEql(args.data[0], "-d"_s))) {
                size_t l;
                numDays = parsePositiveInt(args.data[1], &l);
            }
            if (!numDays.valid) {
                puts("Bad argument for --days (-d) parameter.");
                statusCode = 1;
            } else {
                uint64 todayUnix = getSystemUnixTime();
                UnixTimestamp startUnix = todayUnix - numDays.result * 24 * 60 * 60;
                startTs = timestampFromUnixTime(&startUnix);
            }
        }

        if (statusCode == 0) {
            int lastDay = -1;
            int lastYear = -1;
            size_t entryCount = file.length / sizeof(GymLogEntry);
            list<GymLogEntry> logEntries = { (GymLogEntry *)file.str, entryCount, entryCount };

            list<string> nameByExercise = PushFullListZero(arena, string, db->header.nextId);

            list<real32> workPerExerciseByDay = PushFullListZero(arena, real32, db->header.nextId);
            list<real32> workPerExerciseByPrevDay = PushFullListZero(arena, real32, db->header.nextId);
            list<uint32> restPerExerciseByDay = PushFullListZero(arena, uint32, db->header.nextId);
            list<uint32> lastTsPerExerciseByDay = PushFullListZero(arena, uint32, db->header.nextId);

            int dayCount = 0;

            Timestamp timestamp = {0};

            GymLogEntry *prevEntry = 0;
            GymLogEntry *entry = 0;
            for (EachIn(logEntries, i)) {
                prevEntry = entry;
                entry = &logEntries.data[i];

                timestamp = timestampFromUnixTime(&entry->timestamp);

                if (timestamp.tm_year < startTs.tm_year || timestamp.tm_yday < startTs.tm_yday) {
                    continue;
                }

                if (timestamp.tm_yday != lastDay || timestamp.tm_year != lastYear) {
                    if (dayCount > 0) {
                        log("\n");
                    }
                    log("================ %S ===================\n", formatTimeYmd(arena, &timestamp));
                    lastDay = timestamp.tm_yday;
                    lastYear = timestamp.tm_year;
                    dayCount++;
                }

                workPerExerciseByDay.data[entry->exerciseId] += entry->weightRepsInfo.reps * entry->weightRepsInfo.weight;
                uint32 lastTsForExercise = lastTsPerExerciseByDay.data[entry->exerciseId];
                if (lastTsForExercise > 0) {
                    restPerExerciseByDay.data[entry->exerciseId] += (uint32)(entry->timestamp - lastTsForExercise);
                }
                lastTsPerExerciseByDay.data[entry->exerciseId] = (uint32)entry->timestamp;

                const char *format;
                if (entry->weightRepsInfo.weight == (int32)entry->weightRepsInfo.weight) {
                    format = "%S: %S %.0fkg X %i\n";
                } else {
                    format = "%S: %S %.2fkg X %i\n";
                }

                string *exerciseName = &(nameByExercise.data[entry->exerciseId]);
                if (exerciseName->str == 0) {
                    for (EachIn(db->entries, j)) {
                        GymLogDbParsedEntry dbEntry = db->entries.data[j];
                        if (dbEntry.id == entry->exerciseId) {
                            *exerciseName = dbEntry.name;
                        }
                    }
                }

                string nameToPrint = {0};
                if (prevEntry && entry->exerciseId == prevEntry->exerciseId) {
                    nameToPrint = PushStringFill(arena, exerciseName->length, '.');
                } else {
                    nameToPrint = exerciseName->str ? *exerciseName : "unknown-exercise"_s;
                    log("\n");
                }
                log(format, 
                        formatTimeHms(arena, &timestamp), 
                        nameToPrint,  
                        entry->weightRepsInfo.weight, 
                        entry->weightRepsInfo.reps);

                Timestamp nextTimestamp = {0};
                if (i < logEntries.head - 1) {
                    nextTimestamp = timestampFromUnixTime(&logEntries.data[i + 1].timestamp);
                }

                if (i == logEntries.head + 1 || nextTimestamp.tm_yday != lastDay || nextTimestamp.tm_year != lastYear) {
                    log("\n");
                    log("Work summary:\n");
                    for (size_t j = 0; j < workPerExerciseByDay.length; j++) {
                        if (workPerExerciseByDay.data[j] != 0.0f) {
                            const char *fmtString;
                            real32 improvement = 0;
                            real32 workToday = workPerExerciseByDay.data[j];
                            real32 workLastTime = workPerExerciseByPrevDay.data[j];
                            if (workPerExerciseByPrevDay.data[j] == 0) {
                                fmtString = COLOR_TEXT("%S", ANSI_fg_cyan) ": %.2fkg in %.2fmin\n";
                            } else {
                                improvement = workToday - workLastTime;
                                if (improvement > 0) {
                                    fmtString = COLOR_TEXT("%S", ANSI_fg_cyan) ": %.2fkg in %.2fmin " COLOR_TEXT("+%.2fkg (+%.2f%%)\n", ANSI_fg_green);
                                } else if (improvement < 0) {
                                    fmtString = COLOR_TEXT("%S", ANSI_fg_cyan) ": %.2fkg in %.2fmin " COLOR_TEXT("%.2fkg (%.2f%%)\n", ANSI_fg_red);
                                } else {
                                    fmtString = COLOR_TEXT("%S", ANSI_fg_cyan) ": %.2fkg in %.2fmin " COLOR_TEXT("(no change)\n", ANSI_fg_yellow);
                                }
                            }

                            log(fmtString, nameByExercise.data[j], workToday, (real32)restPerExerciseByDay.data[j] / 60.0f, improvement, improvement / workLastTime * 100);

                            workPerExerciseByPrevDay.data[j] = workToday;
                        }
                    }
                    zeroListFull(&workPerExerciseByDay);
                    zeroListFull(&restPerExerciseByDay);
                    zeroListFull(&lastTsPerExerciseByDay);
                    prevEntry = 0;
                    entry = 0;
                }
            }
        }
    }

    return statusCode;
}

int gymTrackerDeleteEntries(Arena *arena, list<string> args) {
    int statusCode = 0;

    if (args.length == 0) {
        log("Please pass the number of entries to delete starting from the most recent.");
        statusCode = 1;
    } else {
        size_t position = 0;
        ParsePositiveIntResult numToDeleteParsed = parsePositiveInt(args.data[0], &position);
        if (numToDeleteParsed.valid) {
            list<GymLogEntry> logEntries = loadEntryLog(arena, LOG_FILE_LOCATION);
            if (numToDeleteParsed.result > logEntries.length) {
                log("%i is more than the current number of log entries (%i). Aborting.", numToDeleteParsed, logEntries.length);
                statusCode = 1;
            } else {
                os_writeEntireFile(arena, LOG_FILE_LOCATION, (byte *)logEntries.data, (logEntries.length - numToDeleteParsed.result) * sizeof(GymLogEntry));
            }
        } else {
            log("Invalid number to delete.\n");
            statusCode = 0;
        }
    }

    return statusCode;
}

// Syntax: do <exercise-name> weightKg reps
int gymTrackerDo(Arena *arena, list<string> args) {
    int statusCode = 0;
    Exercise exercise = {};

    if (args.length < 3 || args.data[0].length == 0) {
        log("Invalid exercise name and/or number of arguments.\n");
        statusCode = 1;
    } else {
        exercise.name = args.data[0];
    }

    GymLogDbParsedEntry *existingEntry = 0;

    if (statusCode == 0) {
        GymLogDbParsed *db = parseDb(arena, os_readEntireFile(arena, DB_FILE_LOCATION));
        for (EachIn(db->entries, i)) {
            GymLogDbParsedEntry entry = db->entries.data[i];
            if (strStartsWith(entry.name, exercise.name)) {
                existingEntry = &entry; 
                if (entry.name.length != exercise.name.length) {
                    exercise.name = entry.name;
                    log("Assuming exercise \"%S\".\n\n", entry.name);
                }
                break;
            }
        }
        if (!existingEntry) {
            log("The exercise \"%S\" hasn't been registered.", exercise.name);
            statusCode = 1;
        }
    }

    if (statusCode == 0) {
        exercise.id = existingEntry->id;
        size_t parsedCount = 0;
        ParsePositiveReal32Result kg = parsePositiveReal32(args.data[1], &parsedCount);
        ParsePositiveIntResult reps = parsePositiveInt(args.data[2], &parsedCount);
        if (!kg.valid || !reps.valid) {
            log("%zu, %f, %\n", parsedCount, kg, reps);
            log("Invalid reps or weight input.\n");
            statusCode = 1;
        } else {
            GymLogEntry entry = {
                getSystemUnixTime(),
                exercise.id,
                {
                    reps.result,
                    kg.result,
                },
            };

            os_fileAppend(arena, LOG_FILE_LOCATION, (byte *)&entry, sizeof(entry));
            statusCode = gymTrackerLogWorkToday(arena, exercise);
        }
    }

    return statusCode;
}

int gymTrackerListExercises(Arena *arena, list<string> args) {
    int statusCode = 0;
    GymLogDbParsed *db = parseDb(arena, os_readEntireFile(arena, DB_FILE_LOCATION));

    if (db->entries.length == 0) {
        log("No entries currently registered in the exercise database.");
    } else {
        log("%i entries currently registered in the exercise database:\n\n", db->entries.length);
        for (EachIn(db->entries, i)) {
            log("#%i: %S\n", i + 1, db->entries.data[i].name);
        }
    }

    return statusCode;
}

int gymTrackerAddExercise(Arena *arena, list<string> args) {
    int statusCode = 0;

    string newExerciseName = args.data[0];
    if (newExerciseName.length == 0) {
        log("No exercise name provided.\n");
        statusCode = 1;
    }

    if (statusCode != 1) {
        string database = os_readEntireFile(arena, DB_FILE_LOCATION);

        byte *buf = 0; 
        size_t newEntryStartIndex = 0;

        if (database.length == 0) {
            // Initialise DB
            newEntryStartIndex = sizeof(GymLogDbHeader);
            buf = PushArray(arena, byte, sizeof(GymLogDbHeader) + sizeof(GymLogDbEntry) + newExerciseName.length);
            GymLogDbHeader *header = (GymLogDbHeader *)buf;
            header->nextId = 1;
        } else {
            // Validate entry not already present
            bool invalid = false;
            GymLogDbHeader *header = (GymLogDbHeader *)database.str;
            size_t head = sizeof(GymLogDbHeader);
            uint32 entriesLeft = header->nextId - 1;
            while (entriesLeft > 0 && head < database.length) {
                GymLogDbEntry *currentEntry = (GymLogDbEntry *)((byte *)database.str + head);
                head += sizeof(GymLogDbEntry);
                string entryName = {(char *)((byte *)database.str + head), currentEntry->nameLength };
                if (strEql(entryName, newExerciseName)) {
                    invalid = true;
                    log("Exercise \"%S\" already registered (entry #%i)\n", entryName, currentEntry->id);
                    break;
                }
                head += currentEntry->nameLength;
            }

            if (!invalid) {
                newEntryStartIndex = database.length;
                buf = PushArray(arena, byte, database.length + sizeof(GymLogDbEntry) + newExerciseName.length);
                memcpy(buf, database.str, database.length);
            } else {
                statusCode = 1;
            }
        }

        if (statusCode != 1) {
            // Add entry
            GymLogDbHeader *header = (GymLogDbHeader *)buf;
            GymLogDbEntry *entry = (GymLogDbEntry *)(buf + newEntryStartIndex); 
            entry->id = header->nextId;
            entry->nameLength = (uint32)newExerciseName.length;
            header->nextId++;
            byte *newExerciseNameDb = buf + newEntryStartIndex + sizeof(GymLogDbEntry);
            memcpy(newExerciseNameDb, newExerciseName.str, newExerciseName.length);
            size_t bufSize = newEntryStartIndex + sizeof(GymLogDbEntry) + newExerciseName.length;
            os_writeEntireFile(arena, DB_FILE_LOCATION, buf, bufSize);
        }
    }

    return statusCode;
}

int main(int argc, char **argv) {
    initialiseCore();
    Arena *arena = arenaAlloc(Megabytes(64));
    list<string> args = getArgs(arena, argc, argv);
    int statusCode = 0;

    if (args.length < 1) {
        log("At least one arg is required.\n");
        statusCode = 1;
    }

    if (statusCode == 0) {
        string cmd = args.data[0];
        list<string> argsRest = listSlice(args, 1);

        if (strEql("status"_s, cmd)) {
            statusCode = gymTrackerStatus(arena, argsRest);
        } else if (strEql("do"_s, cmd)) {
            statusCode = gymTrackerDo(arena, argsRest);
        } else if (strEql("delete"_s, cmd)) {
            statusCode = gymTrackerDeleteEntries(arena, argsRest);
        } else if (strEql("list"_s, cmd)) {
            statusCode = gymTrackerListExercises(arena, argsRest);
        } else if (strEql("add"_s, cmd)) {
            statusCode = gymTrackerAddExercise(arena, argsRest);
        } else {
            log("Unknown command \"%S\"\n", args.data[0]);
            statusCode = 1;
        }
    }

    return statusCode;
}