/**
Copyright (c) 2018 Clipsey (clipseypone@gmail.com)

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
module ppc.backend.cfile;
import ppc.backend;
import ppc.exceptions;

import core.stdc.stdlib;
import core.stdc..string;
import core.stdc.stdio;

// Handling for bit arch
// Windows acts like it's 32 bit even if it's 64 bit, ugly hack to make windows work.
version(Windows) version = BIT_32;
else version(D_X32) version = BIT_32;
else version(D_LP64) version = BIT_64;

/// Seek based of the start of the MemFile
/// Alias of SEEK_SET
enum SeekStart = SEEK_SET;

/// Seek based of the current position of the readhead of the MemFile
/// Alias of SEEK_CUR
enum SeekCurrent = SEEK_CUR;

/// Seek based of the end of the MemFile backwards.
/// Alias of SEEK_END
enum SeekEnd = SEEK_END;

/// Loads a raw file as a MemFile usable by the loaders.
MemFile loadFile(string filePath) {
    import std.file : read;
    auto data = cast(ubyte[])read(filePath);
    MemFile file;
    file.arrayptr = data.ptr;
    file.readhead = file.arrayptr;
    file.length = data.length;
    return file;
}

/// Loads a raw file as a MemFile usable by the loaders.
RefMemFile loadFileRef(string filePath) {
    import std.file : read;
    auto data = cast(ubyte[])read(filePath);
    return RefMemFile(data);
}

/// A memfile wrapper to make sure that the garbage collector 100% doesn't remove it.
struct RefMemFile {
private:
    ubyte[] data;

public:
    /// The MemFile object that the references the internally stored data of this struct.
    MemFile file;

    /// Creates a new RefMemFile
    this(ubyte[] data) {
        this.data = data;
        file.arrayptr = cast(ubyte*)&this.data;
        file.readhead = file.arrayptr;
        file.length = data.length;
    }
}

/// A C File struct which reads from memory instead of disk.
struct MemFile {
public:
    /// Pointer to data
    ubyte* arrayptr;

    /// Pointer to read head.
    ubyte* readhead;

    /// Length of data.
    size_t length;

    this(ubyte* array, size_t length) {
        this.arrayptr = array;
        this.readhead = this.arrayptr;
        this.length = length;
    }

    /// MemFile implementation of C fseek.
    static extern (C) int seek(void* fileStream, int64_t offset, int whence) nothrow {
        MemFile* mf = cast(MemFile*)fileStream;
        switch (whence) {
            case SEEK_CUR:
                mf.readhead += offset;
                break;
            case SEEK_SET:
                mf.readhead = mf.arrayptr + offset;
                break;
            case SEEK_END:
                mf.readhead = mf.arrayptr + mf.length-offset;
                break;
            default:
                return -1;
        }

        if (mf.readhead < mf.arrayptr) {
            mf.readhead = mf.arrayptr;
            return -1;
        }

        if (mf.readhead > mf.arrayptr + mf.length) {
            mf.readhead = mf.arrayptr + mf.length;
        }

        return 0;
    }

    /// MemFile implementation of C fread.
    static extern (C) size_t read(void* data, size_t bytes, size_t to_read, void* fileStream) nothrow {
        MemFile* mf = cast(MemFile*)fileStream;
        
        size_t len = bytes*to_read;
        if (mf.readhead + len > mf.arrayptr+mf.length) {
            len = mf.arrayptr+mf.length-mf.readhead;
        }
        memcpy(data, mf.readhead, len);
        mf.readhead += len;
        return len;
    }

    // TODO: Improve the implementation of this.
    /// MemFile implementation of C fwrite
    /// Returns 0 if index is out of range
    static extern (C) size_t write(void* data, size_t bytes, size_t to_write, void* fileStream) {
        MemFile* mf = cast(MemFile*)fileStream;

        // Create buffer if doesn't exist.
        if (mf.arrayptr is null) {
            mf.arrayptr = (new ubyte[1]).ptr;
            mf.readhead = mf.arrayptr;
        }

        ubyte[] newArr;
        size_t len = bytes*to_write;
        if (mf.readhead + len > mf.arrayptr+mf.length) {
            
            // Offset from last iteration
            size_t offset = (cast(size_t)mf.readhead-cast(size_t)mf.arrayptr);

            // Allocation
            newArr = new ubyte[mf.length+(len)];
            
            // Resize/copy operation
            memoryCopy(mf.arrayptr, newArr.ptr, mf.length);
            mf.arrayptr = newArr.ptr;
            mf.readhead = mf.arrayptr+offset;
            mf.length = newArr.length;

        }
        memoryCopy(data, mf.readhead, len);
        mf.readhead += len;
        return len;
    }

    /// MemFile implementation of C fclose.
    static extern (C) int close(void* fileStream) nothrow {
        return 0;
    }

    /// MemFile implementation of C ftell.
    static extern (C) clong tell(void* fileStream) nothrow {
        MemFile* mf = cast(MemFile*)fileStream;

        // Screw C file handling, make sure that the right type of long is used on each platform...
        version(BIT_32) {

            // Pray that stuff doesn't break with this cast.
            return cast(clong)mf.readhead-cast(clong)mf.arrayptr;

        } else version(BIT_64) {

            // How it is intended to work, geez.
            return mf.readhead-mf.arrayptr;

        } 
    }

    ubyte[] toArray() nothrow {
        return cast(ubyte[])arrayptr[0..length];
    }
    
}

/// C-style memory copy.
void memoryCopy(void* input, void* output, size_t length) nothrow {
    memcpy(output, input, length);
}