/*
    Copyright 2015 Wolfgang Thaller.

    This file is part of Retro68.

    Retro68 is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Retro68 is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    Under Section 7 of GPL version 3, you are granted additional
    permissions described in the GCC Runtime Library Exception, version
    3.1, as published by the Free Software Foundation.

    You should have received a copy of the GNU General Public License and
    a copy of the GCC Runtime Library Exception along with this program;
    see the files COPYING and COPYING.RUNTIME respectively.  If not, see
    <http://www.gnu.org/licenses/>.
*/

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/time.h>
#include <reent.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>

#include <MacMemory.h>
#include <Processes.h>
#include <Files.h>
#include <TextUtils.h>
#include <Errors.h>

void *_sbrk_r(struct _reent *reent, ptrdiff_t increment)
{
    Debugger();
    return NewPtrClear(increment);
}

__attribute__((weak))
void _exit(int status)
{
    //if(status != 0)
    //    Debugger();
    ExitToShell();
    for(;;)
        ;
}

ssize_t _consolewrite(int fd, const void *buf, size_t count);
ssize_t _consoleread(int fd, void *buf, size_t count);

const int kMacRefNumOffset = 10;

static int OSErrToErrno(OSErr err) {
    switch (err) {
    case noErr:
        return 0;

    case nsvErr:
        return ENODEV;

    case fnfErr:
    case dirNFErr:
        return ENOENT;

    case bdNamErr:
    case paramErr:
        return EINVAL;

    case ioErr:
    default:
        return EIO;
    }
}


ssize_t _write_r(struct _reent *reent, int fd, const void *buf, size_t count)
{
    long cnt = count;
    if(fd >= kMacRefNumOffset)
    {
        FSWrite(fd - kMacRefNumOffset, &cnt, buf);
        return cnt;
    }
    else
        return _consolewrite(fd,buf,count);
}

ssize_t _read_r(struct _reent *reent, int fd, void *buf, size_t count)
{
    long cnt = count;
    if(fd >= kMacRefNumOffset)
    {
        FSRead(fd - kMacRefNumOffset, &cnt, buf);
        return cnt;
    }
    else
        return _consoleread(fd,buf,count);
}

int _open_r(struct _reent *reent, const char* name, int flags, int mode)
{
    Str255 pname;
#if TARGET_API_MAC_CARBON
    // Carbon has the new, sane version.
    c2pstrcpy(pname,name);
#else
    // It is also available in various glue code libraries and
    // in some versions of InterfaceLib, but it's confusing.
    // Using the inplace variant, c2pstr, isn't much better than
    // doing things by hand:
    strncpy(&pname[1],name,255);
    pname[0] = strlen(name);
#endif
    short ref;

    SInt8 permission;
    switch(flags & O_ACCMODE)
    {
        case O_RDONLY:
            permission = fsRdPerm;
            break;
        case O_WRONLY:
            permission = fsWrPerm;
            break;
        case O_RDWR:
            permission = fsRdWrPerm;
            break;
    }

    if(flags & O_CREAT)
    {
        HCreate(0,0,pname,'????','TEXT');
    }

    OSErr err = HOpenDF(0,0,pname,fsRdWrPerm,&ref);
    if(err == paramErr)
        err = HOpen(0,0,pname,fsRdWrPerm,&ref);

    if(err)
        return -1;    // TODO: errno

    if(flags & O_TRUNC)
    {
        SetEOF(ref, 0);
    }

    return ref + kMacRefNumOffset;
}

int _close_r(struct _reent *reent, int fd)
{
    if(fd >= kMacRefNumOffset) {
        short refNum = fd - kMacRefNumOffset;
        short vRefNum;
        OSErr err = GetVRefNum(refNum, &vRefNum);
        FSClose(refNum);
        if (err == noErr)
            FlushVol(NULL, vRefNum);
    }
    return 0;
}

int _fstat_r(struct _reent *reent, int fd, struct stat *buf)
{
    const long long int epochDiffInSeconds = 2082844800LL;

    if (buf == NULL) {
        reent->_errno = EFAULT;
        return -1;
    }

    memset(buf, 0, sizeof (struct stat));
    buf->st_nlink = 1;
    buf->st_uid = 42;
    buf->st_gid = 42;
    buf->st_blksize = 512;

    if (fd < kMacRefNumOffset) {
        // Console.
        unsigned long secs;
        GetDateTime(&secs);

        buf->st_mode = S_IFCHR | S_IRUSR | S_IWUSR | S_IWGRP;
        buf->st_mtim.tv_sec = secs - epochDiffInSeconds;
        buf->st_ctim.tv_sec = secs - epochDiffInSeconds;
        buf->st_atim.tv_sec = secs - epochDiffInSeconds;
        return 0;
    }

    CInfoPBRec p;
    memset(&p, 0, sizeof (p));
    p.hFileInfo.ioFRefNum = fd - kMacRefNumOffset;
    OSErr err = PBGetCatInfoSync(&p);
    if (err) {
        reent->_errno = OSErrToErrno(err);
        return -1;
    }

    ino_t inode;
    mode_t mode;

    long long mtim;
    long long ctim;

    int size = 0;
    int phySize = 0;

    if (p.hFileInfo.ioFlAttrib & 16) {
        inode = p.dirInfo.ioDrDirID;
        mode = S_IFDIR | S_IRUSR | S_IRUSR | S_IXUSR;
        mtim = p.dirInfo.ioDrMdDat - epochDiffInSeconds;
        ctim = p.dirInfo.ioDrCrDat - epochDiffInSeconds;
    } else {
        inode = p.hFileInfo.ioDirID;
        mode = S_IFREG | S_IRUSR | S_IRUSR;
        mtim = p.hFileInfo.ioFlMdDat - epochDiffInSeconds;
        ctim = p.hFileInfo.ioFlCrDat - epochDiffInSeconds;
        size = p.hFileInfo.ioFlLgLen;
        phySize = p.hFileInfo.ioFlPyLen + p.hFileInfo.ioFlRPyLen;
    }

    HParamBlockRec h;
    memset(&h, 0, sizeof (h));
    h.volumeParam.ioVRefNum = p.hFileInfo.ioVRefNum;
    err = PBHGetVInfoSync(&h);
    if (err) {
        reent->_errno = OSErrToErrno(err);
        return -1;
    }

    buf->st_dev = h.volumeParam.ioVDrvInfo;
    buf->st_ino = inode;
    buf->st_mode = mode;
    buf->st_size = size;
    buf->st_mtim.tv_sec = mtim;
    buf->st_ctim.tv_sec = ctim;
    buf->st_blocks = (phySize / 512) + (phySize % 512 > 0);

    return 0;
}

extern int _stat_r(struct _reent * reent, const char *fn, struct stat *buf)
{
    return -1;
}

off_t _lseek_r(struct _reent *reent, int fd, off_t offset, int whence)
{
    if(fd >= kMacRefNumOffset)
    {
        short posMode;
        switch(whence)
        {
            case SEEK_SET:
                posMode = fsFromStart;
                break;
            case SEEK_CUR:
                posMode = fsFromMark;
                break;
            case SEEK_END:
                posMode = fsFromLEOF;
                break;
        }

        short ref = fd - kMacRefNumOffset;
        SetFPos(ref, posMode, offset);
        long finalPos;
        GetFPos(ref, &finalPos);
        return finalPos;
    }
    return (off_t) -1;
}

int _kill_r(struct _reent *reent, pid_t pid, int sig)
{
    if(pid == 42)
        _exit(42);
    else
        return -1;
}

pid_t _getpid_r(struct _reent *reent)
{
    return 42;
}

int _fork_r(struct _reent *reent)
{
    return -1;
}

int _execve_r(struct _reent *reent, const char *fn, char *const * argv, char *const *envp)
{
    return -1;
}

int _fcntl_r(struct _reent *reent, int fd, int cmd, int arg)
{
    return -1;
}

int _isatty_r(struct _reent *reent, int fd)
{
    return fd < kMacRefNumOffset;
}

int _link_r(struct _reent *reent, const char *from, const char *to)
{
    reent->_errno = EPERM;
    return -1;
}

int _mkdir_r(struct _reent *reent, const char *fn, int mode)
{
    return -1;
}

int _rename_r(struct _reent *reent, const char *from, const char *to)
{
    return -1;
}

int _unlink_r(struct _reent *reent, const char *fn)
{
    return -1;
}

_CLOCK_T_ _times_r(struct _reent *reent, struct tms *buf)
{
    reent->_errno = EACCES;
    return  -1;
}

int _wait_r(struct _reent *reent, int *wstatus)
{
    reent->_errno = ECHILD;
    return -1;                    /* Always fails */
}



int _gettimeofday_r(struct _reent *reent, struct timeval *tp, void *__tz)
{
    /* Classic MacOS's GetDateTime function returns an integer.
     * TickCount() has a slightly higher resolution, but is independent of the real-time clock.
     */
    unsigned long secs;
    GetDateTime(&secs);
    unsigned long ticks = TickCount();

    static unsigned long savedTicks = 0, savedSecs = 0;
    
    if(!savedSecs)
    {
        savedTicks = ticks;
        savedSecs = secs;
    }
    else
    {
        unsigned long elapsedTicks = ticks - savedTicks;
        unsigned long elapsedSecs = secs - savedSecs;
        unsigned long expectedTicks = elapsedSecs * 60 + elapsedSecs * 3 / 20;
        
        if(expectedTicks > elapsedTicks)
            savedTicks = ticks;
        else
            savedTicks += expectedTicks;
        savedSecs = secs;
    }

    if(tp)
    {
        const int epochDifferenceInYears = 1970 - 1904;
        const int epochDifferenceInDays =
            365 * epochDifferenceInYears
            + (epochDifferenceInYears + 3)/ 4;  // round up for leap years

        tp->tv_sec = secs - 86400 * epochDifferenceInDays;
        tp->tv_usec = (ticks - savedTicks) * 20000000 / 2003;
    }

    return 0;
}

extern int _getentropy_r (struct _reent *, void *, size_t)
{
    errno = ENOSYS;
    return -1;
}