/*
 * Copyright 2018-2025, Andrew Lindesay <apl@lindesay.co.nz>.

 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Note that this file included code earlier from `MainWindow.cpp` and
 * copyrights have been latterly been carried across in 2021.
 */


#include "PopulatePkgSizesProcess.h"

#include <Catalog.h>

#include "Logger.h"
#include "PackageKitUtils.h"
#include "PackageUtils.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PopulatePkgSizesProcess"


PopulatePkgSizesProcess::PopulatePkgSizesProcess(Model* model)
	:
	fModel(model),
	fProgress(0)
{
}


PopulatePkgSizesProcess::~PopulatePkgSizesProcess()
{
}


const char*
PopulatePkgSizesProcess::Name() const
{
	return "PopulatePkgSizesProcess";
}


const char*
PopulatePkgSizesProcess::Description() const
{
	return B_TRANSLATE("Populating package sizes");
}


float
PopulatePkgSizesProcess::Progress()
{
	return fProgress;
}


status_t
PopulatePkgSizesProcess::RunInternal()
{
	int32 countPkgs;
	int32 countPkgSized = 0;
	int32 countPkgUnsized = 0;

	HDINFO("[%s] will populate size for pkgs without a size", Name());

	const std::vector<PackageInfoRef> packages = _SnapshotOfPackages();
	std::vector<PackageInfoRef> updatedPackages;

	countPkgs = static_cast<int32>(packages.size());

	for (int32 i = 0; i < countPkgs; i++) {
		PackageInfoRef package = packages[i];
		const char* packageName = package->Name().String();

		if (!package.IsSet())
			HDFATAL("package is not set");

		PackageLocalInfoRef localInfo = package->LocalInfo();

		if (_ShouldDeriveSize(localInfo)) {
			off_t derivedSize = _DeriveSize(package);

			if (derivedSize > 0) {
				PackageLocalInfoBuilder localInfoBuilder;

				if (localInfo.IsSet())
					localInfoBuilder = PackageLocalInfoBuilder(localInfo);

				localInfoBuilder.WithSize(derivedSize);

				PackageLocalInfoRef localInfo = localInfoBuilder.BuildRef();

				updatedPackages.push_back(
					PackageInfoBuilder(package).WithLocalInfo(localInfo).BuildRef());

				countPkgSized++;
				HDDEBUG("[%s] did derive a size for package [%s]", Name(), packageName);
			} else {
				countPkgUnsized++;
				HDDEBUG("[%s] unable to derive a size for package [%s]", Name(), packageName);
			}
		}

		_SetProgress(static_cast<float>(i) / static_cast<float>(countPkgs));
	}

	fModel->AddPackagesWithChange(updatedPackages, PKG_CHANGED_LOCAL_INFO);

	_SetProgress(1.0);

	HDINFO("[%s] did populate size for %" B_PRId32 " packages with %" B_PRId32
		   " already having a size and %" B_PRId32 " unable to derive a size",
		Name(), countPkgSized, countPkgs - (countPkgSized + countPkgUnsized), countPkgUnsized);

	return B_OK;
}


const std::vector<PackageInfoRef>
PopulatePkgSizesProcess::_SnapshotOfPackages() const
{
	return fModel->Packages();
}


bool
PopulatePkgSizesProcess::_ShouldDeriveSize(PackageLocalInfoRef localInfo) const
{
	if (!localInfo.IsSet())
		return true;

	if (localInfo->Size() > 0)
		return false;

	PackageState state = localInfo->State();

	return state == ACTIVATED || state == INSTALLED;
}


off_t
PopulatePkgSizesProcess::_DeriveSize(const PackageInfoRef package) const
{
	BPath path;
	if (PackageKitUtils::DeriveLocalFilePath(package, path) == B_OK) {
		BEntry entry(path.Path());
		struct stat s = {};
		if (entry.GetStat(&s) == B_OK)
			return s.st_size;
		else
			HDDEBUG("unable to get the size of local file [%s]", path.Path());
	} else {
		HDDEBUG("unable to get the local file of package [%s]", package->Name().String());
	}
	return 0;
}


void
PopulatePkgSizesProcess::_SetProgress(float value)
{
	if (!_ShouldProcessProgress() && value != 1.0 && (value - fProgress) < 0.1)
		return;
	fProgress = value;
	_NotifyChanged();
}