//go:build !windows

package singleinstance

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"syscall"

	"voicesnap/internal/paths"
)

type unixLock struct {
	file *os.File
}

// Acquire tries to acquire a file lock. Returns error if another instance holds it.
func Acquire() (Lock, error) {
	lockPath := filepath.Join(os.TempDir(), "privatevoice-input.lock")
	if ensureErr := paths.Ensure(); ensureErr != nil {
		return nil, fmt.Errorf("ensure app lock dir: %w", ensureErr)
	}
	appLockPath := paths.File("privatevoice-input.lock")
	return acquireWithFallback(lockPath, appLockPath)
}

func acquireWithFallback(primaryPath, fallbackPath string) (Lock, error) {
	lock, err := acquirePath(primaryPath)
	if err == nil {
		return lock, nil
	}

	var unavailable lockUnavailableError
	if errors.As(err, &unavailable) {
		return nil, err
	}

	lock, fallbackErr := acquirePath(fallbackPath)
	if fallbackErr != nil {
		return nil, fmt.Errorf("acquire temp lock: %w; acquire app lock: %v", err, fallbackErr)
	}
	return lock, nil
}

type lockOpenError struct {
	path string
	err  error
}

func (e lockOpenError) Error() string {
	return fmt.Sprintf("open lock %s: %v", e.path, e.err)
}

func (e lockOpenError) Unwrap() error {
	return e.err
}

type lockAccessError struct {
	path string
	err  error
}

func (e lockAccessError) Error() string {
	return fmt.Sprintf("lock %s: %v", e.path, e.err)
}

func (e lockAccessError) Unwrap() error {
	return e.err
}

type lockUnavailableError struct {
	path string
	err  error
}

func (e lockUnavailableError) Error() string {
	return fmt.Sprintf("another instance is already running: %s", e.path)
}

func (e lockUnavailableError) Unwrap() error {
	return e.err
}

func acquirePath(lockPath string) (Lock, error) {
	f, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0600)
	if err != nil {
		return nil, lockOpenError{path: lockPath, err: err}
	}

	err = syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
	if err != nil {
		f.Close()
		if errors.Is(err, syscall.EWOULDBLOCK) || errors.Is(err, syscall.EAGAIN) {
			return nil, lockUnavailableError{path: lockPath, err: err}
		}
		return nil, lockAccessError{path: lockPath, err: err}
	}

	return &unixLock{file: f}, nil
}

func (l *unixLock) Release() {
	if l.file != nil {
		syscall.Flock(int(l.file.Fd()), syscall.LOCK_UN)
		l.file.Close()
		l.file = nil
	}
}