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


#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <Entry.h>
#include <package/hpkg/PackageContentHandler.h>
#include <package/hpkg/PackageEntry.h>
#include <package/hpkg/PackageEntryAttribute.h>
#include <package/hpkg/PackageInfoAttributeValue.h>
#include <package/hpkg/PackageReader.h>
#include <package/hpkg/StandardErrorOutput.h>
#include <package/hpkg/v1/PackageContentHandler.h>
#include <package/hpkg/v1/PackageEntry.h>
#include <package/hpkg/v1/PackageEntryAttribute.h>
#include <package/hpkg/v1//PackageReader.h>

#include <package/PackageInfo.h>

#include "package.h"
#include "PackageInfoPrinter.h"


using namespace BPackageKit;
using BPackageKit::BHPKG::BErrorOutput;
using BPackageKit::BHPKG::BPackageInfoAttributeValue;
using BPackageKit::BHPKG::BStandardErrorOutput;


struct VersionPolicyV1 {
        typedef BPackageKit::BHPKG::V1::BPackageContentHandler
                PackageContentHandler;
        typedef BPackageKit::BHPKG::V1::BPackageEntry PackageEntry;
        typedef BPackageKit::BHPKG::V1::BPackageEntryAttribute
                PackageEntryAttribute;
        typedef BPackageKit::BHPKG::V1::BPackageReader PackageReader;

        static inline uint64 PackageDataSize(
                const BPackageKit::BHPKG::V1::BPackageData& data)
        {
                return data.UncompressedSize();
        }

        static inline status_t InitReader(PackageReader& packageReader,
                const char* fileName)
        {
                return packageReader.Init(fileName);
        }
};

struct VersionPolicyV2 {
        typedef BPackageKit::BHPKG::BPackageContentHandler PackageContentHandler;
        typedef BPackageKit::BHPKG::BPackageEntry PackageEntry;
        typedef BPackageKit::BHPKG::BPackageEntryAttribute PackageEntryAttribute;
        typedef BPackageKit::BHPKG::BPackageReader PackageReader;

        static inline uint64 PackageDataSize(
                const BPackageKit::BHPKG::BPackageData& data)
        {
                return data.Size();
        }

        static inline status_t InitReader(PackageReader& packageReader,
                const char* fileName)
        {
                return packageReader.Init(fileName,
                        BPackageKit::BHPKG
                                ::B_HPKG_READER_DONT_PRINT_VERSION_MISMATCH_MESSAGE);
        }
};


enum ListMode {
        LIST_ALL,
        LIST_PATHS_ONLY,
        LIST_META_INFO_ONLY
};


template<typename VersionPolicy>
struct PackageContentListHandler : VersionPolicy::PackageContentHandler {
        PackageContentListHandler(bool listEntries, bool listAttributes)
                :
                fPrinter(),
                fLevel(0),
                fListEntries(listEntries),
                fListAttribute(listEntries && listAttributes)
        {
        }

        virtual status_t HandleEntry(typename VersionPolicy::PackageEntry* entry)
        {
                if (!fListEntries)
                        return B_OK;

                fLevel++;

                int indentation = (fLevel - 1) * 2;
                printf("%*s", indentation, "");

                // name and size
                printf("%-*s", indentation < 32 ? 32 - indentation : 0, entry->Name());
                printf("  %8llu",
                        (unsigned long long)VersionPolicy::PackageDataSize(entry->Data()));

                // time
                struct tm* time = localtime(&entry->ModifiedTime().tv_sec);
                printf("  %04d-%02d-%02d %02d:%02d:%02d",
                        1900 + time->tm_year, time->tm_mon + 1, time->tm_mday,
                        time->tm_hour, time->tm_min, time->tm_sec);

                // file type
                mode_t mode = entry->Mode();
                if (S_ISREG(mode))
                        printf("  -");
                else if (S_ISDIR(mode))
                        printf("  d");
                else if (S_ISLNK(mode))
                        printf("  l");
                else
                        printf("  ?");

                // permissions
                char buffer[4];
                printf("%s", _PermissionString(buffer, mode >> 6,
                        (mode & S_ISUID) != 0));
                printf("%s", _PermissionString(buffer, mode >> 3,
                        (mode & S_ISGID) != 0));
                printf("%s", _PermissionString(buffer, mode, false));

                // print the symlink path
                if (S_ISLNK(mode))
                        printf("  -> %s", entry->SymlinkPath());

                printf("\n");
                return B_OK;
        }

        virtual status_t HandleEntryAttribute(
                typename VersionPolicy::PackageEntry* entry,
                typename VersionPolicy::PackageEntryAttribute* attribute)
        {
                if (!fListAttribute)
                        return B_OK;

                int indentation = fLevel * 2;
                printf("%*s<", indentation, "");
                printf("%-*s  %8llu", indentation < 31 ? 31 - indentation : 0,
                        attribute->Name(),
                        (unsigned long long)VersionPolicy::PackageDataSize(
                                attribute->Data()));

                uint32 type = attribute->Type();
                if (isprint(type & 0xff) && isprint((type >> 8) & 0xff)
                         && isprint((type >> 16) & 0xff) && isprint(type >> 24)) {
                        printf("  '%c%c%c%c'", int(type >> 24), int((type >> 16) & 0xff),
                                int((type >> 8) & 0xff), int(type & 0xff));
                } else
                        printf("  %#" B_PRIx32, type);

                printf(">\n");
                return B_OK;
        }

        virtual status_t HandleEntryDone(
                typename VersionPolicy::PackageEntry* entry)
        {
                if (!fListEntries)
                        return B_OK;

                fLevel--;
                return B_OK;
        }

        virtual status_t HandlePackageAttribute(
                const BPackageInfoAttributeValue& value)
        {
                if (value.attributeID == B_PACKAGE_INFO_NAME)
                        printf("package-attributes:\n");

                if (!fPrinter.PrintAttribute(value)) {
                        printf("*** Invalid package attribute section: unexpected "
                                "package attribute id %d encountered\n", value.attributeID);
                        return B_BAD_DATA;
                }

                return B_OK;
        }

        virtual void HandleErrorOccurred()
        {
        }

private:
        static const char* _PermissionString(char* buffer, uint32 mode, bool sticky)
        {
                buffer[0] = (mode & 0x4) != 0 ? 'r' : '-';
                buffer[1] = (mode & 0x2) != 0 ? 'w' : '-';

                if ((mode & 0x1) != 0)
                        buffer[2] = sticky ? 's' : 'x';
                else
                        buffer[2] = '-';

                buffer[3] = '\0';
                return buffer;
        }

        static void _PrintPackageVersion(const BPackageVersionData& version)
        {
                printf("%s", BPackageVersion(version).ToString().String());
        }

private:
        PackageInfoPrinter      fPrinter;
        int                                     fLevel;
        bool                            fListEntries;
        bool                            fListAttribute;
};


template<typename VersionPolicy>
struct PackageContentListPathsHandler : VersionPolicy::PackageContentHandler {
        PackageContentListPathsHandler()
                :
                fPathComponents()
        {
        }

        virtual status_t HandleEntry(typename VersionPolicy::PackageEntry* entry)
        {
                fPathComponents.Add(entry->Name());
                printf("%s\n", fPathComponents.Join("/").String());
                return B_OK;
        }

        virtual status_t HandleEntryAttribute(
                typename VersionPolicy::PackageEntry* entry,
                typename VersionPolicy::PackageEntryAttribute* attribute)
        {
                return B_OK;
        }

        virtual status_t HandleEntryDone(
                typename VersionPolicy::PackageEntry* entry)
        {
                fPathComponents.Remove(fPathComponents.CountStrings() - 1);
                return B_OK;
        }

        virtual status_t HandlePackageAttribute(
                const BPackageInfoAttributeValue& value)
        {
                return B_OK;
        }

        virtual void HandleErrorOccurred()
        {
        }

private:
        BStringList     fPathComponents;
};


template<typename VersionPolicy>
static void
do_list(const char* packageFileName, bool listAttributes, ListMode listMode,
        bool ignoreVersionError)
{
        // open package
        BStandardErrorOutput errorOutput;
        typename VersionPolicy::PackageReader packageReader(&errorOutput);
        status_t error = VersionPolicy::InitReader(packageReader, packageFileName);
        if (error != B_OK) {
                if (ignoreVersionError && error == B_MISMATCHED_VALUES)
                        return;
                exit(1);
        }

        // list
        switch (listMode) {
                case LIST_PATHS_ONLY:
                {
                        PackageContentListPathsHandler<VersionPolicy> handler;
                        error = packageReader.ParseContent(&handler);
                        break;
                }

                case LIST_ALL:
                case LIST_META_INFO_ONLY:
                {
                        PackageContentListHandler<VersionPolicy> handler(
                                listMode != LIST_META_INFO_ONLY, listAttributes);
                        error = packageReader.ParseContent(&handler);
                }
        }

        if (error != B_OK)
                exit(1);

        exit(0);
}


int
command_list(int argc, const char* const* argv)
{
        ListMode listMode = LIST_ALL;
        bool listAttributes = false;

        while (true) {
                static struct option sLongOptions[] = {
                        { "help", no_argument, 0, 'h' },
                        { 0, 0, 0, 0 }
                };

                opterr = 0; // don't print errors
                int c = getopt_long(argc, (char**)argv, "+ahip", sLongOptions, NULL);
                if (c == -1)
                        break;

                switch (c) {
                        case 'a':
                                listAttributes = true;
                                break;

                        case 'i':
                                listMode = LIST_META_INFO_ONLY;
                                break;

                        case 'h':
                                print_usage_and_exit(false);
                                break;

                        case 'p':
                                listMode = LIST_PATHS_ONLY;
                                break;

                        default:
                                print_usage_and_exit(true);
                                break;
                }
        }

        // One argument should remain -- the package file name.
        if (optind + 1 != argc)
                print_usage_and_exit(true);

        const char* packageFileName = argv[optind++];

        // If the file doesn't look like a package file, try to load it as a
        // package info file.
        if (!BString(packageFileName).EndsWith(".hpkg")) {
                struct ErrorListener : BPackageInfo::ParseErrorListener {
                        virtual void OnError(const BString& msg, int line, int col)
                        {
                                fprintf(stderr, "%s:%d:%d: %s\n", fPath, line, col,
                                        msg.String());
                        }

                        const char*     fPath;
                } errorListener;
                errorListener.fPath = packageFileName;

                BPackageInfo info;
                if (info.ReadFromConfigFile(BEntry(packageFileName), &errorListener)
                                != B_OK) {
                        return 1;
                }

                printf("package-attributes:\n");
                PackageInfoPrinter().PrintPackageInfo(info);
                return 0;
        }

        BHPKG::BStandardErrorOutput errorOutput;

        // current package file format version
        do_list<VersionPolicyV2>(packageFileName, listAttributes, listMode, true);
        do_list<VersionPolicyV1>(packageFileName, listAttributes, listMode, false);

        return 0;
}