/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef TRANSACTION_H
#define TRANSACTION_H


#include <fs_cache.h>

#include <util/DoublyLinkedList.h>
#include <util/OpenHashTable.h>

#include "CheckSum.h"
#include "driver/checksum_device.h"
#include "Node.h"


class PostCommitNotification;
class Volume;


enum {
        TRANSACTION_DELETE_NODE                         = 0x01,
        TRANSACTION_NODE_ALREADY_LOCKED         = 0x02,
        TRANSACTION_KEEP_NODE_LOCKED            = 0x04,
        TRANSACTION_REMOVE_NODE_ON_ERROR        = 0x08,
        TRANSACTION_UNREMOVE_NODE_ON_ERROR      = 0x10
};


class Transaction {
public:
        explicit                                        Transaction(Volume* volume);
                                                                ~Transaction();

                        int32                           ID() const      { return fID; }

                        status_t                        Start();
                        status_t                        StartAndAddNode(Node* node, uint32 flags = 0);
                        status_t                        Commit(
                                                                        const PostCommitNotification* notification1
                                                                                = NULL,
                                                                        const PostCommitNotification* notification2
                                                                                = NULL,
                                                                        const PostCommitNotification* notification3
                                                                                = NULL);
        inline  status_t                        Commit(
                                                                        const PostCommitNotification& notification);
                        void                            Abort();

        inline  bool                            IsActive() const        { return fID >= 0; }

                        status_t                        AddNode(Node* node, uint32 flags = 0);
                        status_t                        AddNodes(Node* node1, Node* node2,
                                                                        Node* node3 = NULL);
                        bool                            RemoveNode(Node* node);
                        void                            UpdateNodeFlags(Node* node, uint32 flags);

                        void                            KeepNode(Node* node);

                        bool                            IsNodeLocked(Node* node) const
                                                                        { return _GetNodeInfo(node) != NULL; }

                        status_t                        RegisterBlock(uint64 blockIndex);
                        void                            PutBlock(uint64 blockIndex, const void* data);

private:
                        struct NodeInfo : DoublyLinkedListLinkImpl<NodeInfo> {
                                Node*                   node;
                                checksumfs_node oldNodeData;
                                uint32                  flags;
                        };

                        typedef DoublyLinkedList<NodeInfo> NodeInfoList;

                        struct BlockInfo {
                                checksum_device_ioctl_check_sum indexAndCheckSum;
                                BlockInfo*                                              hashNext;
                                const void*                                             data;
                                int32                                                   refCount;
                                bool                                                    dirty;
                        };

                        struct BlockInfoHashDefinition {
                                typedef uint64          KeyType;
                                typedef BlockInfo       ValueType;

                                size_t HashKey(uint64 key) const
                                {
                                        return (size_t)key;
                                }

                                size_t Hash(const BlockInfo* value) const
                                {
                                        return HashKey(value->indexAndCheckSum.blockIndex);
                                }

                                bool Compare(uint64 key, const BlockInfo* value) const
                                {
                                        return value->indexAndCheckSum.blockIndex == key;
                                }

                                BlockInfo*& GetLink(BlockInfo* value) const
                                {
                                        return value->hashNext;
                                }
                        };

                        typedef BOpenHashTable<BlockInfoHashDefinition> BlockInfoTable;

private:
                        NodeInfo*                       _GetNodeInfo(Node* node) const;
                        void                            _DeleteNodeInfosAndUnlock(bool failed);
                        void                            _DeleteNodeInfoAndUnlock(NodeInfo* info,
                                                                        bool failed);

                        status_t                        _UpdateBlockCheckSums();
                        status_t                        _RevertBlockCheckSums();

private:
                        Volume*                         fVolume;
                        SHA256*                         fSHA256;
                        checksum_device_ioctl_check_sum* fCheckSum;
                        int32                           fID;
                        NodeInfoList            fNodeInfos;
                        BlockInfoTable          fBlockInfos;
                        uint64                          fOldFreeBlockCount;
};


status_t
Transaction::Commit(const PostCommitNotification& notification)
{
        return Commit(&notification);
}


// #pragma mark -


class PostCommitNotification {
public:
        virtual                                         ~PostCommitNotification();

        virtual void                            NotifyPostCommit() const = 0;
};


#endif  // TRANSACTION_H