/*
 * Copyright 2008-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT license.
 */

#include "Utilities.h"

#include <ctype.h>
#include <stdlib.h>

#if __GNUC__ < 4
#define va_copy         __va_copy
#endif

#include <Catalog.h>
#include <Locale.h>
#include <Message.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Utilities"


BString
trim_string(const char* string, size_t len)
{
        BString trimmed;
        size_t i = 0;
        bool addSpace = false;

        while (i < len) {
                // skip space block
                while (i < len && isspace(string[i]))
                        i++;

                // write non-spaced (if any)
                if (i < len && !isspace(string[i])) {
                        // pad with a single space, for all but the first block
                        if (addSpace)
                                trimmed << ' ';
                        else
                                addSpace = true;

                        // append chars
                        while (i < len && !isspace(string[i]))
                                trimmed << string[i++];
                }
        }

        return trimmed;
}


void
parse_named_url(const BString& namedURL, BString& name, BString& url)
{
        int32 urlStart = namedURL.FindFirst('<');
        int32 urlEnd = namedURL.FindLast('>');
        if (urlStart < 0 || urlEnd < 0 || urlStart + 1 >= urlEnd) {
                name = namedURL;
                url = namedURL;
                return;
        }

        url.SetTo(namedURL.String() + urlStart + 1, urlEnd - urlStart - 1);

        if (urlStart > 0)
                name = trim_string(namedURL, urlStart);
        else
                name = url;
}


// #pragma mark - StringVector


StringVector::StringVector()
        :
        fStrings(NULL),
        fCount(0)
{
}


StringVector::StringVector(const char* string,...)
        :
        fStrings(NULL),
        fCount(0)
{
        if (string == NULL)
                return;

        va_list list;
        va_start(list, string);
        SetTo(string, list);
        va_end(list);
}


StringVector::StringVector(const BMessage& strings, const char* fieldName)
        :
        fStrings(NULL),
        fCount(0)
{
        SetTo(strings, fieldName);
}


StringVector::StringVector(const StringVector& other)
        :
        fStrings(NULL),
        fCount(0)
{
        if (other.fCount == 0)
                return;

        fStrings = new BString[other.fCount];
        fCount = other.fCount;

        for (int32 i = 0; i < fCount; i++)
                fStrings[i] = other.fStrings[i];
}


StringVector::~StringVector()
{
        Unset();
}


void
StringVector::SetTo(const char* string,...)
{
        va_list list;
        va_start(list, string);
        SetTo(string, list);
        va_end(list);
}


void
StringVector::SetTo(const char* string, va_list _list)
{
        // free old strings
        Unset();

        if (string == NULL)
                return;

        // count strings
        va_list list;
        va_copy(list, _list);
        fCount = 1;
        while (va_arg(list, const char*) != NULL)
                fCount++;
        va_end(list);

        // create array and copy them
        fStrings = new BString[fCount];
        fStrings[0] = string;

        va_copy(list, _list);
        for (int32 i = 1; i < fCount; i++)
                fStrings[i] = va_arg(list, const char*);
        va_end(list);

}


void
StringVector::SetTo(const BMessage& strings, const char* fieldName,
        const char* prefix)
{
        Unset();

        type_code type;
        int32 count;
        if (strings.GetInfo(fieldName, &type, &count) != B_OK
                || type != B_STRING_TYPE) {
                return;
        }

        fStrings = new BString[count];

        for (int32 i = 0; i < count; i++) {
                if (strings.FindString(fieldName, i, &fStrings[i]) != B_OK)
                        return;

                if (prefix != NULL)
                        fStrings[i].Prepend(prefix);

                fCount++;
        }
}


void
StringVector::Unset()
{
        delete[] fStrings;
        fStrings = NULL;
        fCount = 0;
}


const char*
StringVector::StringAt(int32 index) const
{
        return (index >= 0 && index < fCount ? fStrings[index].String() : NULL);
}


// #pragma mark - PackageCredit


PackageCredit::PackageCredit(const char* packageName)
        :
        fPackageName(packageName)
{
}


PackageCredit::PackageCredit(const BMessage& packageDescription)
{
        const char* package;
        const char* copyright;
        const char* url;

        // package and copyright are mandatory
        if (packageDescription.FindString("Package", &package) != B_OK
                || packageDescription.FindString("Copyright", &copyright) != B_OK) {
                return;
        }

        // URL is optional
        if (packageDescription.FindString("URL", &url) != B_OK)
                url = NULL;

        fPackageName = package;
        fCopyrights.SetTo(packageDescription, "Copyright", COPYRIGHT_STRING);
        fLicenses.SetTo(packageDescription, "License");
        fSources.SetTo(packageDescription, "SourceURL");
        fURL = url;
}


PackageCredit::PackageCredit(const PackageCredit& other)
        :
        fPackageName(other.fPackageName),
        fCopyrights(other.fCopyrights),
        fLicenses(other.fLicenses),
        fSources(other.fSources),
        fURL(other.fURL)
{
}


PackageCredit::~PackageCredit()
{
}


bool
PackageCredit::IsValid() const
{
        // should have at least a package name and a copyright
        return fPackageName.Length() > 0 && !fCopyrights.IsEmpty();
}


bool
PackageCredit::IsBetterThan(const PackageCredit& other) const
{
        // We prefer credits with licenses.
        if (CountLicenses() > 0 && other.CountLicenses() == 0)
                return true;

        // Scan the copyrights for year numbers and let the greater one win.
        return _MaxCopyrightYear() > other._MaxCopyrightYear();
}


PackageCredit&
PackageCredit::SetCopyrights(const char* copyright,...)
{
        va_list list;
        va_start(list, copyright);
        fCopyrights.SetTo(copyright, list);
        va_end(list);

        return *this;
}


PackageCredit&
PackageCredit::SetCopyright(const char* copyright)
{
        return SetCopyrights(copyright, NULL);
}


PackageCredit&
PackageCredit::SetLicenses(const char* license,...)
{
        va_list list;
        va_start(list, license);
        fLicenses.SetTo(license, list);
        va_end(list);

        return *this;
}


PackageCredit&
PackageCredit::SetLicense(const char* license)
{
        return SetLicenses(license, NULL);
}


PackageCredit&
PackageCredit::SetSources(const char* source,...)
{
        va_list list;
        va_start(list, source);
        fSources.SetTo(source, list);
        va_end(list);

        return *this;
}


PackageCredit&
PackageCredit::SetSource(const char* source)
{
        return SetSources(source, NULL);
}


PackageCredit&
PackageCredit::SetURL(const char* url)
{
        fURL = url;

        return *this;
}


const char*
PackageCredit::PackageName() const
{
        return fPackageName.String();
}


const StringVector&
PackageCredit::Copyrights() const
{
        return fCopyrights;
}


int32
PackageCredit::CountCopyrights() const
{
        return fCopyrights.CountStrings();
}


const char*
PackageCredit::CopyrightAt(int32 index) const
{
        return fCopyrights.StringAt(index);
}


const StringVector&
PackageCredit::Licenses() const
{
        return fLicenses;
}


int32
PackageCredit::CountLicenses() const
{
        return fLicenses.CountStrings();
}


const char*
PackageCredit::LicenseAt(int32 index) const
{
        return fLicenses.StringAt(index);
}


const StringVector&
PackageCredit::Sources() const
{
        return fSources;
}


int32
PackageCredit::CountSources() const
{
        return fSources.CountStrings();
}


const char*
PackageCredit::SourceAt(int32 index) const
{
        return fSources.StringAt(index);
}


const char*
PackageCredit::URL() const
{
        return fURL.Length() > 0 ? fURL.String() : NULL;
}


/*static*/ bool
PackageCredit::NameLessInsensitive(const PackageCredit* a,
        const PackageCredit* b)
{
        return a->fPackageName.ICompare(b->fPackageName) < 0;
}


int
PackageCredit::_MaxCopyrightYear() const
{
        int maxYear = 0;

        for (int32 i = 0; const char* string = CopyrightAt(i); i++) {
                // iterate through the numbers
                int32 start = 0;
                while (true) {
                        // find the next number start
                        while (string[start] != '\0' && !isdigit(string[start]))
                                start++;

                        if (string[start] == '\0')
                                break;

                        // find the end
                        int32 end = start + 1;
                        while (string[end] != '\0' && isdigit(string[end]))
                                end++;

                        if (end - start == 4) {
                                int year = atoi(string + start);
                                if (year > 1900 && year < 2200 && year > maxYear)
                                        maxYear = year;
                        }

                        start = end;
                }
        }

        return maxYear;
}