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


#include <package/ActivationTransaction.h>

#include <new>

#include <Message.h>


namespace BPackageKit {
namespace BPrivate {


BActivationTransaction::BActivationTransaction()
        :
        fLocation(B_PACKAGE_INSTALLATION_LOCATION_ENUM_COUNT),
        fChangeCount(0),
        fTransactionDirectoryName(),
        fPackagesToActivate(),
        fPackagesToDeactivate(),
        fFirstBootProcessing(false)
{
}


BActivationTransaction::BActivationTransaction(BMessage* archive,
        status_t* _error)
        :
        fLocation(B_PACKAGE_INSTALLATION_LOCATION_ENUM_COUNT),
        fChangeCount(0),
        fTransactionDirectoryName(),
        fPackagesToActivate(),
        fPackagesToDeactivate(),
        fFirstBootProcessing(false)
{
        status_t error;
        int32 location;

        if (archive->FindBool("first boot processing", &fFirstBootProcessing)
                        != B_OK)
                fFirstBootProcessing = false; // Field is optional for compatibility.

        if ((error = archive->FindInt32("location", &location)) == B_OK
                && (error = archive->FindInt64("change count", &fChangeCount)) == B_OK
                && (error = archive->FindString("transaction",
                        &fTransactionDirectoryName)) == B_OK
                && (error = _ExtractStringList(archive, "activate",
                        fPackagesToActivate)) == B_OK
                && (error = _ExtractStringList(archive, "deactivate",
                        fPackagesToDeactivate)) == B_OK) {
                if (location >= 0
                        && location <= B_PACKAGE_INSTALLATION_LOCATION_ENUM_COUNT) {
                        fLocation = (BPackageInstallationLocation)location;
                } else
                        error = B_BAD_VALUE;
        }

        if (_error != NULL)
                *_error = error;
}


BActivationTransaction::~BActivationTransaction()
{
}


status_t
BActivationTransaction::InitCheck() const
{
        if (fLocation < 0 || fLocation >= B_PACKAGE_INSTALLATION_LOCATION_ENUM_COUNT
                || fTransactionDirectoryName.IsEmpty()
                || (fPackagesToActivate.IsEmpty() && fPackagesToDeactivate.IsEmpty())) {
                return B_BAD_VALUE;
        }
        return B_OK;
}


status_t
BActivationTransaction::SetTo(BPackageInstallationLocation location,
        int64 changeCount, const BString& directoryName)
{
        if (location < 0 || location >= B_PACKAGE_INSTALLATION_LOCATION_ENUM_COUNT
                || directoryName.IsEmpty()) {
                return B_BAD_VALUE;
        }

        fLocation = location;
        fChangeCount = changeCount;
        fTransactionDirectoryName = directoryName;
        fPackagesToActivate.MakeEmpty();
        fPackagesToDeactivate.MakeEmpty();
        fFirstBootProcessing = false;

        return B_OK;
}


BPackageInstallationLocation
BActivationTransaction::Location() const
{
        return fLocation;
}


void
BActivationTransaction::SetLocation(BPackageInstallationLocation location)
{
        fLocation = location;
}


int64
BActivationTransaction::ChangeCount() const
{
        return fChangeCount;
}


void
BActivationTransaction::SetChangeCount(int64 changeCount)
{
        fChangeCount = changeCount;
}


const BString&
BActivationTransaction::TransactionDirectoryName() const
{
        return fTransactionDirectoryName;
}


void
BActivationTransaction::SetTransactionDirectoryName(
        const BString& directoryName)
{
        fTransactionDirectoryName = directoryName;
}


const BStringList&
BActivationTransaction::PackagesToActivate() const
{
        return fPackagesToActivate;
}


bool
BActivationTransaction::SetPackagesToActivate(const BStringList& packages)
{
        fPackagesToActivate = packages;
        return fPackagesToActivate.CountStrings() == packages.CountStrings();
}


bool
BActivationTransaction::AddPackageToActivate(const BString& package)
{
        return fPackagesToActivate.Add(package);
}


const BStringList&
BActivationTransaction::PackagesToDeactivate() const
{
        return fPackagesToDeactivate;
}


bool
BActivationTransaction::SetPackagesToDeactivate(const BStringList& packages)
{
        fPackagesToDeactivate = packages;
        return fPackagesToDeactivate.CountStrings() == packages.CountStrings();
}


bool
BActivationTransaction::AddPackageToDeactivate(const BString& package)
{
        return fPackagesToDeactivate.Add(package);
}


bool
BActivationTransaction::FirstBootProcessing() const
{
        return fFirstBootProcessing;
}


void
BActivationTransaction::SetFirstBootProcessing(bool processingIsOn)
{
        fFirstBootProcessing = processingIsOn;
}


status_t
BActivationTransaction::Archive(BMessage* archive, bool deep) const
{
        status_t error = BArchivable::Archive(archive, deep);
        if (error != B_OK)
                return error;

        if ((error = archive->AddInt32("location", fLocation)) != B_OK
                || (error = archive->AddInt64("change count", fChangeCount)) != B_OK
                || (error = archive->AddString("transaction",
                        fTransactionDirectoryName)) != B_OK
                || (error = archive->AddStrings("activate", fPackagesToActivate))
                        != B_OK
                || (error = archive->AddStrings("deactivate", fPackagesToDeactivate))
                        != B_OK
                || (error = archive->AddBool("first boot processing",
                        fFirstBootProcessing)) != B_OK) {
                return error;
        }

        return B_OK;
}


/*static*/ BArchivable*
BActivationTransaction::Instantiate(BMessage* archive)
{
        if (validate_instantiation(archive, "BActivationTransaction"))
                return new(std::nothrow) BActivationTransaction(archive);
        return NULL;
}


/*static*/ status_t
BActivationTransaction::_ExtractStringList(BMessage* archive, const char* field,
        BStringList& _list)
{
        status_t error = archive->FindStrings(field, &_list);
        return error == B_NAME_NOT_FOUND ? B_OK : error;
                // If the field doesn't exist, that's OK.
}


}       // namespace BPrivate
}       // namespace BPackageKit