/*
 * Copyright 2008-2010, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2011, Jérôme Duval, korli@users.berlios.de.
 * Copyright 2014 Haiku, Inc. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Axel Dörfler, axeld@pinc-software.de
 *              Jérôme Duval, korli@users.berlios.de
 *              John Scipione, jscipione@gmail.com
 */
#ifndef VOLUME_H
#define VOLUME_H


#include <lock.h>
#include <string.h>

#include <StorageDefs.h>
#include <util/SplayTree.h>

#include "exfat.h"


struct node_key {
        cluster_t cluster;
        uint32 offset;
};

struct node {
        struct node_key key;
        ino_t ino;
        ino_t parent;
        SplayTreeLink<struct node> nodeTreeLink;
        SplayTreeLink<struct node> inoTreeLink;
};


struct NodeTreeDefinition {
        typedef struct node_key KeyType;
        typedef struct node NodeType;

        static KeyType GetKey(const NodeType* node)
        {
                return node->key;
        }

        static SplayTreeLink<NodeType>* GetLink(NodeType* node)
        {
                return &node->nodeTreeLink;
        }

        static int Compare(KeyType key, const NodeType* node)
        {
                if (key.cluster == node->key.cluster) {
                        if (key.offset == node->key.offset)
                                return 0;
                        return key.offset < node->key.offset ? -1 : 1;
                }
                return key.cluster < node->key.cluster ? -1 : 1;
        }
};

struct InoTreeDefinition {
        typedef ino_t KeyType;
        typedef struct node NodeType;

        static KeyType GetKey(const NodeType* node)
        {
                return node->ino;
        }

        static SplayTreeLink<NodeType>* GetLink(NodeType* node)
        {
                return &node->inoTreeLink;
        }

        static int Compare(KeyType key, const NodeType* node)
        {
                if (key != node->ino)
                        return key < node->ino ? -1 : 1;
                return 0;
        }
};


typedef SplayTree<NodeTreeDefinition> NodeTree;
typedef SplayTree<InoTreeDefinition> InoTree;
class Inode;
struct InodesInoTreeDefinition;
typedef IteratableSplayTree<InodesInoTreeDefinition> InodesInoTree;
struct InodesClusterTreeDefinition;
typedef IteratableSplayTree<InodesClusterTreeDefinition> InodesClusterTree;


enum volume_flags {
        VOLUME_READ_ONLY        = 0x0001
};


class Volume {
public:
                                                                Volume(fs_volume* volume);
                                                                ~Volume();

                        status_t                        Mount(const char* device, uint32 flags);
                        status_t                        Unmount();

                        bool                            IsValidSuperBlock();
                        bool                            IsReadOnly() const
                                                                { return (fFlags & VOLUME_READ_ONLY) != 0; }

                        Inode*                          RootNode() const { return fRootNode; }
                        int                                     Device() const { return fDevice; }

                        dev_t                           ID() const
                                                                { return fFSVolume ? fFSVolume->id : -1; }
                        fs_volume*                      FSVolume() const { return fFSVolume; }
                        const char*                     Name() const;
                        void                            SetName(const char* name)
                                                                { strlcpy(fName, name, sizeof(fName)); }
                        
                        uint32                          BlockSize() const { return fBlockSize; }
                        uint32                          EntriesPerBlock() const
                                                                { return fEntriesPerBlock; }
                        uint32                          EntriesPerCluster()
                                                                { return fEntriesPerBlock
                                                                        << SuperBlock().BlocksPerClusterShift(); }
                        size_t                          ClusterSize() { return fBlockSize 
                                                                        << SuperBlock().BlocksPerClusterShift(); }
                        exfat_super_block&      SuperBlock() { return fSuperBlock; }

                        status_t                        LoadSuperBlock();

                        // cache access
                        void*                           BlockCache() { return fBlockCache; }

        static  status_t                        Identify(int fd, exfat_super_block* superBlock);

                        status_t                        ClusterToBlock(cluster_t cluster,
                                                                        fsblock_t &block);
                        Inode *                         FindInode(ino_t id);
                        Inode *                         FindInode(cluster_t cluster);
                        cluster_t                       NextCluster(cluster_t cluster);
                        ino_t                           GetIno(cluster_t cluster, uint32 offset,
                                                                        ino_t parent);
                        struct node_key*        GetNode(ino_t ino, ino_t &parent);
private:
                        ino_t                           _NextID() { return fNextId++; }

                        mutex                           fLock;
                        fs_volume*                      fFSVolume;
                        int                                     fDevice;
                        exfat_super_block       fSuperBlock;
                        char                            fName[B_FILE_NAME_LENGTH];

                        uint16                          fFlags;
                        uint32                          fBlockSize;
                        uint32                          fEntriesPerBlock;
                        Inode*                          fRootNode;
                        ino_t                           fNextId;

                        void*                           fBlockCache;
                        InodesInoTree*          fInodesInoTree;
                        InodesClusterTree*      fInodesClusterTree;
                        NodeTree                        fNodeTree;
                        InoTree                         fInoTree;
};

#endif  // VOLUME_H