/*
 * Copyright 2013, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include <CopyEngine.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <Directory.h>
#include <Entry.h>
#include <File.h>
#include <fs_attr.h>
#include <Path.h>
#include <SymLink.h>
#include <TypeConstants.h>


namespace BPrivate {


static const size_t kDefaultBufferSize = 1024 * 1024;
static const size_t kSmallBufferSize = 64 * 1024;


// #pragma mark - BCopyEngine


BCopyEngine::BCopyEngine(uint32 flags)
        :
        fController(NULL),
        fFlags(flags),
        fBuffer(NULL),
        fBufferSize(0)
{
}


BCopyEngine::~BCopyEngine()
{
        delete[] fBuffer;
}


BCopyEngine::BController*
BCopyEngine::Controller() const
{
        return fController;
}


void
BCopyEngine::SetController(BController* controller)
{
        fController = controller;
}


uint32
BCopyEngine::Flags() const
{
        return fFlags;
}


BCopyEngine&
BCopyEngine::SetFlags(uint32 flags)
{
        fFlags = flags;
        return *this;
}


BCopyEngine&
BCopyEngine::AddFlags(uint32 flags)
{
        fFlags |= flags;
        return *this;
}


BCopyEngine&
BCopyEngine::RemoveFlags(uint32 flags)
{
        fFlags &= ~flags;
        return *this;
}


status_t
BCopyEngine::CopyEntry(const Entry& sourceEntry, const Entry& destEntry)
{
        if (fBuffer == NULL) {
                fBuffer = new(std::nothrow) char[kDefaultBufferSize];
                if (fBuffer == NULL) {
                        fBuffer = new(std::nothrow) char[kSmallBufferSize];
                        if (fBuffer == NULL) {
                                _NotifyError(B_NO_MEMORY, "Failed to allocate buffer");
                                return B_NO_MEMORY;
                        }
                        fBufferSize = kSmallBufferSize;
                } else
                        fBufferSize = kDefaultBufferSize;
        }

        BPath sourcePathBuffer;
        const char* sourcePath;
        status_t error = sourceEntry.GetPath(sourcePathBuffer, sourcePath);
        if (error != B_OK)
                return error;

        BPath destPathBuffer;
        const char* destPath;
        error = destEntry.GetPath(destPathBuffer, destPath);
        if (error != B_OK)
                return error;

        return _CopyEntry(sourcePath, destPath);
}


status_t
BCopyEngine::_CopyEntry(const char* sourcePath, const char* destPath)
{
        // apply entry filter
        if (fController != NULL && !fController->EntryStarted(sourcePath))
                return B_OK;

        // stat source
        struct stat sourceStat;
        if (lstat(sourcePath, &sourceStat) < 0) {
                return _HandleEntryError(sourcePath, errno,
                        "Couldn't access \"%s\": %s\n", sourcePath, strerror(errno));
        }

        // stat destination
        struct stat destStat;
        bool destExists = lstat(destPath, &destStat) == 0;

        // check whether to delete/create the destination
        bool unlinkDest = destExists;
        bool createDest = true;
        if (destExists) {
                if (S_ISDIR(destStat.st_mode)) {
                        if (!S_ISDIR(sourceStat.st_mode)
                                || (fFlags & MERGE_EXISTING_DIRECTORIES) == 0) {
                                return _HandleEntryError(sourcePath, B_FILE_EXISTS,
                                        "Can't copy \"%s\", since directory \"%s\" is in the "
                                        "way.\n", sourcePath, destPath);
                        }

                        if (S_ISDIR(sourceStat.st_mode)) {
                                // both are dirs; nothing to do
                                unlinkDest = false;
                                destExists = false;
                        }
                } else if ((fFlags & UNLINK_DESTINATION) == 0) {
                        return _HandleEntryError(sourcePath, B_FILE_EXISTS,
                                "Can't copy \"%s\", since entry \"%s\" is in the way.\n",
                                sourcePath, destPath);
                }
        }

        // unlink the destination
        if (unlinkDest) {
                if (unlink(destPath) < 0) {
                        return _HandleEntryError(sourcePath, errno,
                                "Failed to unlink \"%s\": %s\n", destPath, strerror(errno));
                }
        }

        // open source node
        BNode _sourceNode;
        BFile sourceFile;
        BDirectory sourceDir;
        BNode* sourceNode = NULL;
        status_t error;

        if (S_ISDIR(sourceStat.st_mode)) {
                error = sourceDir.SetTo(sourcePath);
                sourceNode = &sourceDir;
        } else if (S_ISREG(sourceStat.st_mode)) {
                error = sourceFile.SetTo(sourcePath, B_READ_ONLY);
                sourceNode = &sourceFile;
        } else {
                error = _sourceNode.SetTo(sourcePath);
                sourceNode = &_sourceNode;
        }

        if (error != B_OK) {
                return _HandleEntryError(sourcePath, error,
                        "Failed to open \"%s\": %s\n", sourcePath, strerror(error));
        }

        // create the destination
        BNode _destNode;
        BDirectory destDir;
        BFile destFile;
        BSymLink destSymLink;
        BNode* destNode = NULL;

        if (createDest) {
                if (S_ISDIR(sourceStat.st_mode)) {
                        // create dir
                        error = BDirectory().CreateDirectory(destPath, &destDir);
                        if (error != B_OK) {
                                return _HandleEntryError(sourcePath, error,
                                        "Failed to make directory \"%s\": %s\n", destPath,
                                        strerror(error));
                        }

                        destNode = &destDir;
                } else if (S_ISREG(sourceStat.st_mode)) {
                        // create file
                        error = BDirectory().CreateFile(destPath, &destFile);
                        if (error != B_OK) {
                                return _HandleEntryError(sourcePath, error,
                                        "Failed to create file \"%s\": %s\n", destPath,
                                        strerror(error));
                        }

                        destNode = &destFile;

                        // copy file contents
                        error = _CopyFileData(sourcePath, sourceFile, destPath, destFile);
                        if (error != B_OK) {
                                if (fController != NULL
                                        && fController->EntryFinished(sourcePath, error)) {
                                        return B_OK;
                                }
                                return error;
                        }
                } else if (S_ISLNK(sourceStat.st_mode)) {
                        // read symlink
                        char* linkTo = fBuffer;
                        ssize_t bytesRead = readlink(sourcePath, linkTo, fBufferSize - 1);
                        if (bytesRead < 0) {
                                return _HandleEntryError(sourcePath, errno,
                                        "Failed to read symlink \"%s\": %s\n", sourcePath,
                                        strerror(errno));
                        }

                        // null terminate the link contents
                        linkTo[bytesRead] = '\0';

                        // create symlink
                        error = BDirectory().CreateSymLink(destPath, linkTo, &destSymLink);
                        if (error != B_OK) {
                                return _HandleEntryError(sourcePath, error,
                                        "Failed to create symlink \"%s\": %s\n", destPath,
                                        strerror(error));
                        }

                        destNode = &destSymLink;

                } else {
                        return _HandleEntryError(sourcePath, B_NOT_SUPPORTED,
                                "Source file \"%s\" has unsupported type.\n", sourcePath);
                }

                // copy attributes (before setting the permissions!)
                error = _CopyAttributes(sourcePath, *sourceNode, destPath, *destNode);
                if (error != B_OK) {
                        if (fController != NULL
                                && fController->EntryFinished(sourcePath, error)) {
                                return B_OK;
                        }
                        return error;
                }

                // set file owner, group, permissions, times
                destNode->SetOwner(sourceStat.st_uid);
                destNode->SetGroup(sourceStat.st_gid);
                destNode->SetPermissions(sourceStat.st_mode);
                #ifdef HAIKU_TARGET_PLATFORM_HAIKU
                        destNode->SetCreationTime(sourceStat.st_crtime);
                #endif
                destNode->SetModificationTime(sourceStat.st_mtime);
        }

        // the destination node is no longer needed
        destNode->Unset();

        // recurse
        if ((fFlags & COPY_RECURSIVELY) != 0 && S_ISDIR(sourceStat.st_mode)) {
                char buffer[offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH];
                dirent *entry = (dirent*)buffer;
                while (sourceDir.GetNextDirents(entry, sizeof(buffer), 1) == 1) {
                        if (strcmp(entry->d_name, ".") == 0
                                || strcmp(entry->d_name, "..") == 0) {
                                continue;
                        }

                        // construct new entry paths
                        BPath sourceEntryPath;
                        error = sourceEntryPath.SetTo(sourcePath, entry->d_name);
                        if (error != B_OK) {
                                return _HandleEntryError(sourcePath, error,
                                        "Failed to construct entry path from dir \"%s\" and name "
                                        "\"%s\": %s\n", sourcePath, entry->d_name, strerror(error));
                        }

                        BPath destEntryPath;
                        error = destEntryPath.SetTo(destPath, entry->d_name);
                        if (error != B_OK) {
                                return _HandleEntryError(sourcePath, error,
                                        "Failed to construct entry path from dir \"%s\" and name "
                                        "\"%s\": %s\n", destPath, entry->d_name, strerror(error));
                        }

                        // copy the entry
                        error = _CopyEntry(sourceEntryPath.Path(), destEntryPath.Path());
                        if (error != B_OK) {
                                if (fController != NULL
                                        && fController->EntryFinished(sourcePath, error)) {
                                        return B_OK;
                                }
                                return error;
                        }
                }
        }

        if (fController != NULL)
                fController->EntryFinished(sourcePath, B_OK);
        return B_OK;
}


status_t
BCopyEngine::_CopyFileData(const char* sourcePath, BFile& source,
        const char* destPath, BFile& destination)
{
        off_t offset = 0;
        while (true) {
                // read
                ssize_t bytesRead = source.ReadAt(offset, fBuffer, fBufferSize);
                if (bytesRead < 0) {
                        _NotifyError(bytesRead, "Failed to read from file \"%s\": %s\n",
                                sourcePath, strerror(bytesRead));
                        return bytesRead;
                }

                if (bytesRead == 0)
                        return B_OK;

                // write
                ssize_t bytesWritten = destination.WriteAt(offset, fBuffer, bytesRead);
                if (bytesWritten < 0) {
                        _NotifyError(bytesWritten, "Failed to write to file \"%s\": %s\n",
                                destPath, strerror(bytesWritten));
                        return bytesWritten;
                }

                if (bytesWritten != bytesRead) {
                        _NotifyError(B_ERROR, "Failed to write all data to file \"%s\"\n",
                                destPath);
                        return B_ERROR;
                }

                offset += bytesRead;
        }
}


status_t
BCopyEngine::_CopyAttributes(const char* sourcePath, BNode& source,
        const char* destPath, BNode& destination)
{
        char attrName[B_ATTR_NAME_LENGTH];
        while (source.GetNextAttrName(attrName) == B_OK) {
                // get attr info
                attr_info attrInfo;
                status_t error = source.GetAttrInfo(attrName, &attrInfo);
                if (error != B_OK) {
                        // Delay reporting/handling the error until the controller has been
                        // asked whether it is interested.
                        attrInfo.type = B_ANY_TYPE;
                }

                // filter
                if (fController != NULL
                        && !fController->AttributeStarted(sourcePath, attrName,
                                attrInfo.type)) {
                        if (error != B_OK) {
                                _NotifyError(error, "Failed to get info of attribute \"%s\" "
                                        "of file \"%s\": %s\n", attrName, sourcePath,
                                        strerror(error));
                        }
                        continue;
                }

                if (error != B_OK) {
                        error = _HandleAttributeError(sourcePath, attrName, attrInfo.type,
                                error, "Failed to get info of attribute \"%s\" of file \"%s\": "
                                "%s\n", attrName, sourcePath, strerror(error));
                        if (error != B_OK)
                                return error;
                        continue;
                }

                // copy the attribute
                off_t offset = 0;
                off_t bytesLeft = attrInfo.size;
                // go at least once through the loop, so that an empty attribute will be
                // created as well
                do {
                        size_t toRead = fBufferSize;
                        if ((off_t)toRead > bytesLeft)
                                toRead = bytesLeft;

                        // read
                        ssize_t bytesRead = source.ReadAttr(attrName, attrInfo.type,
                                offset, fBuffer, toRead);
                        if (bytesRead < 0) {
                                error = _HandleAttributeError(sourcePath, attrName,
                                        attrInfo.type, bytesRead, "Failed to read attribute \"%s\" "
                                        "of file \"%s\": %s\n", attrName, sourcePath,
                                        strerror(bytesRead));
                                if (error != B_OK)
                                        return error;
                                break;
                        }

                        if (bytesRead == 0 && offset > 0)
                                break;

                        // write
                        ssize_t bytesWritten = destination.WriteAttr(attrName,
                                attrInfo.type, offset, fBuffer, bytesRead);
                        if (bytesWritten < 0) {
                                error = _HandleAttributeError(sourcePath, attrName,
                                        attrInfo.type, bytesWritten, "Failed to write attribute "
                                        "\"%s\" of file \"%s\": %s\n", attrName, destPath,
                                        strerror(bytesWritten));
                                if (error != B_OK)
                                        return error;
                                break;
                        }

                        bytesLeft -= bytesRead;
                        offset += bytesRead;
                } while (bytesLeft > 0);

                if (fController != NULL) {
                        fController->AttributeFinished(sourcePath, attrName, attrInfo.type,
                                B_OK);
                }
        }

        return B_OK;
}


void
BCopyEngine::_NotifyError(status_t error, const char* format, ...)
{
        if (fController != NULL) {
                va_list args;
                va_start(args, format);
                _NotifyErrorVarArgs(error, format, args);
                va_end(args);
        }
}


void
BCopyEngine::_NotifyErrorVarArgs(status_t error, const char* format,
        va_list args)
{
        if (fController != NULL) {
                BString message;
                message.SetToFormatVarArgs(format, args);
                fController->ErrorOccurred(message, error);
        }
}


status_t
BCopyEngine::_HandleEntryError(const char* path, status_t error,
        const char* format, ...)
{
        if (fController == NULL)
                return error;

        va_list args;
        va_start(args, format);
        _NotifyErrorVarArgs(error, format, args);
        va_end(args);

        if (fController->EntryFinished(path, error))
                return B_OK;
        return error;
}


status_t
BCopyEngine::_HandleAttributeError(const char* path, const char* attribute,
        uint32 attributeType, status_t error, const char* format, ...)
{
        if (fController == NULL)
                return error;

        va_list args;
        va_start(args, format);
        _NotifyErrorVarArgs(error, format, args);
        va_end(args);

        if (fController->AttributeFinished(path, attribute, attributeType, error))
                return B_OK;
        return error;
}


// #pragma mark - BController


BCopyEngine::BController::BController()
{
}


BCopyEngine::BController::~BController()
{
}


bool
BCopyEngine::BController::EntryStarted(const char* path)
{
        return true;
}


bool
BCopyEngine::BController::EntryFinished(const char* path, status_t error)
{
        return error == B_OK;
}


bool
BCopyEngine::BController::AttributeStarted(const char* path,
        const char* attribute, uint32 attributeType)
{
        return true;
}


bool
BCopyEngine::BController::AttributeFinished(const char* path,
        const char* attribute, uint32 attributeType, status_t error)
{
        return error == B_OK;
}


void
BCopyEngine::BController::ErrorOccurred(const char* message, status_t error)
{
}


} // namespace BPrivate