/*
 * Copyright 2024-2025, Andrew Lindesay <apl@lindesay.co.nz>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#include "PackageLocalInfo.h"

#include "Package.h"


PackageLocalInfo::PackageLocalInfo()
        :
        fViewed(false),
        fLocalFilePath(),
        fFileName(),
        fSize(0),
        fFlags(0),
        fSystemDependency(false),
        fState(NONE),
        fInstallationLocations(),
        fDownloadProgress(0.0)
{
}


PackageLocalInfo::PackageLocalInfo(const PackageLocalInfo& other)
        :
        fViewed(other.fViewed),
        fLocalFilePath(other.fLocalFilePath),
        fFileName(other.fFileName),
        fSize(other.fSize),
        fFlags(other.fFlags),
        fSystemDependency(other.fSystemDependency),
        fState(other.fState),
        fInstallationLocations(),
        fDownloadProgress(other.fDownloadProgress)
{
        PackageInstallationLocationSet otherLocations = other.InstallationLocations();
        PackageInstallationLocationSet::const_iterator it;

        for (it = otherLocations.begin(); it != otherLocations.end(); it++)
                fInstallationLocations.insert(*it);
}


PackageLocalInfo::~PackageLocalInfo()
{
}


bool
PackageLocalInfo::operator==(const PackageLocalInfo& other) const
{
        return fState == other.fState
                && fFlags == other.fFlags
                && fInstallationLocations == other.fInstallationLocations
                && fDownloadProgress == other.fDownloadProgress
                && fSystemDependency == other.fSystemDependency
                && fLocalFilePath == other.fLocalFilePath
                && fFileName == other.fFileName
                && fSize == other.fSize
                && fViewed == other.fViewed;
}


bool
PackageLocalInfo::operator!=(const PackageLocalInfo& other) const
{
        return !(*this == other);
}


bool
PackageLocalInfo::Viewed() const
{
        return fViewed;
}


const BString&
PackageLocalInfo::LocalFilePath() const
{
        return fLocalFilePath;
}


const BString&
PackageLocalInfo::FileName() const
{
        return fFileName;
}


off_t
PackageLocalInfo::Size() const
{
        return fSize;
}


int32
PackageLocalInfo::Flags() const
{
        return fFlags;
}


bool
PackageLocalInfo::IsSystemDependency() const
{
        return fSystemDependency;
}


PackageState
PackageLocalInfo::State() const
{
        return fState;
}


const PackageInstallationLocationSet&
PackageLocalInfo::InstallationLocations() const
{
        return fInstallationLocations;
}


float
PackageLocalInfo::DownloadProgress() const
{
        return fDownloadProgress;
}


bool
PackageLocalInfo::IsSystemPackage() const
{
        return (fFlags & BPackageKit::B_PACKAGE_FLAG_SYSTEM_PACKAGE) != 0;
}


void
PackageLocalInfo::SetSystemDependency(bool isDependency)
{
        fSystemDependency = isDependency;
}


void
PackageLocalInfo::SetState(PackageState state)
{
        if (fState != state) {
                fState = state;
                if (fState != DOWNLOADING)
                        fDownloadProgress = 0.0;
        }
}


void
PackageLocalInfo::AddInstallationLocation(int32 location)
{
        fInstallationLocations.insert(location);
        SetState(ACTIVATED);
                // TODO: determine how to differentiate between installed and active.
}


bool
PackageLocalInfo::HasInstallationLocation(int32 location) const
{
        return fInstallationLocations.find(location) != fInstallationLocations.end();
}


int32
PackageLocalInfo::CountInstallationLocations() const
{
        return static_cast<int32>(fInstallationLocations.size());
}


void
PackageLocalInfo::SetDownloadProgress(float progress)
{
        fState = DOWNLOADING;
        fDownloadProgress = progress;
}


void
PackageLocalInfo::SetLocalFilePath(const char* path)
{
        fLocalFilePath = path;
}


bool
PackageLocalInfo::IsLocalFile() const
{
        return !fLocalFilePath.IsEmpty() && fInstallationLocations.empty();
}


void
PackageLocalInfo::SetSize(int64 size)
{
        fSize = size;
}


void
PackageLocalInfo::SetViewed()
{
        fViewed = true;
}


void
PackageLocalInfo::SetFlags(int32 value)
{
        fFlags = value;
}


void
PackageLocalInfo::SetFileName(const BString& value)
{
        fFileName = value;
}


// #pragma mark - PackageLocalInfoBuilder


PackageLocalInfoBuilder::PackageLocalInfoBuilder()
        :
        fViewed(false),
        fLocalFilePath(),
        fFileName(),
        fSize(0),
        fFlags(0),
        fSystemDependency(false),
        fState(NONE),
        fInstallationLocations(),
        fDownloadProgress(0.0)
{
}


PackageLocalInfoBuilder::PackageLocalInfoBuilder(const PackageLocalInfoRef& value)
        :
        fViewed(false),
        fLocalFilePath(),
        fFileName(),
        fSize(0),
        fFlags(0),
        fSystemDependency(false),
        fState(NONE),
        fInstallationLocations(),
        fDownloadProgress(0.0)
{
        fSource = value;
}


PackageLocalInfoBuilder::~PackageLocalInfoBuilder()
{
}


void
PackageLocalInfoBuilder::_InitFromSource()
{
        if (fSource.IsSet()) {
                _Init(fSource);
                fSource.Unset();
        }
}


void
PackageLocalInfoBuilder::_Init(const PackageLocalInfo* value)
{
        fViewed = value->Viewed();
        fLocalFilePath = value->LocalFilePath();
        fFileName = value->FileName();
        fSize = value->Size();
        fFlags = value->Flags();
        fSystemDependency = value->IsSystemDependency();
        fState = value->State();
        fDownloadProgress = value->DownloadProgress();

        PackageInstallationLocationSet valueLocations = value->InstallationLocations();
        PackageInstallationLocationSet::const_iterator it;

        for (it = valueLocations.begin(); it != valueLocations.end(); it++)
                fInstallationLocations.insert(*it);
}


PackageLocalInfoRef
PackageLocalInfoBuilder::BuildRef()
{
        if (fSource.IsSet())
                return fSource;

        PackageLocalInfo* localInfo = new PackageLocalInfo();

        if (fViewed)
                localInfo->SetViewed();

        localInfo->SetLocalFilePath(fLocalFilePath);
        localInfo->SetFileName(fFileName);
        localInfo->SetSize(fSize);
        localInfo->SetFlags(fFlags);
        localInfo->SetSystemDependency(fSystemDependency);
        localInfo->SetState(fState);
        if (fState == DOWNLOADING)
                localInfo->SetDownloadProgress(fDownloadProgress);

        PackageInstallationLocationSet::const_iterator it;

        for (it = fInstallationLocations.begin(); it != fInstallationLocations.end(); it++)
                localInfo->AddInstallationLocation(*it);

        return PackageLocalInfoRef(localInfo, true);
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithViewed()
{
        if (!fSource.IsSet() || !fSource->Viewed()) {
                _InitFromSource();
                fViewed = true;
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithLocalFilePath(const char* path)
{
        if (!fSource.IsSet() || fSource->LocalFilePath() != path) {
                _InitFromSource();
                fLocalFilePath.SetTo(path);
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithFileName(const BString& value)
{
        if (!fSource.IsSet() || fSource->FileName() != value) {
                _InitFromSource();
                fFileName.SetTo(value);
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithSize(off_t size)
{
        if (!fSource.IsSet() || fSource->Size() != size) {
                _InitFromSource();
                fSize = size;
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithFlags(int32 value)
{
        if (!fSource.IsSet() || fSource->Flags() != value) {
                _InitFromSource();
                fFlags = value;
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithSystemDependency(bool value)
{
        if (!fSource.IsSet() || fSource->IsSystemDependency() != value) {
                _InitFromSource();
                fSystemDependency = value;
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithState(PackageState value)
{
        if (!fSource.IsSet() || fSource->State() != value) {
                _InitFromSource();
                fState = value;
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::WithDownloadProgress(float value)
{
        if (!fSource.IsSet() || fSource->DownloadProgress() != value) {
                _InitFromSource();
                fDownloadProgress = value;
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::AddInstallationLocation(int32 value)
{
        if (!fSource.IsSet() || !fSource->HasInstallationLocation(value)) {
                _InitFromSource();
                fInstallationLocations.insert(value);
        }
        return *this;
}


PackageLocalInfoBuilder&
PackageLocalInfoBuilder::ClearInstallationLocations()
{
        if (!fSource.IsSet() || fSource->CountInstallationLocations() != 0) {
                _InitFromSource();
                fInstallationLocations.clear();
        }
        return *this;
}