#ifndef DISK_H
#define DISK_H
/* Disk - handles BFS superblock, disk access etc.
**
** Copyright (c) 2001-2003 pinc Software. All Rights Reserved.
** Released under the terms of the MIT license.
*/


#include <BufferIO.h>
#include <File.h>
#include <Path.h>

#include <string.h>

#include "Bitmap.h"
#include "bfs.h"
#include "Cache.h"


class Disk;

class BlockRunCache : public Cache<block_run>
{
	public:
		BlockRunCache(Disk *disk);
//		~BlockRunCache();

		virtual Cacheable *NewCacheable(block_run run);

	protected:
		Disk	*fDisk;
};


class Disk : public BPositionIO
{
	public:
		Disk(const char *device, bool rawMode = false, off_t start = 0, off_t stop = -1);
		virtual ~Disk();

		status_t			InitCheck();
		const BPath			&Path() const { return fPath; }

		off_t				Size() const { return fSize; }
		off_t				NumBlocks() const { return fSuperBlock.num_blocks; }
		uint32				BlockSize() const { return fSuperBlock.block_size; }
		uint32				BlockShift() const { return fSuperBlock.block_shift; }
		uint32				AllocationGroups() const { return fSuperBlock.num_ags; }
		uint32				AllocationGroupShift() const { return fSuperBlock.ag_shift; }
		uint32				BitmapSize() const { return fBitmap.Size(); }
		off_t				LogSize() const;

		disk_super_block	*SuperBlock() { return &fSuperBlock; }
		block_run			Root() const { return fSuperBlock.root_dir; }
		block_run			Indices() const { return fSuperBlock.indices; }
		block_run			Log() const { return fSuperBlock.log_blocks; }
		Bitmap				*BlockBitmap() { return &fBitmap; }

		const char			*Name() const { return fSuperBlock.name; }
		void				SetName(const char *name) { strcpy(fSuperBlock.name,name); }

		off_t				ToOffset(block_run run) const { return ToBlock(run) << fSuperBlock.block_shift; }
		off_t				ToBlock(block_run run) const { return ((((off_t)run.allocation_group) << fSuperBlock.ag_shift) | (off_t)run.start); }
		block_run			ToBlockRun(off_t start,int16 length = 1) const;

		uint8				*ReadBlockRun(block_run run);

		status_t			ScanForSuperBlock(off_t start = 0,off_t stop = -1);
		status_t			ValidateSuperBlock();
		status_t			RecreateSuperBlock();

		status_t			DumpBootBlockToFile();

		// BPositionIO methods
		virtual ssize_t		Read(void *buffer, size_t size);
		virtual ssize_t		Write(const void *buffer, size_t size);

		virtual ssize_t		ReadAt(off_t pos, void *buffer, size_t size);
		virtual ssize_t		WriteAt(off_t pos, const void *buffer, size_t size);

		virtual off_t		Seek(off_t position, uint32 seek_mode);
		virtual off_t		Position() const;

		virtual status_t	SetSize(off_t size);

	protected:
		status_t			GetNextSpecialInode(char *,off_t *,off_t,bool);
		void				SaveInode(bfs_inode *,bool *,bfs_inode *,bool *,bfs_inode *);
		status_t			ScanForIndexAndRoot(bfs_inode *,bfs_inode *);
		status_t			DetermineBlockSize();
		status_t			ValidateSuperBlock(disk_super_block &superBlock);

		status_t			LoadBootBlock();

	protected:
		BFile				fFile;
		BBufferIO*			fBufferedFile;
		BPath				fPath;
		off_t				fRawDiskOffset;
		off_t				fSize;
		disk_super_block	fSuperBlock;
		Bitmap				fBitmap;

		block_run			fValidBlockRun;
		off_t				fValidOffset;
		off_t				fLogStart;

		BlockRunCache		fCache;

		bool				fRawMode;
};

#endif	/* DISK_H */