/*
 * Copyright 2010, Haiku Inc. All rights reserved.
 * Copyright 2001-2010, Axel Dörfler, axeld@pinc-software.de.
 * This file may be used under the terms of the MIT License.
 *
 * Authors:
 *              Janito V. Ferreira Filho
 */


#include "Transaction.h"

#include <string.h>

#include <fs_cache.h>

#include "Journal.h"


//#define TRACE_EXT2
#ifdef TRACE_EXT2
#       define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
#else
#       define TRACE(x...) ;
#endif


TransactionListener::TransactionListener()
{
}


TransactionListener::~TransactionListener()
{
}


Transaction::Transaction()
        :
        fJournal(NULL),
        fParent(NULL)
{
}


Transaction::Transaction(Journal* journal)
        :
        fJournal(NULL),
        fParent(NULL)
{
        Start(journal);
}


Transaction::~Transaction()
{
        if (IsStarted())
                fJournal->Unlock(this, false);
}

status_t
Transaction::Start(Journal* journal)
{
        if (IsStarted())
                return B_OK;

        fJournal = journal;
        if (fJournal == NULL)
                return B_ERROR;
        
        status_t status = fJournal->Lock(this, false);
        if (status != B_OK)
                fJournal = NULL;

        return status;
}


status_t
Transaction::Done(bool success)
{
        if (!IsStarted())
                return B_OK;

        status_t status = fJournal->Unlock(this, success);
        
        if (status == B_OK)
                fJournal = NULL;

        return status;
}


int32
Transaction::ID() const
{
        if (!IsStarted())
                return -1;

        return fJournal->TransactionID();
}


bool
Transaction::IsStarted() const
{
        return fJournal != NULL;
}


bool
Transaction::HasParent() const
{
        return fParent != NULL;
}


status_t
Transaction::WriteBlocks(off_t blockNumber, const uint8* buffer,
        size_t numBlocks)
{
        if (!IsStarted())
                return B_NO_INIT;

        void* cache = GetVolume()->BlockCache();
        size_t blockSize = GetVolume()->BlockSize();

        for (size_t i = 0; i < numBlocks; ++i) {
                void* block = block_cache_get_empty(cache, blockNumber + i, ID());
                if (block == NULL)
                        return B_ERROR;
                
                memcpy(block, buffer, blockSize);
                buffer += blockSize;

                block_cache_put(cache, blockNumber + i);
        }

        return B_OK;
}


void
Transaction::Split()
{
        cache_start_sub_transaction(fJournal->GetFilesystemVolume()->BlockCache(),
                ID());
}


Volume*
Transaction::GetVolume() const
{
        if (!IsStarted())
                return NULL;

        return fJournal->GetFilesystemVolume();
}


void
Transaction::AddListener(TransactionListener* listener)
{
        TRACE("Transaction::AddListener()\n");
        if (!IsStarted())
                panic("Transaction is not running!");

        fListeners.Add(listener);
}


void
Transaction::RemoveListener(TransactionListener* listener)
{
        TRACE("Transaction::RemoveListener()\n");
        if (!IsStarted())
                panic("Transaction is not running!");

        fListeners.Remove(listener);
        listener->RemovedFromTransaction();
}


void
Transaction::NotifyListeners(bool success)
{
        TRACE("Transaction::NotifyListeners(): fListeners.First(): %p\n",
                fListeners.First());
        if (success) {
                TRACE("Transaction::NotifyListeners(true): Number of listeners: %"
                        B_PRId32 "\n", fListeners.Count());
        } else {
                TRACE("Transaction::NotifyListeners(false): Number of listeners: %"
                        B_PRId32 "\n", fListeners.Count());
        }
        TRACE("Transaction::NotifyListeners(): Finished counting\n");

        while (TransactionListener* listener = fListeners.RemoveHead()) {
                listener->TransactionDone(success);
                listener->RemovedFromTransaction();
        }
}


void
Transaction::MoveListenersTo(Transaction* transaction)
{
        TRACE("Transaction::MoveListenersTo()\n");
        while (TransactionListener* listener = fListeners.RemoveHead())
                transaction->fListeners.Add(listener);
}


void
Transaction::SetParent(Transaction* transaction)
{
        fParent = transaction;
}


Transaction*
Transaction::Parent() const
{
        return fParent;
}