package stack

import (

"fmt"

"os"

"path/filepath"

"time"

)

const lockFileName = "gh-stack.lock"

// LockError is returned when the stack file lock cannot be acquired.

// Callers can check for this with errors.As to distinguish lock failures

// from other errors.

type LockError struct {

Err error

}

func (e *LockError) Error() string { return e.Err.Error() }

func (e *LockError) Unwrap() error { return e.Err }

// StaleError is returned when the stack file was modified on disk since it

// was loaded. This indicates another process wrote to the file concurrently.

// Callers can check for this with errors.As.

type StaleError struct {

Err error

}

func (e *StaleError) Error() string { return e.Err.Error() }

func (e *StaleError) Unwrap() error { return e.Err }

// LockTimeout is how long Lock() will wait for the exclusive lock before

// giving up. With the lock held only during file writes (milliseconds),

// this timeout primarily guards against a hung process holding the lock.

var LockTimeout = 5 * time.Second

// lockRetryInterval is the sleep between non-blocking lock attempts.

const lockRetryInterval = 100 * time.Millisecond

// FileLock provides an exclusive advisory lock on the stack file to prevent

// concurrent writes between multiple gh-stack processes.

type FileLock struct {

f *os.File

}

// Lock acquires an exclusive lock on the stack file in the given git directory.

// It retries with a non-blocking attempt every 100ms for up to LockTimeout.

//

// Most callers should not use Lock directly — stack.Save() acquires the lock

// automatically. Use Lock only when you need to hold the lock across multiple

// operations (e.g. Load-Modify-Save as an atomic unit).

func Lock(gitDir string) (*FileLock, error) {

path := filepath.Join(gitDir, lockFileName)

f, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)

if err != nil {

return nil, fmt.Errorf("opening lock file: %w", err)

}

deadline := time.Now().Add(LockTimeout)

for {

err := tryLockFile(f)

if err == nil {

return &FileLock{f: f}, nil

}

if !isLockBusy(err) {

// Unexpected error (e.g. bad fd) — don't retry.

f.Close()

return nil, fmt.Errorf("locking stack file: %w", err)

}

if time.Now().After(deadline) {

f.Close()

return nil, &LockError{Err: fmt.Errorf(

"timed out waiting for stack lock after %s — another gh-stack process may be running", LockTimeout)}

}

time.Sleep(lockRetryInterval)

}

}

// Unlock releases the lock. The lock file is intentionally left on disk to

// avoid a race where another process opens the same path, blocks on flock,

// then wakes up holding a lock on an unlinked inode while a third process

// creates a new file and locks a different inode.

func (l *FileLock) Unlock() {

if l == nil || l.f == nil {

return

}

unlockFile(l.f)

l.f.Close()

}