/*-
 * Copyright (c) 2002-2018 The UbixOS Project.
 * All rights reserved.
 *
 * This was developed by Christopher W. Olsen for the UbixOS Project.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
 *
 * 1) Redistributions of source code must retain the above copyright notice, this list of
 *    conditions, the following disclaimer and the list of authors.
 * 2) Redistributions in binary form must reproduce the above copyright notice, this list of
 *    conditions, the following disclaimer and the list of authors in the documentation and/or
 *    other materials provided with the distribution.
 * 3) Neither the name of the UbixOS Project nor the names of its contributors may be used to
 *    endorse or promote products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/gen_calls.h>
#include <sys/thread.h>
#include <sys/gdt.h>
#include <ubixos/sched.h>
#include <ubixos/endtask.h>
#include <lib/kprintf.h>
#include <lib/kmalloc.h>
#include <string.h>
#include <assert.h>
#include <sys/descrip.h>
#include <sys/video.h>
#include <sys/signal.h>
#include <ubixos/errno.h>
#include <vmm/vmm.h>

/* Exit Syscall */
int sys_exit(struct thread *td, struct sys_exit_args *args) {
    //kprintf("exit(%i)", args->status);
    endTask(_current->id);
    return (0x0);
}

/* return the process id */
int getpid(struct thread *td, struct getpid_args *uap) {
#ifdef DEBUG
  kprintf("[%s:%i]",__FILE__,__LINE__);
#endif
    td->td_retval[0] = _current->id;
    return (0);
}

/* return the process user id */
int getuid(struct thread *td, struct getuid_args *uap) {
#ifdef DEBUG
  kprintf("[%s:%i]",__FILE__,__LINE__);
#endif
    td->td_retval[0] = _current->uid;
    return (0);
}

/* return the process group id */
int getgid(struct thread *td, struct getgid_args *uap) {
#ifdef DEBUG
  kprintf("[%s:%i]",__FILE__,__LINE__);
#endif
    td->td_retval[0] = _current->gid;
    return (0);
}

int sys_issetugid(register struct thread *td, struct sys_issetugid_args *uap) {
    td->td_retval[0] = 0;
    return (0);
}

int readlink(struct thread *td, struct readlink_args *uap) {
#ifdef DEBUG
  kprintf("[%s:%i]",__FILE__,__LINE__);
#endif
    kprintf("readlink: [%s:%i]\n", uap->path, uap->count);
    td->td_retval[0] = -1;
    td->td_retval[1] = 0x0;
    return (0x0);
}

int gettimeofday_new(struct thread *td, struct gettimeofday_args *uap) {
#ifdef DEBUG
  kprintf("[%s:%i]",__FILE__,__LINE__);
#endif
    return (0x0);
}

int read(struct thread *td, struct read_args *uap) {
    int error = 0x0;
    size_t count = 0x0;
    struct file *fd = 0x0;

#ifdef DEBUG
  kprintf("[%s:%i]",__FILE__,__LINE__);
#endif

    error = getfd(td, &fd, uap->fd);

    if (error)
        return (error);

    count = fread(uap->buf, uap->nbyte, 0x1, fd->fd);
    kprintf("count: %i\n", count);
    td->td_retval[0] = count;

    return (error);
}

/*!
 * \brief place holder for now functionality to be added later
 */
int setitimer(struct thread *td, struct setitimer_args *uap) {
    int error = 0x0;

    return (error);
}

int access(struct thread *td, struct access_args *uap) {
    int error = 0x0;
    kprintf("name: [%s]\n", uap->path);
    return (error);
}

int mprotect(struct thread *td, struct mprotect_args *uap) {
    int error = 0x0;
    return (error);
}

int sys_invalid(struct thread *td, void *args) {
    kprintf("ISC[%i:%i]", td->frame->tf_eax, _current->id);
    td->td_retval[0] = -1;
    return (0);
}

int sys_wait4(struct thread *td, struct sys_wait4_args *args) {
    int error = 0;

    if (args->pid == -1) {
        if (_current->children <= 0) {
            td->td_retval[0] = ECHILD;
            return (-1);
        }

        int children = _current->children;

        sched_setStatus(_current->id, WAIT);
        while (_current->children == children) {
            sched_yield();
        }

        td->td_retval[0] = _current->last_exit;
        td->td_retval[1] = 0x8;
    }
    else {

        kTask_t *tmpTask = schedFindTask(args->pid);

        if (tmpTask != 0x0) {
            sched_setStatus(_current->id, WAIT);
            while (tmpTask != 0x0) {
                sched_yield();
                tmpTask = schedFindTask(args->pid);
            }
            td->td_retval[0] = args->pid;
        }
        else {
            td->td_retval[0] = -1;
            error = -1;
        }
    }
    return (error);
}

int sys_sysarch(struct thread *td, struct sys_sysarch_args *args) {

    void **segbase = 0x0;
    uint32_t base_addr = 0x0;

    if (args->op == 10) {
        kprintf("SETGSBASE: 0x%X:0x%X", args->parms, args->parms[0]);

        segbase = args->parms;

        kprintf("SGS: [0x%X:0x%X]", segbase[0], segbase[1]);
        base_addr = (uint32_t) segbase[0];

        struct gdtDescriptor *tmpDesc = 0x0;

        tmpDesc = VMM_USER_LDT + sizeof(struct gdtDescriptor);  //taskLDT[1];

        tmpDesc->limitLow = 0xFFFF;  //(0xFFFFF & 0xFFFF);
        tmpDesc->limitHigh = 0xF;  //(0xFFFFF >> 16);
        tmpDesc->baseLow = (base_addr & 0xFFFF);
        tmpDesc->baseMed = ((base_addr >> 16) & 0xFF);
        tmpDesc->access = ((dData + dWrite + dBig + dBiglim + dDpl3) + dPresent) >> 8;
        tmpDesc->granularity = ((dData + dWrite + dBig + dBiglim + dDpl3) & 0xFF) >> 4;
        tmpDesc->baseHigh = base_addr >> 24;

        asm(
            "push %eax\n"
            "mov $0x18,%ax\n"
            "lldt %ax\n" /* "lgdtl (loadGDT)\n" */
            "mov $0xF,%eax\n"
            "mov %eax,%gs\n"
            "pop %eax\n"
        );

        td->td_retval[0] = 0;
    }
    else {
        kprintf("sysarch(%i,NULL)", args->op);
        td->td_retval[0] = -1;
    }
    return (0);
}

int sys_getpid(struct thread *td, struct sys_getpid_args *args) {
    td->td_retval[0] = _current->id;
    return (0);
}
int sys_geteuid(struct thread *td, struct sys_geteuid_args *args) {
    td->td_retval[0] = _current->uid;
    return (0);
}

int sys_getegid(struct thread *td, struct sys_getegid_args *args) {
    td->td_retval[0] = _current->gid;
    return (0);
}

int sys_getppid(struct thread *td, struct sys_getppid_args *args) {
    td->td_retval[0] = _current->ppid;
    return (0);
}

int sys_sigprocmask(struct thread *td, struct sys_sigprocmask_args *args) {
    td->td_retval[0] = -1;

    if (args->oset != 0x0) {
        memcpy(args->oset, &td->sigmask, sizeof(sigset_t));
        td->td_retval[0] = 0x0;
    }

    if (args->set != 0x0) {
        if (args->how == SIG_SETMASK) {
            if (args->set != 0x0) {
                memcpy(&td->sigmask, args->set, sizeof(sigset_t));
                td->td_retval[0] = 0;
            }
            else {
                td->td_retval[0] = -1;
            }
        }
        else if (args->how == SIG_BLOCK) {
            if (args->set != 0x0) {
                td->sigmask.__bits[0] &= args->set->__bits[0];
                td->sigmask.__bits[1] &= args->set->__bits[1];
                td->sigmask.__bits[2] &= args->set->__bits[2];
                td->sigmask.__bits[3] &= args->set->__bits[3];
                td->td_retval[0] = 0;
            }
            else {
                td->td_retval[0] = -1;
            }
        }
        else if (args->how == SIG_UNBLOCK) {
            if (args->set != 0x0) {
                td->sigmask.__bits[0] |= args->set->__bits[0];
                td->sigmask.__bits[1] |= args->set->__bits[1];
                td->sigmask.__bits[2] |= args->set->__bits[2];
                td->sigmask.__bits[3] |= args->set->__bits[3];
                td->td_retval[0] = 0;
            }
            else {
                td->td_retval[0] = -1;
            }
        }
        else {
            kprintf("SPM: 0x%X", args->how);
            td->td_retval[0] = -1;
        }
    }

    return (0);
}

int sys_sigaction(struct thread *td, struct sys_sigaction_args *args) {
    td->td_retval[0] = -1;

    if (args->oact != 0x0) {
        memcpy(args->oact, &td->sigact[args->sig], sizeof(struct sigaction));
        td->td_retval[0] = 0;
    }

    if (args->act != 0x0) {
        //kprintf("SA: %i", args->sig);
        memcpy(&td->sigact[args->sig], args->act, sizeof(struct sigaction));
        td->td_retval[0] = 0;
    }
    return (0);
}

int sys_getpgrp(struct thread *td, struct sys_getpgrp_args *args) {
    td->td_retval[0] = _current->pgrp;
    return (0);
}

int sys_setpgid(struct thread *td, struct sys_setpgid_args *args) {
    pidType pid = 0x0;
    pidType pgrp = 0x0;

    if (args->pid == 0x0 || args->pid == _current->id) {
        if (args->pgid == 0x0 || args->pgid == _current->id) {
            td->td_retval[0] = 0x0;
            _current->pgrp = _current->id;
        }
        else {
            td->td_retval[0] = -1;
        }
    }
    else {
        kTask_t *tmpTask = schedFindTask(pid);

        if (tmpTask == 0x0) {
            td->td_retval[0] = -1;
        }
        else {

            /* Get The PRGP We Want To Set */
            pgrp = (args->pgid == 0) ? tmpTask->pgrp : args->pgid;

            if (pgrp != _current->pgrp || pgrp != tmpTask->id) {
                td->td_retval[0] = -1;
            }
            else {
                td->td_retval[0] = 0x0;
                tmpTask->pgrp = pgrp;
            }

        }

    }

    return (0);
}

int sys_gettimeofday(struct thread *td, struct sys_gettimeofday_args *args) {
    gettimeofday(args->tp, args->tzp);
    td->td_retval[0] = 0;
    return (0);
}

int sys_getlogin(struct thread *thr, struct sys_getlogin_args *args) {
    int error = 0;

    memcpy(args->namebuf, _current->username, args->namelen);

    return (error);
}

int sys_setlogin(struct thread *thr, struct sys_setlogin_args *args) {
    int error = 0;

    memcpy(_current->username, args->namebuf, 256);

    return (error);
}

int sys_getrlimit(struct thread *thr, struct sys_getrlimit_args *args) {
    int error = 0;

    struct rlimit *rlim = 0x0;

    switch (args->which) {
        case 0:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 1:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 2:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 3:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 4:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 5:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 6:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 7:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 8:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 9:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 10:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 11:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 12:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 13:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        case 14:
            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
            break;
        default:
            error = -1;
            kprintf("[getrlimit: %i]", args->which);
    }

    return (error);
}

int sys_setrlimit(struct thread *thr, struct sys_setrlimit_args *args) {
    int error = 0;

    switch (args->which) {
        case 0:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 1:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 2:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 3:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 4:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 5:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 6:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 7:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 8:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 9:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 10:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 11:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 12:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 13:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        case 14:
            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
            break;
        default:
            error = -1;
            kprintf("[setrlimit: %i]", args->which);
    }

    return (error);
}