/*
 * Copyright 2020 Suhel Mehta, mehtasuhel@gmail.com
 * Copyright 2008-2010, Axel Dörfler, axeld@pinc-software.de.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#ifndef INODE_H
#define INODE_H

#include "ufs2.h"
#include "Volume.h"

#define	UFS2_ROOT	((ino_t)2)


struct timeval32
{
	int tv_sec, tv_usec;
};


struct ufs2_inode {
	u_int16_t	fileMode;
	int16_t		linkCount;
	int32_t		userId;
	int32_t		groupId;
	int32_t		inodeBlockSize;
	int64_t		size;
	int64_t		inodeBlocks;
	struct		timeval32	accessTime;
	struct		timeval32	modifiedTime;
	struct		timeval32	changeTime;
	struct		timeval32	createTime;
	/* time in nano seconds */
	int32_t		nsModifiedTime;
	int32_t		nsAccessTime;
	int32_t		nsChangeTime;
	int32_t		nsCreateTime;
	int32_t		generationNumber;
	int32_t		kernelFlags;
	int32_t		statusFlags;
	int32_t		extendedAttSize; /* Extended attribute size */
	/* 2 Direct extended attribute block pointers */
	int64_t		extendedBklPtr1;
	int64_t		extendedBklPtr2;

	union {
		struct {
			int64_t		directBlockPointer[12];
			int64_t		indirectBlockPointer;
			int64_t		doubleIndriectBlockPointer;
			int64_t		tripleIndriectBlockPointer;
		};
		char	symlinkpath[120];
	};
	/* Unused but need to figure out what are they */
	int64_t		unused1;
	int64_t		unused2;
	int64_t		unused3;


	static void _DecodeTime(struct timespec& timespec, timeval32 time)
	{
		timespec.tv_sec = time.tv_sec;
		timespec.tv_nsec = time.tv_usec * 1000;
	}
	void GetAccessTime(struct timespec& timespec) const
		{ _DecodeTime(timespec, accessTime); }
	void GetChangeTime(struct timespec& timespec) const
		{ _DecodeTime(timespec, changeTime); }
	void GetModificationTime(struct timespec& timespec) const
		{ _DecodeTime(timespec, modifiedTime); }
	void GetCreationTime(struct timespec& timespec) const
		{ _DecodeTime(timespec, createTime); }
};

class Inode {
	public:
						Inode(Volume* volume, ino_t id);
						Inode(Volume* volume, ino_t id,
							const ufs2_inode& item);
						~Inode();

			status_t	InitCheck();

			ino_t		ID() const { return fID; }
//
			rw_lock*	Lock() { return& fLock; }
//
//			status_t	UpdateNodeFromDisk();

			bool		IsDirectory() const
							{ return S_ISDIR(Mode()); }
			bool		IsFile() const
							{ return S_ISREG(Mode()); }
			bool		IsSymLink() const
							{ return S_ISLNK(Mode()); }
//			status_t	CheckPermissions(int accessMode) const;

			mode_t		Mode() const { return fNode.fileMode; }
			off_t		Size() const { return fNode.size; }
			uid_t		UserID() const { return fNode.userId; }
			gid_t		GroupID() const { return fNode.groupId; }
			int16_t		LinkCount() const { return fNode.linkCount; }
			uint64_t	NumBlocks() const
							{ return fNode.inodeBlocks * (fNode.inodeBlockSize >> 9); }
			void		GetChangeTime(struct timespec& timespec) const
							{ fNode.GetChangeTime(timespec); }
			void		GetModificationTime(struct timespec& timespec) const
							{ fNode.GetModificationTime(timespec); }
			void		GetCreationTime(struct timespec& timespec) const
							{ fNode.GetCreationTime(timespec); }
			void		GetAccessTime(struct timespec& timespec) const
							{ fNode.GetAccessTime(timespec); }
			status_t	CheckPermissions(int accessMode) const;

			Volume*		GetVolume() const { return fVolume; }

			ino_t		Parent();

			off_t   	FindBlock(off_t block_number, off_t block_offset);
			status_t	ReadAt(off_t pos, uint8* buffer, size_t* length);
			status_t	ReadLink(char* buffer, size_t *_bufferSize);
//			status_t	FillGapWithZeros(off_t start, off_t end);

			void*		FileCache() const { return fCache; }
			void*		Map() const { return fMap; }

//			status_t	FindParent(ino_t* id);
	//static	Inode*		Create(Transaction& transaction, ino_t id, Inode* parent, int32 mode, uint64 size = 0, uint64 flags = 0);
private:
						Inode(Volume* volume);
						Inode(const Inode&);
						Inode& operator=(const Inode&);
			int64_t		GetBlockPointer(int ptrNumber) {
						return fNode.directBlockPointer[ptrNumber]; }

			int64_t 	GetIndirectBlockPointer() {
						return fNode.indirectBlockPointer; }

			int64_t 	GetDoubleIndirectBlockPtr() {
						return fNode.doubleIndriectBlockPointer; }

			int64_t 	GetTripleIndirectBlockPtr() {
						return fNode.tripleIndriectBlockPointer; }

//			uint64		_NumBlocks();
private:

			rw_lock		fLock;
			::Volume*	fVolume;
			ino_t		fID;
			void*		fCache;
			void*		fMap;
			status_t	fInitStatus;
			ufs2_inode	fNode;
};

#endif	// INODE_H