/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "compatibility.h"

#include "partition_support.h"

#include <errno.h>
#include <unistd.h>

#include <list>

#include "fssh_errno.h"
#include "fssh_stat.h"
#include "fssh_unistd.h"
#include "stat_priv.h"


using namespace FSShell;


namespace FSShell {


struct FileRestriction {
        FileRestriction(fssh_dev_t device, fssh_ino_t node, fssh_off_t startOffset,
                        fssh_off_t endOffset)
                :
                device(device),
                node(node),
                startOffset(startOffset),
                endOffset(endOffset)
        {
        }

        fssh_dev_t      device;
        fssh_ino_t      node;
        fssh_off_t      startOffset;
        fssh_off_t      endOffset;
};


typedef std::list<FileRestriction*> FileRestrictionList;

static FileRestrictionList sFileRestrictions;


static FileRestriction*
find_file_restriction(fssh_dev_t device, fssh_ino_t node)
{
        for (FileRestrictionList::iterator it = sFileRestrictions.begin();
                        it != sFileRestrictions.end(); ++it) {
                FileRestriction* restriction = *it;
                if (restriction->device == device && restriction->node == node)
                        return restriction;
        }

        return NULL;
}


static FileRestriction*
find_file_restriction(int fd)
{
        struct fssh_stat st;
        if (unrestricted_fstat(fd, &st) < 0)
                return NULL;

        return find_file_restriction(st.fssh_st_dev, st.fssh_st_ino);
}


void
add_file_restriction(const char* fileName, fssh_off_t startOffset,
        fssh_off_t endOffset)
{
        struct fssh_stat st;
        if (unrestricted_stat(fileName, &st) < 0)
                return;

        fssh_dev_t device = st.fssh_st_dev;
        fssh_ino_t node = st.fssh_st_ino;

        FileRestriction* restriction = find_file_restriction(device, node);
        if (restriction)
                return;

        if (endOffset < 0)
                endOffset = st.fssh_st_size;

        restriction = new FileRestriction(device, node, startOffset, endOffset);
        sFileRestrictions.push_back(restriction);
}


void
restricted_file_opened(int fd)
{
        FileRestriction* restriction = find_file_restriction(fd);
        if (!restriction)
                return;

        lseek(fd, restriction->startOffset, SEEK_SET);
}


void
restricted_file_duped(int oldFD, int newFD)
{
}


void
restricted_file_closed(int fd)
{
}


int
restricted_file_restrict_io(int fd, fssh_off_t& pos, fssh_off_t size)
{
        FileRestriction* restriction = find_file_restriction(fd);
        if (!restriction)
                return 0;

        if (pos < 0) {
                pos = lseek(fd, 0, SEEK_CUR);
                if (pos < 0)
                        return -1;
        } else
                pos += restriction->startOffset;

        if (pos < restriction->startOffset || pos > restriction->endOffset) {
                fssh_set_errno(B_BAD_VALUE);
                return -1;
        }

        fssh_off_t maxSize = restriction->endOffset - pos;
        if (size > maxSize)
                size = maxSize;

        return 0;
}


void
restricted_file_restrict_stat(struct fssh_stat* st)
{
        FileRestriction* restriction = find_file_restriction(st->fssh_st_dev,
                st->fssh_st_ino);
        if (!restriction)
                return;

        st->fssh_st_size = restriction->endOffset - restriction->startOffset;
}


static int
to_platform_seek_mode(int fsshWhence)
{
        switch (fsshWhence) {
                case FSSH_SEEK_CUR:
                        return SEEK_CUR;
                case FSSH_SEEK_END:
                        return SEEK_END;
                case FSSH_SEEK_SET:
                default:
                        return SEEK_SET;
        }
}


}       // namespace FSShell


fssh_off_t
fssh_lseek(int fd, fssh_off_t offset, int whence)
{
        FileRestriction* restriction = find_file_restriction(fd);
        if (!restriction)
                return lseek(fd, offset, to_platform_seek_mode(whence));

        fssh_off_t pos;

        switch (whence) {
                case FSSH_SEEK_CUR:
                {
                        pos = lseek(fd, 0, SEEK_CUR);
                        if (pos < 0)
                                return pos;
                        pos += offset;
                        break;
                }
                case FSSH_SEEK_END:
                        pos = restriction->endOffset + offset;
                        break;
                case FSSH_SEEK_SET:
                default:
                        pos = restriction->startOffset + offset;
                        break;
        }

        if (pos < restriction->startOffset) {
                fssh_set_errno(B_BAD_VALUE);
                return -1;
        }

        pos = lseek(fd, pos, SEEK_SET);
        if (pos >= 0)
                pos -= restriction->startOffset;

        return pos;
}