import os
import os.filelock
import time

const test_dir = os.join_path(os.vtmp_dir(), 'filelock_tests')

const helper_mode_env = 'V_FILELOCK_HELPER_MODE'
const helper_path_env = 'V_FILELOCK_HELPER_PATH'
const helper_lock_mode_env = 'V_FILELOCK_LOCK_MODE'
const helper_start_env = 'V_FILELOCK_START'
const helper_len_env = 'V_FILELOCK_LEN'

fn testsuite_begin() {
    if os.getenv(helper_mode_env) != '' {
        run_helper_process()
    }
    os.mkdir_all(test_dir) or {}
}

fn testsuite_end() {
    os.rmdir_all(test_dir) or {}
}

fn run_helper_process() {
    path := os.getenv(helper_path_env)
    lock_mode := if os.getenv(helper_lock_mode_env) == 'shared' {
        filelock.LockMode.shared
    } else {
        filelock.LockMode.exclusive
    }
    start := os.getenv(helper_start_env).u64()
    len := os.getenv(helper_len_env).u64()
    mut file_lock := filelock.new_file(path, filelock.LockOptions{
        mode:  lock_mode
        start: start
        len:   len
    })
    match os.getenv(helper_mode_env) {
        'hold' {
            file_lock.acquire() or {
                eprintln(err.msg())
                exit(2)
            }
            println('locked')
            os.flush()
            time.sleep(300 * time.millisecond)
            file_lock.release()
            exit(0)
        }
        'try' {
            exit(if file_lock.try_acquire() {
                file_lock.release()
                0
            } else {
                1
            })
        }
        else {
            exit(3)
        }
    }
}

fn helper_path(name string) string {
    return os.join_path(test_dir, name)
}

fn new_helper_process(path string, lock_mode filelock.LockMode, start u64, len u64, mode string) &os.Process {
    mut p := os.new_process(os.executable())
    mut env := os.environ()
    env[helper_mode_env] = mode
    env[helper_path_env] = path
    env[helper_lock_mode_env] = lock_mode.str()
    env[helper_start_env] = start.str()
    env[helper_len_env] = len.str()
    p.set_environment(env)
    p.set_redirect_stdio()
    return p
}

fn wait_for_lock(mut p os.Process) {
    mut output := ''
    for _ in 0 .. 50 {
        if p.is_pending(.stdout) {
            output += p.stdout_read()
            if output.contains('locked') {
                return
            }
        }
        if !p.is_alive() {
            break
        }
        time.sleep(10 * time.millisecond)
    }
    p.wait()
    stderr := p.stderr_slurp().trim_space()
    assert false, 'helper failed to acquire lock; exit=${p.code} stdout="${output.trim_space()}" stderr="${stderr}"'
}

fn try_lock_from_helper(path string, lock_mode filelock.LockMode, start u64, len u64) int {
    mut p := new_helper_process(path, lock_mode, start, len, 'try')
    p.run()
    p.wait()
    stderr := p.stderr_slurp().trim_space()
    code := p.code
    p.close()
    assert stderr == ''
    return code
}

fn test_flock() {
    lockfile := helper_path('test.lock')
    os.rm(lockfile) or {}
    mut l := filelock.new(lockfile)
    assert !os.exists(lockfile)
    l.acquire() or { panic(err) }
    assert os.exists(lockfile)
    l.release()
    assert !os.exists(lockfile)
}

fn test_flock_try() {
    lockfile := helper_path('test-try.lock')
    os.rm(lockfile) or {}
    mut l := filelock.new(lockfile)
    assert l.try_acquire()
    l.release()
    assert !os.exists(lockfile)
    assert l.try_acquire()
    assert os.exists(lockfile)
    l.release()
    assert l.try_acquire()
    l.release()
    assert !os.exists(lockfile)
}

fn test_existing_file_lock_range() {
    target := helper_path('existing-range.txt')
    os.write_file(target, '0123456789abcdef')!
    mut holder := new_helper_process(target, .exclusive, 0, 5, 'hold')
    holder.run()
    defer {
        if holder.status == .running || holder.is_alive() {
            holder.wait()
        }
        holder.close()
    }
    wait_for_lock(mut holder)
    assert try_lock_from_helper(target, .exclusive, 0, 5) == 1
    assert try_lock_from_helper(target, .exclusive, 6, 5) == 0
    holder.wait()
    assert holder.code == 0
    assert os.exists(target)
    assert os.read_file(target)! == '0123456789abcdef'
}

fn test_existing_file_lock_shared_mode() {
    target := helper_path('existing-shared.txt')
    os.write_file(target, '0123456789abcdef')!
    mut holder := new_helper_process(target, .shared, 0, 5, 'hold')
    holder.run()
    defer {
        if holder.status == .running || holder.is_alive() {
            holder.wait()
        }
        holder.close()
    }
    wait_for_lock(mut holder)
    assert try_lock_from_helper(target, .shared, 0, 5) == 0
    assert try_lock_from_helper(target, .exclusive, 0, 5) == 1
    holder.wait()
    assert holder.code == 0
    assert os.exists(target)
}