//----------------------------------------------------------------------
//  This software is part of the Haiku distribution and is covered
//  by the MIT License.
//---------------------------------------------------------------------
/*!
        \file ResourceStrings.cpp
        BResourceStrings implementation.
*/

#include <ResourceStrings.h>

#include <new>
#include <stdlib.h>
#include <string.h>

#include <Entry.h>
#include <File.h>
#include <Resources.h>
#include <String.h>

#include <AppMisc.h>

using namespace std;


// constructor
/*! \brief Creates an object initialized to the application's string resources.
*/
BResourceStrings::BResourceStrings()
                                : _string_lock(),
                                  _init_error(),
                                  fFileRef(),
                                  fResources(NULL),
                                  fHashTable(NULL),
                                  fHashTableSize(0),
                                  fStringCount(0)
{
        SetStringFile(NULL);
}

// constructor
/*! \brief Creates an object initialized to the string resources of the
        file referred to by the supplied entry_ref.
        \param ref the entry_ref referring to the resource file
*/
BResourceStrings::BResourceStrings(const entry_ref &ref)
                                : _string_lock(),
                                  _init_error(),
                                  fFileRef(),
                                  fResources(NULL),
                                  fHashTable(NULL),
                                  fHashTableSize(0),
                                  fStringCount(0)
{
        SetStringFile(&ref);
}

// destructor
/*!     \brief Frees all resources associated with the BResourceStrings object.
*/
BResourceStrings::~BResourceStrings()
{
        _string_lock.Lock();
        _Cleanup();
}

// InitCheck
/*!     \brief Returns the status of the last initialization via contructor or
        SetStringFile().
        \return \c B_OK, if the object is properly initialized, an error code
                        otherwise.
*/
status_t
BResourceStrings::InitCheck()
{
        return _init_error;
}

// NewString
/*!     \brief Finds and returns a copy of the string identified by the supplied
        ID.
        The caller is responsible for deleting the returned BString object.
        \param id the ID of the requested string
        \return
        - A string object containing the requested string,
        - \c NULL, if the object is not properly initialized or there is no string
          with ID \a id.
*/
BString *
BResourceStrings::NewString(int32 id)
{
//      _string_lock.Lock();
        BString *result = NULL;
        if (const char *str = FindString(id))
                result = new(nothrow) BString(str);
//      _string_lock.Unlock();
        return result;
}

// FindString
/*!     \brief Finds and returns the string identified by the supplied ID.
        The caller must not free the returned string. It belongs to the
        BResourceStrings object and is valid until the object is destroyed or set
        to another file.
        \param id the ID of the requested string
        \return
        - The requested string,
        - \c NULL, if the object is not properly initialized or there is no string
          with ID \a id.
*/
const char *
BResourceStrings::FindString(int32 id)
{
        _string_lock.Lock();
        const char *result = NULL;
        if (InitCheck() == B_OK) {
                if (_string_id_hash *entry = _FindString(id))
                        result = entry->data;
        }
        _string_lock.Unlock();
        return result;
}

// SetStringFile
/*!     \brief Re-initialized the BResourceStrings object to the file referred to
        by the supplied entry_ref.
        If the supplied entry_ref is \c NULL, the object is initialized to the
        application file.
        \param ref the entry_ref referring to the resource file
*/
status_t
BResourceStrings::SetStringFile(const entry_ref *ref)
{
        _string_lock.Lock();
        // cleanup
        _Cleanup();
        // get the ref (if NULL, take the application)
        status_t error = B_OK;
        entry_ref fileRef;
        if (ref) {
                fileRef = *ref;
                fFileRef = *ref;
        } else
                error = BPrivate::get_app_ref(&fileRef);
        // get the BResources
        if (error == B_OK) {
                BFile file(&fileRef, B_READ_ONLY);
                error = file.InitCheck();
                if (error == B_OK) {
                        fResources = new(nothrow) BResources;
                        if (fResources)
                                error = fResources->SetTo(&file);
                        else
                                error = B_NO_MEMORY;
                }
        }
        // read the strings
        if (error == B_OK) {
                // count them first
                fStringCount = 0;
                int32 id;
                const char *name;
                size_t length;
                while (fResources->GetResourceInfo(RESOURCE_TYPE, fStringCount, &id,
                                                                                   &name, &length)) {
                        fStringCount++;
                }
                // allocate a hash table with a nice size
                // I don't have a heuristic at hand, so let's simply take the count.
                error = _Rehash(fStringCount);
                // load the resources
                for (int32 i = 0; error == B_OK && i < fStringCount; i++) {
                        if (!fResources->GetResourceInfo(RESOURCE_TYPE, i, &id, &name,
                                                                                         &length)) {
                                error = B_ERROR;
                        }
                        if (error == B_OK) {
                                const void *data
                                        = fResources->LoadResource(RESOURCE_TYPE, id, &length);
                                if (data) {
                                        _string_id_hash *entry = NULL;
                                        if (length == 0)
                                                entry = _AddString(NULL, id, false);
                                        else
                                                entry = _AddString((char*)data, id, false);
                                        if (!entry)
                                                error = B_ERROR;
                                } else
                                        error = B_ERROR;
                        }
                }
        }
        // if something went wrong, cleanup the mess
        if (error != B_OK)
                _Cleanup();
        _init_error = error;
        _string_lock.Unlock();
        return error;
}

// GetStringFile
/*!     \brief Returns an entry_ref referring to the resource file, the object is
        currently initialized to.
        \param outRef a pointer to an entry_ref variable to be initialized to the
                   requested entry_ref
        \return
        - \c B_OK: Everything went fine.
        - \c B_BAD_VALUE: \c NULL \a outRef.
        - other error codes
*/
status_t
BResourceStrings::GetStringFile(entry_ref *outRef)
{
        status_t error = (outRef ? B_OK : B_BAD_VALUE);
        if (error == B_OK)
                error = InitCheck();
        if (error == B_OK) {
                if (fFileRef == entry_ref())
                        error = B_ENTRY_NOT_FOUND;
                else
                        *outRef = fFileRef;
        }
        return error;
}


// _Cleanup
/*!     \brief Frees all resources associated with this object and sets all
        member variables to harmless values.
*/
void
BResourceStrings::_Cleanup()
{
//      _string_lock.Lock();
        _MakeEmpty();
        delete[] fHashTable;
        fHashTable = NULL;
        delete fResources;
        fResources = NULL;
        fFileRef = entry_ref();
        fHashTableSize = 0;
        fStringCount = 0;
        _init_error = B_OK;
//      _string_lock.Unlock();
}

// _MakeEmpty
/*!     \brief Empties the id->string hash table.
*/
void
BResourceStrings::_MakeEmpty()
{
        if (fHashTable) {
                for (int32 i = 0; i < fHashTableSize; i++) {
                        while (_string_id_hash *entry = fHashTable[i]) {
                                fHashTable[i] = entry->next;
                                delete entry;
                        }
                }
                fStringCount = 0;
        }
}

// _Rehash
/*!     \brief Resizes the id->string hash table to the supplied size.
        \param newSize the new hash table size
        \return
        - \c B_OK: Everything went fine.
        - \c B_NO_MEMORY: Insuffient memory.
*/
status_t
BResourceStrings::_Rehash(int32 newSize)
{
        status_t error = B_OK;
        if (newSize > 0 && newSize != fHashTableSize) {
                // alloc a new table and fill it with NULL
                _string_id_hash **newHashTable
                        = new(nothrow) _string_id_hash*[newSize];
                if (newHashTable) {
                        memset(newHashTable, 0, sizeof(_string_id_hash*) * newSize);
                        // move the entries to the new table
                        if (fHashTable && fHashTableSize > 0 && fStringCount > 0) {
                                for (int32 i = 0; i < fHashTableSize; i++) {
                                        while (_string_id_hash *entry = fHashTable[i]) {
                                                fHashTable[i] = entry->next;
                                                int32 newPos = entry->id % newSize;
                                                entry->next = newHashTable[newPos];
                                                newHashTable[newPos] = entry;
                                        }
                                }
                        }
                        // set the new table
                        delete[] fHashTable;
                        fHashTable = newHashTable;
                        fHashTableSize = newSize;
                } else
                        error = B_NO_MEMORY;
        }
        return error;
}

// _AddString
/*!     \brief Adds an entry to the id->string hash table.
        If there is already a string with the given ID, it will be replaced.
        \param str the string
        \param id the id of the string
        \param wasMalloced if \c true, the object will be responsible for
                   free()ing the supplied string
        \return the hash table entry or \c NULL, if something went wrong
*/
BResourceStrings::_string_id_hash *
BResourceStrings::_AddString(char *str, int32 id, bool wasMalloced)
{
        _string_id_hash *entry = NULL;
        if (fHashTable && fHashTableSize > 0)
                entry = new(nothrow) _string_id_hash;
        if (entry) {
                entry->assign_string(str, false);
                entry->id = id;
                entry->data_alloced = wasMalloced;
                int32 pos = id % fHashTableSize;
                entry->next = fHashTable[pos];
                fHashTable[pos] = entry;
        }
        return entry;
}

// _FindString
/*!     \brief Returns the hash table entry for a given ID.
        \param id the ID
        \return the hash table entry or \c NULL, if there is no entry with this ID
*/
BResourceStrings::_string_id_hash *
BResourceStrings::_FindString(int32 id)
{
        _string_id_hash *entry = NULL;
        if (fHashTable && fHashTableSize > 0) {
                int32 pos = id % fHashTableSize;
                entry = fHashTable[pos];
                while (entry != NULL && entry->id != id)
                        entry = entry->next;
        }
        return entry;
}


// FBC
status_t BResourceStrings::_Reserved_ResourceStrings_0(void *) { return 0; }
status_t BResourceStrings::_Reserved_ResourceStrings_1(void *) { return 0; }
status_t BResourceStrings::_Reserved_ResourceStrings_2(void *) { return 0; }
status_t BResourceStrings::_Reserved_ResourceStrings_3(void *) { return 0; }
status_t BResourceStrings::_Reserved_ResourceStrings_4(void *) { return 0; }
status_t BResourceStrings::_Reserved_ResourceStrings_5(void *) { return 0; }


// _string_id_hash

// constructor
/*!     \brief Creates an uninitialized hash table entry.
*/
BResourceStrings::_string_id_hash::_string_id_hash()
        : next(NULL),
          id(0),
          data(NULL),
          data_alloced(false)
{
}

// destructor
/*!     \brief Frees all resources associated with this object.
        Only if \c data_alloced is \c true, the string will be free()d.
*/
BResourceStrings::_string_id_hash::~_string_id_hash()
{
        if (data_alloced)
                free(data);
}

// assign_string
/*!     \brief Sets the string of the hash table entry.
        \param str the string
        \param makeCopy If \c true, the supplied string is copied and the copy
                   will be freed on destruction. If \c false, the entry points to the
                   supplied string. It will not be freed() on destruction.
*/
void
BResourceStrings::_string_id_hash::assign_string(const char *str,
                                                                                                 bool makeCopy)
{
        if (data_alloced)
                free(data);
        data = NULL;
        data_alloced = false;
        if (str) {
                if (makeCopy) {
                        data = strdup(str);
                        data_alloced = true;
                } else
                        data = const_cast<char*>(str);
        }
}