/*
 * Copyright 2017-2025, Andrew Lindesay <apl@lindesay.co.nz>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */
#include "ServerIconExportUpdateProcess.h"

#include <sys/stat.h>
#include <time.h>

#include <AutoDeleter.h>
#include <BufferIO.h>
#include <Catalog.h>
#include <FileIO.h>

#include "DataIOUtils.h"
#include "HaikuDepotConstants.h"
#include "Logger.h"
#include "PackageIconTarRepository.h"
#include "ServerHelper.h"
#include "StandardMetaDataJsonEventListener.h"
#include "StorageUtils.h"
#include "TarArchiveService.h"

#define ENTRY_PATH_METADATA "hicn/info.json"

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "ServerIconExportUpdateProcess"


/*!     This listener will scan the files that are available in the tar file and
        find the meta-data file.  This is a JSON piece of data that describes the
        timestamp of the last modified data in the tar file.  This is then used to
        establish if the server has any newer data and hence if it is worth
        downloading fresh data.  The process uses the standard HTTP
        If-Modified-Since header.
*/

class InfoJsonExtractEntryListener : public TarEntryListener
{
public:
                                                                InfoJsonExtractEntryListener();
        virtual                                         ~InfoJsonExtractEntryListener();

        virtual status_t                        Handle(
                                                                        const TarArchiveHeader& header,
                                                                        size_t offset,
                                                                        BDataIO *data);

                        BPositionIO&            GetInfoJsonData();
private:
                        BMallocIO                       fInfoJsonData;
};


InfoJsonExtractEntryListener::InfoJsonExtractEntryListener()
{
}


InfoJsonExtractEntryListener::~InfoJsonExtractEntryListener()
{
}


BPositionIO&
InfoJsonExtractEntryListener::GetInfoJsonData()
{
        return fInfoJsonData;
}


status_t
InfoJsonExtractEntryListener::Handle(const TarArchiveHeader& header, size_t offset, BDataIO* data)
{
        if (header.Length() > 0 && header.FileName() == ENTRY_PATH_METADATA) {
                status_t copyResult = DataIOUtils::CopyAll(&fInfoJsonData, data);
                if (copyResult == B_OK) {
                        HDINFO("[InfoJsonExtractEntryListener] did extract [%s]", ENTRY_PATH_METADATA);
                        fInfoJsonData.Seek(0, SEEK_SET);
                        return B_CANCELED;
                                // this will prevent further scanning of the tar file
                }
                return copyResult;
        }

        return B_OK;
}


/*!     This constructor will locate the cached data in a standardized location
 */
ServerIconExportUpdateProcess::ServerIconExportUpdateProcess(Model* model,
        uint32 serverProcessOptions)
        :
        AbstractSingleFileServerProcess(serverProcessOptions),
        fModel(model)
{
}


ServerIconExportUpdateProcess::~ServerIconExportUpdateProcess()
{
}


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


const char*
ServerIconExportUpdateProcess::Description() const
{
        return B_TRANSLATE("Synchronizing icons");
}


status_t
ServerIconExportUpdateProcess::ProcessLocalData()
{
        BPath tarPath;
        status_t result = GetLocalPath(tarPath);

        if (result == B_OK) {
                PackageIconTarRepository* tarRepository = new PackageIconTarRepository(tarPath);

                result = tarRepository->Init();

                if (result == B_OK)
                        fModel->SetIconRepository(PackageIconRepositoryRef(tarRepository, true));
                else
                        delete tarRepository;
        }

        return result;
}


status_t
ServerIconExportUpdateProcess::GetLocalPath(BPath& path) const
{
        return StorageUtils::IconTarPath(path);
}


/*!     This overridden method implementation seems inefficient because it will
        apparently scan the entire tarball for the file that it is looking for, but
        actually it will cancel the scan once it has found it's target object (the
        JSON data containing the meta-data) and by convention, the server side will
        place the meta-data as one of the first objects in the tar-ball so it will
        find it quickly.
*/

status_t
ServerIconExportUpdateProcess::IfModifiedSinceHeaderValue(BString& headerValue)
{
        headerValue.SetTo("");

        BPath tarPath;
        status_t result = GetLocalPath(tarPath);

        // early exit if the tar file is not there.

        if (result == B_OK) {
                off_t size;
                bool hasFile;

                result = StorageUtils::ExistsObject(tarPath, &hasFile, NULL, &size);

                if (result == B_OK && (!hasFile || size == 0))
                        return result;
        }

        if (result == B_OK) {
                BFile* tarIo = new BFile(tarPath.Path(), O_RDONLY);
                BBufferIO* bufferTarIo = new BBufferIO(tarIo, 10 * 1024, true);
                ObjectDeleter<BBufferIO> tarIoDeleter(bufferTarIo);

                InfoJsonExtractEntryListener* extractDataListener = new InfoJsonExtractEntryListener();
                ObjectDeleter<InfoJsonExtractEntryListener> extractDataListenerDeleter(extractDataListener);
                result = TarArchiveService::ForEachEntry(*bufferTarIo, extractDataListener);

                if (result == B_CANCELED) {
                        // the cancellation is expected because it will cancel when it finds
                        // the meta-data file to avoid any further cost of traversing the
                        // tar-ball.
                        result = B_OK;

                        StandardMetaData metaData;
                        BString metaDataJsonPath;
                        GetStandardMetaDataJsonPath(metaDataJsonPath);
                        StandardMetaDataJsonEventListener parseInfoJsonListener(metaDataJsonPath, metaData);
                        BPrivate::BJson::Parse(&(extractDataListener->GetInfoJsonData()),
                                &parseInfoJsonListener);

                        result = parseInfoJsonListener.ErrorStatus();

                        // An example of this output would be; 'Fri, 24 Oct 2014 19:32:27 +0000'

                        if (result == B_OK)
                                SetIfModifiedSinceHeaderValueFromMetaData(headerValue, metaData);
                        else
                                HDERROR("[%s] unable to parse the meta data from the tar file", Name());
                } else {
                        HDERROR("[%s] did not find the metadata [%s] in the tar", Name(), ENTRY_PATH_METADATA);
                        result = B_BAD_DATA;
                }
        }

        return result;
}


status_t
ServerIconExportUpdateProcess::GetStandardMetaDataPath(BPath& path) const
{
        return B_ERROR;
                // unsupported
}


void
ServerIconExportUpdateProcess::GetStandardMetaDataJsonPath(BString& jsonPath) const
{
        jsonPath.SetTo("$");
                // the "$" here indicates that the data is at the top level.
}


BString
ServerIconExportUpdateProcess::UrlPathComponent()
{
        return "/__pkgicon/all.tar.gz";
}