/*
 * Copyright 2019 Leorize <leorize+oss@disroot.org>
 * Copyright 2015 Tiancheng "Timothy" Gu, timothygu99@gmail.com
 * Copyright 2001-2002 François Revol (mmu_man)
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600 /* for NZERO */
#endif

#include "pthread_private.h"

#include <errno.h>
#include <sys/resource.h>

#include <OS.h>
#include <sys/param.h> // for MAX() and MIN() macros
#include <syscall_utils.h> // RETURN_AND_SET_ERRNO()

// Part of this file is adapted from src/bin/renice.c, by François Revol.

// Some notes on different priority notations:
//
// Notation system          | Real-time | High Prio | Default | Low Prio |
// -------------------------|----------:|----------:|--------:|---------:|
// BeOS/Haiku               |      120* |        99 |      10 |      1** |
// UNIX [gs]etpriority()*** |      N.A. |       -20 |       0 |       19 |
// UNIX internal            |      N.A. |         0 |      20 |       39 |
//
// *    Note that BeOS/Haiku does not have an absolute highest priority value
//      (else than the maximum of int32), and (B_REAL_TIME_PRIORITY - 1) is
//      the highest non-real-time priority and usually used as the priority
//      limit. On UNIX systems there is no such concept as "real-time."
// **   0 only for idle_thread
// ***  Also used for UNIX nice(1) and nice(3)

#ifdef CLIP
#undef CLIP
#endif
#define CLIP(n, max, min) MAX(MIN((n), (max)), (min))

// In these contexts, "min" does not mean "lowest value," but "lowest
// priority," which is the maximum value in UNIX priority notation.
// "Zero" means normal priority, which in UNIX function notation is 0.
// POSIX specification also refers to it as "NZERO."
#define NMAX 0
#define NMIN (NZERO * 2 - 1)
#define CLIP_TO_UNIX(n) CLIP(n, NMIN, NMAX)

#define BZERO B_NORMAL_PRIORITY
#define BMAX (B_REAL_TIME_DISPLAY_PRIORITY - 1)
#define BMIN 1
#define CLIP_TO_BEOS(n) CLIP(n, BMAX, BMIN)

// To accurately convert the notation values, we need to use an exponential
// function:
//
//      f(x) = 99e^(-0.116x)
//
// where f() represents the BeOS priority value, and x represents the Unix
// priority value.
//
// But that's too complicated. And slow. So we use a simple piecewise linear
// approach here, by a simple rescaling of the values.

// returns an equivalent UNIX priority for a given BeOS priority.
static int32
prio_be_to_unix(int32 prio)
{
        int out;
        if (prio >= BZERO)
                out = NZERO
                        - ((prio - BZERO) * NZERO + (BMAX - BZERO) / 2) / (BMAX - BZERO);
                        // `(BMAX - BZERO) / 2` for rounding
        else
                out = NZERO
                        + ((BZERO - prio) * (NZERO - 1)) / (BZERO - BMIN)
                        + 1;
                        // `+1` for rounding
        return CLIP_TO_UNIX(out);
}


// returns an equivalent BeOS priority for a given UNIX priority.
static int32
prio_unix_to_be(int32 prio)
{
        int out;
        // Do not need to care about rounding
        if (prio >= NZERO)
                out = BZERO - ((prio - NZERO) * (BZERO - BMIN)) / (NZERO - 1);
        else
                out = BZERO + ((NZERO - prio) * (BMAX - BZERO)) / (NZERO);
        return CLIP_TO_BEOS(out);
}


int
getpriority(int which, id_t who)
{
        bool found = false;
        int out = -100;

        if (who < 0)
                RETURN_AND_SET_ERRNO(EINVAL);
        switch (which) {
                case PRIO_PROCESS:
                {
                        int32 th_cookie = 0;
                        thread_info thread;

                        while (get_next_thread_info(who, &th_cookie, &thread) == B_OK) {
                                if (thread.priority > out) {
                                        found = true;
                                        out = thread.priority;
                                }
                        }
                        break;
                }
                case PRIO_PGRP:
                {
                        int32 team_cookie = 0, th_cookie = 0;
                        team_info team;
                        thread_info thread;

                        who = who == 0 ? getpgrp() : who;
                        while (get_next_team_info(&team_cookie, &team) == B_OK) {
                                if (getpgid(team.team) != who)
                                        continue;
                                th_cookie = 0;
                                while (get_next_thread_info(team.team, &th_cookie, &thread)
                                        == B_OK) {
                                        if (thread.priority > out) {
                                                found = true;
                                                out = thread.priority;
                                        }
                                }
                        }
                        break;
                }
                case PRIO_USER:
                {
                        // `who` (id_t) is int32, but uid_t is uint32, so using this
                        // indirection to get rid of compiler warnings
                        // `who` can never be negative because of the `who < 0` check
                        // above.
                        uid_t euid = who == 0 ? geteuid() : (uid_t)who;
                        int32 team_cookie = 0, th_cookie = 0;
                        team_info team;
                        thread_info thread;

                        while (get_next_team_info(&team_cookie, &team) == B_OK) {
                                if (team.uid != euid)
                                        continue;
                                th_cookie = 0;
                                while (get_next_thread_info(team.team, &th_cookie, &thread)
                                        == B_OK) {
                                        if (thread.priority > out) {
                                                found = true;
                                                out = thread.priority;
                                        }
                                }
                        }
                        break;
                }
                default:
                        RETURN_AND_SET_ERRNO(EINVAL);
        }
        if (!found)
                RETURN_AND_SET_ERRNO(ESRCH);
        return prio_be_to_unix(out) - NZERO;
}


int
setpriority(int which, id_t who, int value)
{
        int32 th_cookie = 0;
        thread_info thread;

        // TODO: implement for other processes
        if (who != 0 && which != PRIO_PROCESS)
                RETURN_AND_SET_ERRNO(EINVAL);
        value = value > NMIN ? NMIN : CLIP_TO_UNIX(value + NZERO);
        value = prio_unix_to_be(value);

        __pthread_set_default_priority(value);
        while (get_next_thread_info(B_CURRENT_TEAM, &th_cookie, &thread) == B_OK)
                set_thread_priority(thread.thread, value);

        return 0;
}