/*
 * Copyright 2010 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Alex Wilson, yourpalal2@gmail.com
 */


#include "ArchivingManagers.h"

#include <syslog.h>
#include <typeinfo>

#include <StackOrHeapArray.h>


namespace BPrivate {
namespace Archiving {
        const char* kArchivableField = "_managed_archivable";
        const char* kManagedField = "_managed_archive";
}
}


using namespace BPrivate::Archiving;


BArchiveManager*
BManagerBase::ArchiveManager(const BMessage* archive)
{
        BManagerBase* manager = ManagerPointer(archive);
        if (!manager)
                return NULL;

        if (manager->fType == ARCHIVE_MANAGER)
                return static_cast<BArchiveManager*>(manager);

        debugger("Overlapping managed unarchive/archive sessions.");
        return NULL;
}


BUnarchiveManager*
BManagerBase::UnarchiveManager(const BMessage* archive)
{
        BManagerBase* manager = ManagerPointer(archive);
        if (!manager)
                return NULL;

        if (manager->fType == UNARCHIVE_MANAGER)
                return static_cast<BUnarchiveManager*>(manager);

        debugger("More calls to BUnarchiver::PrepareArchive()"
                " than BUnarchivers created.");

        return NULL;
}


// #pragma mark -


struct BArchiveManager::ArchiveInfo {
        ArchiveInfo()
                :
                token(-1),
                archive(NULL)
        {
        }


        ~ArchiveInfo()
        {
                delete archive;
        }


        int32           token;
        BMessage*       archive;
};


BArchiveManager::BArchiveManager(const BArchiver* creator)
        :
        BManagerBase(creator->ArchiveMessage(), BManagerBase::ARCHIVE_MANAGER),
        fTokenMap(),
        fCreator(creator),
        fError(B_OK)
{
}


BArchiveManager::~BArchiveManager()
{
        fTopLevelArchive->AddBool(kManagedField, true);
}


status_t
BArchiveManager::GetTokenForArchivable(BArchivable* archivable, int32& _token)
{
        if (!archivable) {
                _token = NULL_TOKEN;
                return B_OK;
        }

        TokenMap::iterator it = fTokenMap.find(archivable);

        if (it == fTokenMap.end())
                return B_ENTRY_NOT_FOUND;

        _token = it->second.token;
        return B_OK;
}


status_t
BArchiveManager::ArchiveObject(BArchivable* archivable,
        bool deep, int32& _token)
{
        if (!archivable) {
                _token = NULL_TOKEN;
                return B_OK;
        }

        ArchiveInfo& info = fTokenMap[archivable];

        status_t err = B_OK;

        if (!info.archive) {
                info.archive = new BMessage();
                info.token = fTokenMap.size() - 1;

                MarkArchive(info.archive);
                err = archivable->Archive(info.archive, deep);
        }

        if (err != B_OK) {
                fTokenMap.erase(archivable);
                        // info.archive gets deleted here
                _token = NULL_TOKEN;
        } else
                _token = info.token;

        return err;
}


bool
BArchiveManager::IsArchived(BArchivable* archivable)
{
        if (!archivable)
                return true;

        return fTokenMap.find(archivable) != fTokenMap.end();
}


status_t
BArchiveManager::ArchiverLeaving(const BArchiver* archiver, status_t err)
{
        if (fError == B_OK)
                fError = err;

        if (archiver == fCreator && fError == B_OK) {
                // first, we must sort the objects into the order they were archived in
                typedef std::pair<BMessage*, const BArchivable*> ArchivePair;
                BStackOrHeapArray<ArchivePair, 64> pairs(fTokenMap.size());

                for(TokenMap::iterator it = fTokenMap.begin(), end = fTokenMap.end();
                                it != end; it++) {
                        ArchiveInfo& info = it->second;
                        pairs[info.token].first = info.archive;
                        pairs[info.token].second = it->first;

                        // make sure fTopLevelArchive isn't deleted
                        if (info.archive == fTopLevelArchive)
                                info.archive = NULL;
                }

                int32 count = fTokenMap.size();
                for (int32 i = 0; i < count; i++) {
                        const ArchivePair& pair = pairs[i];
                        fError = pair.second->AllArchived(pair.first);

                        if (fError == B_OK && i > 0) {
                                fError = fTopLevelArchive->AddMessage(kArchivableField,
                                        pair.first);
                        }

                        if (fError != B_OK) {
                                syslog(LOG_ERR, "AllArchived failed for object of type %s.",
                                        typeid(*pairs[i].second).name());
                                break;
                        }
                }
        }

        status_t result = fError;
        if (archiver == fCreator) 
                delete this;

        return result;
}


void
BArchiveManager::RegisterArchivable(const BArchivable* archivable)
{
        if (fTokenMap.size() == 0) {
                ArchiveInfo& info = fTokenMap[archivable];
                info.archive = fTopLevelArchive;
                info.token = 0;
        }
}


// #pragma mark -


struct BUnarchiveManager::ArchiveInfo {
        ArchiveInfo()
                :
                archivable(NULL),
                archive(),
                adopted(false)
        {
        }

        bool
        operator<(const ArchiveInfo& other)
        {
                return archivable < other.archivable;
        }

        BArchivable*    archivable;
        BMessage                archive;
        bool                    adopted;
};


// #pragma mark -


BUnarchiveManager::BUnarchiveManager(BMessage* archive)
        :
        BManagerBase(archive, BManagerBase::UNARCHIVE_MANAGER),
        fObjects(NULL),
        fObjectCount(0),
        fTokenInProgress(0),
        fRefCount(0),
        fError(B_OK)
{
        archive->GetInfo(kArchivableField, NULL, &fObjectCount);
        fObjectCount++;
                // root object needs a spot too
        fObjects = new ArchiveInfo[fObjectCount];

        // fObjects[0] is a placeholder for the object that started
        // this unarchiving session.
        for (int32 i = 0; i < fObjectCount - 1; i++) {
                BMessage* into = &fObjects[i + 1].archive;
                status_t err = archive->FindMessage(kArchivableField, i, into);
                MarkArchive(into);

                if (err != B_OK)
                        syslog(LOG_ERR, "Failed to find managed archivable");
        }
}


BUnarchiveManager::~BUnarchiveManager()
{
        delete[] fObjects;
}


status_t
BUnarchiveManager::GetArchivableForToken(int32 token,
        BUnarchiver::ownership_policy owning, BArchivable*& _archivable)
{
        if (token >= fObjectCount)
                return B_BAD_VALUE;

        if (token < 0) {
                _archivable = NULL;
                return B_OK;
        }

        status_t err = B_OK;
        ArchiveInfo& info = fObjects[token];
        if (!info.archivable) {
                if (fRefCount > 0) {
                        fTokenInProgress = token;
                        if(!instantiate_object(&info.archive))
                                err = B_ERROR;
                } else {
                        syslog(LOG_ERR, "Object requested from AllUnarchived()"
                                " was not previously instantiated");
                        err = B_ERROR;
                }
        }

        if (owning == BUnarchiver::B_ASSUME_OWNERSHIP)
                info.adopted = true;

        _archivable = info.archivable;
        return err;
}


bool
BUnarchiveManager::IsInstantiated(int32 token)
{
        if (token < 0 || token >= fObjectCount)
                return false;
        return fObjects[token].archivable;
}


void
BUnarchiveManager::RegisterArchivable(BArchivable* archivable)
{
        if (!archivable)
                debugger("Cannot register NULL pointer");

        fObjects[fTokenInProgress].archivable = archivable;
        archivable->fArchivingToken = fTokenInProgress;
}


status_t
BUnarchiveManager::UnarchiverLeaving(const BUnarchiver* unarchiver,
        status_t err)
{
        if (--fRefCount >= 0 && fError == B_OK)
                fError = err;

        if (fRefCount != 0)
                return fError;

        if (fError == B_OK) {
                BArchivable* archivable = fObjects[0].archivable;
                if (archivable) {
                        fError = archivable->AllUnarchived(fTopLevelArchive);
                        archivable->fArchivingToken = NULL_TOKEN;
                }

                for (int32 i = 1; i < fObjectCount && fError == B_OK; i++) {
                        archivable = fObjects[i].archivable;
                        if (archivable) {
                                fError = archivable->AllUnarchived(&fObjects[i].archive);
                                archivable->fArchivingToken = NULL_TOKEN;
                        }
                }
                if (fError != B_OK) {
                        syslog(LOG_ERR, "Error in AllUnarchived"
                                " method of object of type %s", typeid(*archivable).name());
                }
        }

        if (fError != B_OK) {
                syslog(LOG_ERR, "An error occured during unarchival, cleaning up.");
                for (int32 i = 1; i < fObjectCount; i++) {
                        if (!fObjects[i].adopted)
                                delete fObjects[i].archivable;
                }
        }

        status_t result = fError;
        delete this;
        return result;
}


void
BUnarchiveManager::RelinquishOwnership(BArchivable* archivable)
{
        int32 token = NULL_TOKEN;
        if (archivable)
                token = archivable->fArchivingToken;

        if (token < 0 || token >= fObjectCount
                || fObjects[token].archivable != archivable)
                return;

        fObjects[token].adopted = false;
}


void
BUnarchiveManager::AssumeOwnership(BArchivable* archivable)
{
        int32 token = NULL_TOKEN;
        if (archivable)
                token = archivable->fArchivingToken;

        if (token < 0 || token >= fObjectCount
                || fObjects[token].archivable != archivable)
                return;

        fObjects[token].adopted = true;
}


void
BUnarchiveManager::Acquire()
{
        if (fRefCount >= 0)
                fRefCount++;
}