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


#include <fs_info.h>
#include <fs_interface.h>
#include <fs_volume.h>

#include <lock.h>


class BlockAllocator;
class Directory;
class File;
class Node;
class SymLink;
class Transaction;


class Volume {
public:
                                                                Volume(uint32 flags);
                                                                ~Volume();

                        status_t                        Init(const char* device);
                        status_t                        Init(int fd, uint64 totalBlocks);

                        status_t                        Mount(fs_volume* fsVolume);
                        void                            Unmount();

                        status_t                        Initialize(const char* name);

                        void                            GetInfo(fs_info& info);

                        status_t                        NewNode(Node* node);
                        status_t                        PublishNode(Node* node, uint32 flags);
                        status_t                        GetNode(uint64 blockIndex, Node*& _node);
                        status_t                        PutNode(Node* node);
                        status_t                        RemoveNode(Node* node);
                        status_t                        UnremoveNode(Node* node);

                        status_t                        ReadNode(uint64 blockIndex, Node*& _node);

                        status_t                        CreateDirectory(mode_t mode,
                                                                        Transaction& transaction,
                                                                        Directory*& _directory);
                        status_t                        CreateFile(mode_t mode,
                                                                        Transaction& transaction, File*& _file);
                        status_t                        CreateSymLink(mode_t mode,
                                                                        Transaction& transaction,
                                                                        SymLink*& _symLink);
                        status_t                        DeleteNode(Node* node);

                        status_t                        SetName(const char* name);

        inline  void                            TransactionStarted();
        inline  void                            TransactionFinished();

        inline  dev_t                           ID() const                      { return fFSVolume->id; }
        inline  int                                     FD() const                      { return fFD; }
        inline  bool                            IsReadOnly() const;
        inline  uint64                          TotalBlocks() const     { return fTotalBlocks; }
        inline  void*                           BlockCache() const      { return fBlockCache; }
        inline  const char*                     Name() const            { return fName; }
        inline  BlockAllocator*         GetBlockAllocator() const
                                                                        { return fBlockAllocator; }
        inline  Directory*                      RootDirectory() const
                                                                        { return fRootDirectory; }

private:
                        status_t                        _Init(uint64 totalBlocks);

                        status_t                        _CreateNode(Node* node,
                                                                        Transaction& transaction);
                        status_t                        _DeleteDirectoryEntries(Directory* directory);

private:
                        fs_volume*                      fFSVolume;
                        int                                     fFD;
                        uint32                          fFlags;
                        void*                           fBlockCache;
                        uint64                          fTotalBlocks;
                        char*                           fName;
                        BlockAllocator*         fBlockAllocator;
                        Directory*                      fRootDirectory;
                        mutex                           fLock;
                        mutex                           fTransactionLock;
};


void
Volume::TransactionStarted()
{
        mutex_lock(&fTransactionLock);
}


void
Volume::TransactionFinished()
{
        mutex_unlock(&fTransactionLock);
}


bool
Volume::IsReadOnly() const
{
        return (fFlags & B_FS_IS_READONLY) != 0;
}


#endif  // VOLUME_H