/*
 * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
 * Distributed under the terms of the MIT License.
 */


#include <dirent.h>
#include <errno.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Entry.h>
#include <Path.h>

#include <package/hpkg/HPKGDefs.h>
#include <package/hpkg/RepositoryWriter.h>
#include <package/PackageInfo.h>
#include <package/RepositoryInfo.h>

#include "package_repo.h"


using BPackageKit::BHPKG::BRepositoryWriterListener;
using BPackageKit::BHPKG::BRepositoryWriter;
using namespace BPackageKit;


class RepositoryWriterListener  : public BRepositoryWriterListener {
public:
        RepositoryWriterListener(bool verbose, bool quiet)
                : fVerbose(verbose), fQuiet(quiet)
        {
        }

        virtual void PrintErrorVarArgs(const char* format, va_list args)
        {
                vfprintf(stderr, format, args);
        }

        virtual void OnPackageAdded(const BPackageInfo& packageInfo)
        {
                if (fQuiet)
                        return;

                printf("%s (%s)\n", packageInfo.Name().String(),
                        packageInfo.Version().ToString().String());
                if (fVerbose) {
                        printf("\tsummary:  %s\n", packageInfo.Summary().String());
                        printf("\tvendor:   %s\n", packageInfo.Vendor().String());
                        printf("\tpackager: %s\n", packageInfo.Packager().String());
                        printf("\tchecksum: %s\n", packageInfo.Checksum().String());
                        if (uint32 flags = packageInfo.Flags()) {
                                printf("\tflags:\n");
                                if ((flags & B_PACKAGE_FLAG_APPROVE_LICENSE) != 0)
                                        printf("\t\tapprove_license\n");
                                if ((flags & B_PACKAGE_FLAG_SYSTEM_PACKAGE) != 0)
                                        printf("\t\tsystem_package\n");
                        }
                } else
                        printf("\tchecksum: %s\n", packageInfo.Checksum().String());
        }

        virtual void OnRepositoryInfoSectionDone(uint32 uncompressedSize)
        {
                if (fQuiet || !fVerbose)
                        return;

                printf("----- Repository Info Section --------------------\n");
                printf("repository info size:    %10" B_PRIu32 " (uncompressed)\n",
                        uncompressedSize);
        }

        virtual void OnPackageAttributesSectionDone(uint32 stringCount,
                uint32 uncompressedSize)
        {
                if (fQuiet || !fVerbose)
                        return;

                printf("----- Package Attribute Section -------------------\n");
                printf("string count:            %10" B_PRIu32 "\n", stringCount);
                printf("package attributes size: %10" B_PRIu32 " (uncompressed)\n",
                        uncompressedSize);
        }

        virtual void OnRepositoryDone(uint32 headerSize, uint32 repositoryInfoSize,
                uint32 licenseCount, uint32 packageCount, uint32 packageAttributesSize,
                uint64 totalSize)
        {
                if (fQuiet)
                        return;

                printf("----- Package Repository Info -----\n");
                if (fVerbose)
                        printf("embedded license count   %10" B_PRIu32 "\n", licenseCount);
                printf("package count            %10" B_PRIu32 "\n", packageCount);
                printf("-----------------------------------\n");
                printf("header size:             %10" B_PRIu32 "\n", headerSize);
                printf("repository header size:  %10" B_PRIu32 "\n",
                        repositoryInfoSize);
                printf("package attributes size: %10" B_PRIu32 "\n",
                        packageAttributesSize);
                printf("total size:              %10" B_PRIu64 "\n", totalSize);
                printf("-----------------------------------\n");
        }

private:
        bool fVerbose;
        bool fQuiet;
};


int
command_create(int argc, const char* const* argv)
{
        const char* changeToDirectory = NULL;
        bool quiet = false;
        bool verbose = false;

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

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

                switch (c) {
                        case 'C':
                                changeToDirectory = optarg;
                                break;

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

                        case 'q':
                                quiet = true;
                                break;

                        case 'v':
                                verbose = true;
                                break;

                        default:
                                print_usage_and_exit(true);
                                break;
                }
        }

        // The remaining arguments are the repository info file plus one or more
        // package files, i.e. at least two more arguments.
        if (optind + 2 > argc)
                print_usage_and_exit(true);

        const char* repositoryInfoFileName = argv[optind++];
        const char* const* packageFileNames = argv + optind;

        RepositoryWriterListener listener(verbose, quiet);

        BEntry repositoryInfoEntry(repositoryInfoFileName);
        if (!repositoryInfoEntry.Exists()) {
                listener.PrintError(
                        "Error: given repository-info file '%s' doesn't exist!\n",
                        repositoryInfoFileName);
                return 1;
        }

        // determine path for 'repo' file from given info file
        BEntry repositoryParentEntry;
        repositoryInfoEntry.GetParent(&repositoryParentEntry);
        BPath repositoryPath;
        if (repositoryParentEntry.GetPath(&repositoryPath) != B_OK) {
                listener.PrintError(
                        "Error: can't determine path of given repository-info file!\n");
                return 1;
        }
        repositoryPath.Append("repo");

        // create repository
        BRepositoryInfo repositoryInfo(repositoryInfoEntry);
        status_t result = repositoryInfo.InitCheck();
        if (result != B_OK) {
                listener.PrintError(
                        "Error: can't parse given repository-info file : %s\n",
                        strerror(result));
                return 1;
        }
        BRepositoryWriter repositoryWriter(&listener, &repositoryInfo);
        if ((result = repositoryWriter.Init(repositoryPath.Path())) != B_OK) {
                listener.PrintError("Error: can't initialize repository-writer : %s\n",
                        strerror(result));
                return 1;
        }

        // change directory, if requested
        if (changeToDirectory != NULL) {
                if (chdir(changeToDirectory) != 0) {
                        listener.PrintError(
                                "Error: Failed to change the current working directory to "
                                "\"%s\": %s\n", changeToDirectory, strerror(errno));
                        return 1;
                }
        }

        // add all given package files
        for (int i = 0; i < argc - optind; ++i) {
                if (verbose)
                        printf("reading package '%s' ...\n", packageFileNames[i]);
                BEntry entry(packageFileNames[i]);
                if (!entry.Exists()) {
                        printf("package '%s' does not exist\n", packageFileNames[i]);
                        return 1;
                }
                result = repositoryWriter.AddPackage(entry);
                if (result != B_OK)
                        return 1;
        }

        // write the repository
        result = repositoryWriter.Finish();
        if (result != B_OK)
                return 1;

        if (verbose) {
                printf("\nsuccessfully created repository '%s'\n",
                        repositoryPath.Path());
        }

        return 0;
}