package main

import (
	"fmt"
	"io"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/kawasin73/gointr"
)

// lock locks file using FCNTL.
func lock(file *os.File) error {
	// write lock whole file
	flock := syscall.Flock_t{
		Start:  0,
		Len:    0,
		Type:   syscall.F_WRLCK,
		Whence: io.SeekStart,
	}

	if err := syscall.FcntlFlock(file.Fd(), syscall.F_SETLKW, &flock); err != nil {
		// FCNTL returns EINTR if interrupted by signal on blocking mode
		if err == syscall.EINTR {
			return fmt.Errorf("file lock timeout for %q", file.Name())
		}
		return &os.PathError{Op: "fcntl", Path: file.Name(), Err: err}
	}
	return nil
}

func main() {
	signal.Ignore()

	file, err := os.Create("./.lock")
	if err != nil {
		log.Panic(err)
	}

	// init pthread
	intr := gointr.New(syscall.SIGUSR1)

	// init error channel
	chErr := make(chan error, 1)

	// setup timer
	timer := time.NewTimer(3 * time.Second)

	go func() {
		// setup the thread signal settings
		if terr := intr.Setup(); terr != nil {
			chErr <- terr
			return
		}
		defer func() {
			// reset signal settings
			if terr := intr.Close(); terr != nil {
				// if failed to reset sigaction, go runtime will be broken.
				// terr occurs on C memory error which does not happen.
				panic(terr)
			}
		}()
		// lock file blocking
		chErr <- lock(file)
	}()

	for {
		select {
		case err = <-chErr:
			timer.Stop()
			if err == nil {
				log.Println("lock success")
			} else {
				log.Println("lock fail err", err)
			}
			// break loop
			return

		case <-timer.C:
			log.Println("timeout")

			// send signal to the thread locking file and unblock the lock with EINTR
			err := intr.Signal()
			log.Println("signal")
			if err != nil {
				log.Panic("failed to kill thread", err)
			}
			// wait for lock result from chErr
		}
	}
}