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


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

#include <new>

#include <File.h>
#include <String.h>

#include <package/hpkg/HPKGDefs.h>
#include <package/hpkg/PackageWriter.h>

#include <DataPositionIOWrapper.h>
#include <FdIO.h>
#include <SHA256.h>

#include "package.h"
#include "PackageWriterListener.h"


using BPackageKit::BHPKG::BPackageWriter;
using BPackageKit::BHPKG::BPackageWriterListener;
using BPackageKit::BHPKG::BPackageWriterParameters;


struct ChecksumIO : BDataIO {
        ChecksumIO()
        {
                fChecksummer.Init();
        }

        virtual ssize_t Write(const void* buffer, size_t size)
        {
                if (size > 0)
                        fChecksummer.Update(buffer, size);
                return (ssize_t)size;
        }

        BString Digest()
        {
                const uint8* digest = fChecksummer.Digest();
                BString hex;
                size_t length = fChecksummer.DigestLength();
                char* buffer = hex.LockBuffer(length * 2);
                if (buffer == NULL)
                {
                        throw std::bad_alloc();
                }

                for (size_t i = 0; i < length; i++)
                        snprintf(buffer + 2 * i, 3, "%02x", digest[i]);

                hex.UnlockBuffer();
                return hex;
        }

private:
        SHA256  fChecksummer;
};


static BPositionIO*
create_stdio(bool isInput)
{
        BFdIO* dataIO = new BFdIO(isInput ? 0 : 1, false);
        return new BDataPositionIOWrapper(dataIO);
}


int
command_checksum(int argc, const char* const* argv)
{
        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, "+hqv",
                        sLongOptions, NULL);
                if (c == -1)
                        break;

                switch (c) {
                        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 optional remaining argument is the package file.
        if (argc - optind > 1)
                print_usage_and_exit(true);

        const char* packageFileName = optind < argc ? argv[optind++] : NULL;

        // open the input package
        status_t error = B_OK;
        BPositionIO* inputFile;
        if (packageFileName == NULL || strcmp(packageFileName, "-") == 0) {
                inputFile = create_stdio(true);
        } else {
                BFile* inputFileFile = new BFile;
                error = inputFileFile->SetTo(packageFileName, O_RDONLY);
                if (error != B_OK) {
                        fprintf(stderr, "Error: Failed to open input file \"%s\": %s\n",
                                packageFileName, strerror(error));
                        return 1;
                }
                inputFile = inputFileFile;
        }

        // write the output package to a BDataIO that computes the checksum
        BPackageWriterParameters writerParameters;
        writerParameters.SetCompressionLevel(0);
        writerParameters.SetCompression(
                BPackageKit::BHPKG::B_HPKG_COMPRESSION_NONE);

        PackageWriterListener listener(verbose, quiet);
        BPackageWriter packageWriter(&listener);
        ChecksumIO outputFile;
        error = packageWriter.Init(new BDataPositionIOWrapper(&outputFile), true,
                &writerParameters);
        if (error != B_OK)
                return 1;

        error = packageWriter.Recompress(inputFile);
        if (error != B_OK)
                return 1;

        printf("%s\n", outputFile.Digest().String());

        return 0;
}