/*
 * Copyright 2011-2020, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Oliver Tappe <zooey@hirschkaefer.de>
 *              Andrew Lindesay <apl@lindesay.co.nz>
 */


#include <package/RepositoryConfig.h>

#include <stdlib.h>

#include <new>

#include <Directory.h>
#include <driver_settings.h>
#include <File.h>
#include <FindDirectory.h>
#include <Path.h>

#include <DriverSettings.h>


#define STORAGE_VERSION 2

#define KEY_BASE_URL_V1 "url"
#define KEY_IDENTIFIER_V1 "url"

#define KEY_BASE_URL_V2 "baseurl"
#define KEY_IDENTIFIER_V2 "identifier"
#define KEY_IDENTIFIER_V2_ALT "url"
        // should not be used any more in favour of 'identifier'

#define KEY_PRIORITY "priority"
#define KEY_CONFIG_VERSION "cfgversion"

namespace BPackageKit {


// these are mappings of known legacy identifier URLs that are possibly
// still present in some installations.  These are in pairs; the first
// being the legacy URL and the next being the replacement.  This can
// be phased out over time.

static const char* kLegacyUrlMappings[] = {
        "https://eu.hpkg.haiku-os.org/haikuports/master/x86_gcc2/current",
        "https://hpkg.haiku-os.org/haikuports/master/x86_gcc2/current",
        "https://eu.hpkg.haiku-os.org/haikuports/master/x86_64/current",
        "https://hpkg.haiku-os.org/haikuports/master/x86_64/current",
        NULL,
        NULL
};


BRepositoryConfig::BRepositoryConfig()
        :
        fInitStatus(B_NO_INIT),
        fPriority(kUnsetPriority),
        fIsUserSpecific(false)
{
}


BRepositoryConfig::BRepositoryConfig(const BEntry& entry)
{
        SetTo(entry);
}


BRepositoryConfig::BRepositoryConfig(const BString& name,
        const BString& baseURL, uint8 priority)
        :
        fInitStatus(B_OK),
        fName(name),
        fBaseURL(baseURL),
        fPriority(priority),
        fIsUserSpecific(false)
{
}


BRepositoryConfig::~BRepositoryConfig()
{
}


status_t
BRepositoryConfig::Store(const BEntry& entry) const
{
        BFile file(&entry, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
        status_t result = file.InitCheck();
        if (result != B_OK)
                return result;

        BString configString;
        configString << KEY_CONFIG_VERSION << "=" << STORAGE_VERSION << "\n";
        configString << "\n";
        configString << "# the url where the repository data can be "
                "accessed.\n";
        configString << KEY_BASE_URL_V2 << "=" << fBaseURL << "\n";
        configString << "\n";

        configString << "# an identifier for the repository that is "
                "consistent across mirrors\n";
        if (fIdentifier.IsEmpty())
                configString << "# " << KEY_IDENTIFIER_V2 << "=???\n";
        else
                configString << KEY_IDENTIFIER_V2 << "=" << fIdentifier << "\n";
        configString << "\n";

        configString << "# a deprecated copy of the ["
                << KEY_IDENTIFIER_V2 << "] key above for older os versions\n";
        if (fIdentifier.IsEmpty())
                configString << "# " << KEY_IDENTIFIER_V2_ALT << "=???\n";
        else
                configString << KEY_IDENTIFIER_V2_ALT << "=" << fIdentifier << "\n";
        configString << "\n";

        configString << KEY_PRIORITY << "=" << fPriority << "\n";

        int32 size = configString.Length();
        if ((result = file.Write(configString.String(), size)) < size)
                return (result >= 0) ? B_ERROR : result;

        return B_OK;
}


status_t
BRepositoryConfig::InitCheck() const
{
        return fInitStatus;
}


static const char*
repository_config_swap_legacy_identifier_v1(const char* identifier)
{
        for (int32 i = 0; kLegacyUrlMappings[i] != NULL; i += 2) {
                if (strcmp(identifier, kLegacyUrlMappings[i]) == 0)
                        return kLegacyUrlMappings[i + 1];
        }
        return identifier;
}


status_t
BRepositoryConfig::SetTo(const BEntry& entry)
{
        fEntry = entry;
        fInitStatus = B_NO_INIT;

        entry_ref ref;
        status_t result = entry.GetRef(&ref);
        if (result != B_OK)
                return result;

        BDriverSettings driverSettings;
        result = driverSettings.Load(ref);
        if (result != B_OK)
                return result;

        const char* version = driverSettings.GetParameterValue(KEY_CONFIG_VERSION);
        int versionNumber = version == NULL ? 1 : atoi(version);
        const char *baseUrlKey;
        const char *identifierKeys[3] = { NULL, NULL, NULL };

        switch (versionNumber) {
                case 1:
                        baseUrlKey = KEY_BASE_URL_V1;
                        identifierKeys[0] = KEY_IDENTIFIER_V1;
                        break;
                case 2:
                        baseUrlKey = KEY_BASE_URL_V2;
                        identifierKeys[0] = KEY_IDENTIFIER_V2;
                        identifierKeys[1] = KEY_IDENTIFIER_V2_ALT;
                        break;
                default:
                        return B_BAD_DATA;
        }

        const char* baseUrl = driverSettings.GetParameterValue(baseUrlKey);
        const char* priorityString = driverSettings.GetParameterValue(KEY_PRIORITY);
        const char* identifier = NULL;

        for (int32 i = 0; identifier == NULL && identifierKeys[i] != NULL; i++)
                identifier = driverSettings.GetParameterValue(identifierKeys[i]);

        if (baseUrl == NULL || *baseUrl == '\0')
                return B_BAD_DATA;
        if (identifier == NULL || *identifier == '\0')
                return B_BAD_DATA;

        if (versionNumber == 1)
                identifier = repository_config_swap_legacy_identifier_v1(identifier);

        fName = entry.Name();
        fBaseURL = baseUrl;
        fPriority = priorityString == NULL
                ? kUnsetPriority : atoi(priorityString);
        fIdentifier = identifier;

        BPath userSettingsPath;
        if (find_directory(B_USER_SETTINGS_DIRECTORY, &userSettingsPath) == B_OK) {
                BDirectory userSettingsDir(userSettingsPath.Path());
                fIsUserSpecific = userSettingsDir.Contains(&entry);
        } else
                fIsUserSpecific = false;

        fInitStatus = B_OK;

        return B_OK;
}


const BString&
BRepositoryConfig::Name() const
{
        return fName;
}


const BString&
BRepositoryConfig::BaseURL() const
{
        return fBaseURL;
}


const BString&
BRepositoryConfig::Identifier() const
{
        return fIdentifier;
}


uint8
BRepositoryConfig::Priority() const
{
        return fPriority;
}


bool
BRepositoryConfig::IsUserSpecific() const
{
        return fIsUserSpecific;
}


const BEntry&
BRepositoryConfig::Entry() const
{
        return fEntry;
}


BString
BRepositoryConfig::PackagesURL() const
{
        if (fBaseURL.IsEmpty())
                return BString();
        return BString().SetToFormat("%s/packages", fBaseURL.String());
}


void
BRepositoryConfig::SetName(const BString& name)
{
        fName = name;
}


void
BRepositoryConfig::SetBaseURL(const BString& baseURL)
{
        fBaseURL = baseURL;
}


void
BRepositoryConfig::SetIdentifier(const BString& identifier)
{
        fIdentifier = identifier;
}


void
BRepositoryConfig::SetPriority(uint8 priority)
{
        fPriority = priority;
}


void
BRepositoryConfig::SetIsUserSpecific(bool isUserSpecific)
{
        fIsUserSpecific = isUserSpecific;
}


}       // namespace BPackageKit