/*
 * Copyright 2009, Stephan Aßmus <superstippi@gmx.de>
 *  All rights reserved. Distributed under the terms of the MIT License.
 */

#include "UnzipEngine.h"

#include <new>

#include <stdio.h>
#include <string.h>

#include <Directory.h>
#include <Entry.h>
#include <File.h>
#include <Node.h>
#include <Path.h>
#include <String.h>

#include "CommandPipe.h"
#include "SemaphoreLocker.h"
#include "ProgressReporter.h"


using std::nothrow;


UnzipEngine::UnzipEngine(ProgressReporter* reporter,
                sem_id cancelSemaphore)
        :
        fPackage(""),
        fRetrievingListing(false),

        fBytesToUncompress(0),
        fBytesUncompressed(0),
        fLastBytesUncompressed(0),
        fItemsToUncompress(0),
        fItemsUncompressed(0),
        fLastItemsUncompressed(0),

        fProgressReporter(reporter),
        fCancelSemaphore(cancelSemaphore)
{
}


UnzipEngine::~UnzipEngine()
{
}


status_t
UnzipEngine::SetTo(const char* pathToPackage, const char* destinationFolder)
{
        fPackage = pathToPackage;
        fDestinationFolder = destinationFolder;

        fEntrySizeMap.Clear();

        fBytesToUncompress = 0;
        fBytesUncompressed = 0;
        fLastBytesUncompressed = 0;
        fItemsToUncompress = 0;
        fItemsUncompressed = 0;
        fLastItemsUncompressed = 0;

        BPrivate::BCommandPipe commandPipe;
        status_t ret = commandPipe.AddArg("unzip");
        if (ret == B_OK)
                ret = commandPipe.AddArg("-l");
        if (ret == B_OK)
                ret = commandPipe.AddArg(fPackage.String());
        if (ret != B_OK)
                return ret;

        // Launch the unzip thread and start reading the stdout and stderr output.
        FILE* stdOutAndErrPipe = NULL;
        thread_id unzipThread = commandPipe.PipeInto(&stdOutAndErrPipe);
        if (unzipThread < 0)
                return (status_t)unzipThread;

        fRetrievingListing = true;
        ret = commandPipe.ReadLines(stdOutAndErrPipe, this);
        fRetrievingListing = false;

        printf("%" B_PRIu64 " items in %" B_PRIdOFF " bytes\n", fItemsToUncompress,
                fBytesToUncompress);

        return ret;
}


status_t
UnzipEngine::UnzipPackage()
{
        if (fItemsToUncompress == 0)
                return B_NO_INIT;

        BPrivate::BCommandPipe commandPipe;
        status_t ret = commandPipe.AddArg("unzip");
        if (ret == B_OK)
                ret = commandPipe.AddArg("-o");
        if (ret == B_OK)
                ret = commandPipe.AddArg(fPackage.String());
        if (ret == B_OK)
                ret = commandPipe.AddArg("-d");
        if (ret == B_OK)
                ret = commandPipe.AddArg(fDestinationFolder.String());
        if (ret != B_OK) {
                fprintf(stderr, "Faild to construct argument list for unzip "
                        "process: %s\n", strerror(ret));
                return ret;
        }

        // Launch the unzip thread and start reading the stdout and stderr output.
        FILE* stdOutAndErrPipe = NULL;
        thread_id unzipThread = commandPipe.PipeInto(&stdOutAndErrPipe);
        if (unzipThread < 0)
                return (status_t)unzipThread;

        ret = commandPipe.ReadLines(stdOutAndErrPipe, this);
        if (ret != B_OK) {
                fprintf(stderr, "Piping the unzip process failed: %s\n",
                        strerror(ret));
                return ret;
        }

        // Add the contents of a potentially existing .OptionalPackageDescription
        // to the COPYRIGHTS attribute of AboutSystem.
        BPath descriptionPath(fDestinationFolder.String(),
                ".OptionalPackageDescription");
        ret = descriptionPath.InitCheck();
        if (ret != B_OK) {
                fprintf(stderr, "Failed to construct path to "
                        ".OptionalPackageDescription: %s\n", strerror(ret));
                return ret;
        }

        BEntry descriptionEntry(descriptionPath.Path());
        if (!descriptionEntry.Exists())
                return B_OK;

        BFile descriptionFile(&descriptionEntry, B_READ_ONLY);
        ret = descriptionFile.InitCheck();
        if (ret != B_OK) {
                fprintf(stderr, "Failed to construct file to "
                        ".OptionalPackageDescription: %s\n", strerror(ret));
                return ret;
        }

        BPath aboutSystemPath(fDestinationFolder.String(),
                "system/apps/AboutSystem");
        ret = aboutSystemPath.InitCheck();
        if (ret != B_OK) {
                fprintf(stderr, "Failed to construct path to AboutSystem: %s\n",
                        strerror(ret));
                return ret;
        }

        BNode aboutSystemNode(aboutSystemPath.Path());
        ret = aboutSystemNode.InitCheck();
        if (ret != B_OK) {
                fprintf(stderr, "Failed to construct node to AboutSystem: %s\n",
                        strerror(ret));
                return ret;
        }

        const char* kCopyrightsAttrName = "COPYRIGHTS";

        BString copyrightAttr;
        ret = aboutSystemNode.ReadAttrString(kCopyrightsAttrName, &copyrightAttr);
        if (ret != B_OK && ret != B_ENTRY_NOT_FOUND) {
                fprintf(stderr, "Failed to read current COPYRIGHTS attribute from "
                        "AboutSystem: %s\n", strerror(ret));
                return ret;
        }

        // Append the contents of the current optional package description to
        // the existing COPYRIGHTS attribute from AboutSystem
        size_t bufferSize = 2048;
        char buffer[bufferSize + 1];
        buffer[bufferSize] = '\0';
        while (true) {
                ssize_t read = descriptionFile.Read(buffer, bufferSize);
                if (read > 0) {
                        int32 length = copyrightAttr.Length();
                        if (read < (ssize_t)bufferSize)
                                buffer[read] = '\0';
                        int32 bufferLength = strlen(buffer);
                                // Should be "read", but maybe we have a zero in the
                                // buffer in which case the next check would be fooled.
                        copyrightAttr << buffer;
                        if (copyrightAttr.Length() != length + bufferLength) {
                                fprintf(stderr, "Failed to append buffer to COPYRIGHTS "
                                        "attribute.\n");
                                return B_NO_MEMORY;
                        }
                } else
                        break;
        }

        if (copyrightAttr[copyrightAttr.Length() - 1] != '\n')
                copyrightAttr << '\n\n';
        else
                copyrightAttr << '\n';

        ret = aboutSystemNode.WriteAttrString(kCopyrightsAttrName, &copyrightAttr);
        if (ret != B_OK && ret != B_ENTRY_NOT_FOUND) {
                fprintf(stderr, "Failed to read current COPYRIGHTS attribute from "
                        "AboutSystem: %s\n", strerror(ret));
                return ret;
        }

        // Don't leave the .OptionalPackageDescription behind.
        descriptionFile.Unset();
        descriptionEntry.Remove();

        return B_OK;
}


// #pragma mark -


bool
UnzipEngine::IsCanceled()
{
        if (fCancelSemaphore < 0)
                return false;

        SemaphoreLocker locker(fCancelSemaphore);
        return !locker.IsLocked();
}


status_t
UnzipEngine::ReadLine(const BString& line)
{
        if (fRetrievingListing)
                return _ReadLineListing(line);
        else
                return _ReadLineExtract(line);
}


status_t
UnzipEngine::_ReadLineListing(const BString& line)
{
        static const char* kListingFormat = "%llu  %s %s   %s\n";

        const char* string = line.String();
        while (string[0] == ' ')
                string++;

        uint64 bytes;
        char date[16];
        char time[16];
        char path[1024];
        if (sscanf(string, kListingFormat, &bytes, &date, &time, &path) == 4) {
                fBytesToUncompress += bytes;

                BString itemPath(path);
                BString itemName(path);
                int leafPos = itemPath.FindLast('/');
                if (leafPos >= 0)
                        itemName = itemPath.String() + leafPos + 1;

                // We check if the target folder exists and don't increment
                // the item count in that case. Unzip won't report on folders that did
                // not need to be created. This may mess up our current item count.
                uint32 itemCount = 1;
                if (bytes == 0 && itemName.Length() == 0) {
                        // a folder?
                        BPath destination(fDestinationFolder.String());
                        if (destination.Append(itemPath.String()) == B_OK) {
                                BEntry test(destination.Path());
                                if (test.Exists() && test.IsDirectory()) {
//                                      printf("ignoring %s\n", itemPath.String());
                                        itemCount = 0;
                                }
                        }
                }

                fItemsToUncompress += itemCount;

//              printf("item %s with %llu bytes to %s\n", itemName.String(),
//                      bytes, itemPath.String());

                fEntrySizeMap.Put(itemName.String(), bytes);
        } else {
//              printf("listing not understood: %s", string);
        }

        return B_OK;
}


status_t
UnzipEngine::_ReadLineExtract(const BString& line)
{
        const char* kCreatingFormat = "   creating:";
        const char* kInflatingFormat = "  inflating:";
        const char* kLinkingFormat = "    linking:";
        if (line.FindFirst(kCreatingFormat) == 0
                || line.FindFirst(kInflatingFormat) == 0
                || line.FindFirst(kLinkingFormat) == 0) {

                fItemsUncompressed++;

                BString itemPath;

                int pos = line.FindLast(" -> ");
                if (pos > 0)
                        line.CopyInto(itemPath, 13, pos - 13);
                else 
                        line.CopyInto(itemPath, 13, line.CountChars() - 14);

                itemPath.Trim();
                pos = itemPath.FindLast('/');
                BString itemName = itemPath.String() + pos + 1;
                itemPath.Truncate(pos);

                off_t bytes = 0;
                if (fEntrySizeMap.ContainsKey(itemName.String())) {
                        bytes = fEntrySizeMap.Get(itemName.String());
                        fBytesUncompressed += bytes;
                }

//              printf("%llu extracted %s to %s (%llu)\n", fItemsUncompressed,
//                      itemName.String(), itemPath.String(), bytes);

                _UpdateProgress(itemName.String(), itemPath.String());
        } else {
//              printf("ignored: '%s'\n", line.String());
        }

        return B_OK;
}


void
UnzipEngine::_UpdateProgress(const char* item, const char* targetFolder)
{
        if (fProgressReporter == NULL)
                return;

        uint64 items = 0;
        if (fLastItemsUncompressed < fItemsUncompressed) {
                items = fItemsUncompressed - fLastItemsUncompressed;
                fLastItemsUncompressed = fItemsUncompressed;
        }

        off_t bytes = 0;
        if (fLastBytesUncompressed < fBytesUncompressed) {
                bytes = fBytesUncompressed - fLastBytesUncompressed;
                fLastBytesUncompressed = fBytesUncompressed;
        }

        fProgressReporter->ItemsWritten(items, bytes, item, targetFolder);
}