/*
 * Copyright 2012 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Paweł Dziepak, pdziepak@quarnos.org
 */
#ifndef REPLYINTERPRETER_H
#define REPLYINTERPRETER_H


#include <SupportDefs.h>

#include "FileInfo.h"
#include "NFS4Defs.h"
#include "RPCReply.h"


struct FSLocation {
        const char**            fRootPath;

        const char**            fLocations;
        uint32                          fCount;

                                                ~FSLocation();
};

struct FSLocations {
        const char**            fRootPath;

        FSLocation*                     fLocations;
        uint32                          fCount;

                                                ~FSLocations();
};

struct AttrValue {
                        AttrValue();
                        ~AttrValue();

        uint8   fAttribute;
        bool    fFreePointer;
        union {
                        uint32                  fValue32;
                        uint64                  fValue64;
                        void*                   fPointer;
                        FSLocations*    fLocations;
        } fData;
};

struct DirEntry {
        const char*                     fName;
        AttrValue*                      fAttrs;
        uint32                          fAttrCount;

                                                DirEntry();
                                                ~DirEntry();
};

struct LockInfo;

class ReplyInterpreter {
public:
                                                ReplyInterpreter(RPC::Reply* reply = NULL);
                                                ~ReplyInterpreter();

        inline  status_t        SetTo(RPC::Reply* reply);
        inline  void            Reset();

        inline  uint32          NFS4Error();

                        status_t        Access(uint32* supported, uint32* allowed);
                        status_t        Close();
                        status_t        Commit();
                        status_t        Create(uint64* before, uint64* after, bool& atomic);
        inline  status_t        DelegReturn();
                        status_t        GetAttr(AttrValue** attrs, uint32* count);
                        status_t        GetFH(FileHandle* fh);
                        status_t        Link(uint64* before, uint64* after, bool& atomic);
                        status_t        Lock(LockInfo* linfo);
                        status_t        LockT(uint64* pos, uint64* len, LockType* type);
                        status_t        LockU(LockInfo* linfo);
        inline  status_t        LookUp();
        inline  status_t        LookUpUp();
        inline  status_t        Nverify();
                        status_t        Open(uint32* id, uint32* seq, bool* confirm,
                                                        OpenDelegationData* delegData,
                                                        ChangeInfo* changeInfo = NULL);
        inline  status_t        OpenAttrDir();
                        status_t        OpenConfirm(uint32* stateSeq);
        inline  status_t        PutFH();
        inline  status_t        PutRootFH();
                        status_t        Read(void* buffer, uint32* size, bool* eof);
                        status_t        ReadDir(uint64* cookie, uint64* cookieVerf,
                                                        DirEntry** dirents, uint32* count, bool* eof);
                        status_t        ReadLink(void* buffer, uint32* size, uint32 maxSize);
                        status_t        Remove(uint64* before, uint64* after, bool& atomic);
                        status_t        Rename(uint64* fromBefore, uint64* fromAfter,
                                                        bool& fromAtomic, uint64* toBefore, uint64* toAfter,
                                                        bool& toAtomic);
        inline  status_t        Renew();
        inline  status_t        SaveFH();
                        status_t        SetAttr();
                        status_t        SetClientID(uint64* clientid, uint64* verifier);
        inline  status_t        SetClientIDConfirm();
        inline  status_t        Verify();
                        status_t        Write(uint32* size);
        inline  status_t        ReleaseLockOwner();

private:
                        void            _ParseHeader();

        static  const char** _GetPath(XDR::ReadStream& stream);

                        status_t        _DecodeAttrs(XDR::ReadStream& stream, AttrValue** attrs,
                                                        uint32* count);
                        status_t        _OperationError(Opcode op);

        static  status_t        _NFS4ErrorToHaiku(uint32 x);

                        uint32          fNFS4Error;
                        bool            fDecodeError;
                        RPC::Reply*     fReply;
};


inline status_t
ReplyInterpreter::SetTo(RPC::Reply* _reply)
{
        if (fReply != NULL)
                return B_DONT_DO_THAT;

        fDecodeError = false;
        fReply = _reply;

        if (fReply != NULL)
                _ParseHeader();

        return B_OK;
}


inline void
ReplyInterpreter::Reset()
{
        delete fReply;
        fReply = NULL;
        fDecodeError = false;
}


inline uint32
ReplyInterpreter::NFS4Error()
{
        return fNFS4Error;
}


inline status_t
ReplyInterpreter::DelegReturn()
{
        return _OperationError(OpDelegReturn);
}


inline status_t
ReplyInterpreter::LookUp()
{
        return _OperationError(OpLookUp);
}


inline status_t
ReplyInterpreter::LookUpUp()
{
        return _OperationError(OpLookUpUp);
}


inline status_t
ReplyInterpreter::OpenAttrDir()
{
        return _OperationError(OpOpenAttrDir);
}


inline status_t
ReplyInterpreter::Nverify()
{
        return _OperationError(OpNverify);
}


inline status_t
ReplyInterpreter::PutFH()
{
        return _OperationError(OpPutFH);
}


inline status_t
ReplyInterpreter::PutRootFH()
{
        return _OperationError(OpPutRootFH);
}


inline status_t
ReplyInterpreter::Renew()
{
        return _OperationError(OpRenew);
}


inline status_t
ReplyInterpreter::SaveFH()
{
        return _OperationError(OpSaveFH);
}


inline status_t
ReplyInterpreter::SetClientIDConfirm()
{
        return _OperationError(OpSetClientIDConfirm);
}


inline status_t
ReplyInterpreter::Verify()
{
        return _OperationError(OpVerify);
}


inline status_t
ReplyInterpreter::ReleaseLockOwner()
{
        return _OperationError(OpReleaseLockOwner);
}


#endif  // REPLYINTERPRETER_H