package main

/*
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

// Helper function to get the current errno value
int get_errno() {
    return errno;
}

// Function to initialize a mutex as process-shared
int setupMutex(void* addr) {
    pthread_mutexattr_t attr;
    pthread_mutex_t* mutex = (pthread_mutex_t*) addr;

    if (pthread_mutexattr_init(&attr)) {
        perror("Mutex attribute init failed");
        return -1;
    }

    if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)) {
        perror("Setting pshared failed");
        pthread_mutexattr_destroy(&attr);
        return -1;
    }

    if (pthread_mutex_init(mutex, &attr)) {
        perror("Mutex init failed");
        pthread_mutexattr_destroy(&attr);
        return -1;
    }

    pthread_mutexattr_destroy(&attr);
    return 0;
}

// Function to create shared memory with error handling
int createSharedMemory(key_t key, size_t size) {
    int shmid = shmget(key, size, IPC_CREAT | 0666);
    if (shmid == -1) {
        fprintf(stderr, "Failed to create/find shared memory: %s\n", strerror(errno));
    }
    return shmid;
}
*/
import "C"

import (
    "log"
    "sync"
    "sync/atomic"
    "time"
    "unsafe"
)

var (
    lockUnlockCount int64
    reportFrequency = time.Second
)

func main() {
    path := C.CString("/dev/null") // Use an accessible path on your system
    defer C.free(unsafe.Pointer(path))
    id := C.int(123) // Arbitrary project identifier

    key := C.ftok(path, id)
    if key == -1 {
        log.Fatalf("ftok failed: %s", C.GoString(C.strerror(C.get_errno())))
    }

    size := C.size_t(unsafe.Sizeof(C.pthread_mutex_t{}))
    shmid := C.createSharedMemory(key, size)
    if shmid < 0 {
        log.Fatal("Exiting due to previous error.")
    }

    shmaddr := C.shmat(shmid, nil, 0)
    if shmaddr == nil {
        log.Fatalf("Failed to attach shared memory: %s", C.GoString(C.strerror(C.get_errno())))
    }
    defer C.shmdt(shmaddr)

    if C.setupMutex(shmaddr) != 0 {
        log.Fatalf("Failed to setup mutex")
    }

    var wg sync.WaitGroup
    go reportLockUnlockOperations()

    const numGoroutines = 100
    wg.Add(numGoroutines)

    for i := 0; i < numGoroutines; i++ {
        go func() {
            defer wg.Done()
            for {
                if C.pthread_mutex_lock((*C.pthread_mutex_t)(shmaddr)) != 0 {
                    log.Println("Failed to lock mutex")
                    continue
                }
                atomic.AddInt64(&lockUnlockCount, 1)
                if C.pthread_mutex_unlock((*C.pthread_mutex_t)(shmaddr)) != 0 {
                    log.Println("Failed to unlock mutex")
                    continue
                }
            }
        }()
    }

    wg.Wait()
}

func reportLockUnlockOperations() {
    for range time.Tick(reportFrequency) {
        count := atomic.SwapInt64(&lockUnlockCount, 0)
        log.Printf("Lock-unlock operations per second: %d", count)
    }
}