// StatItem.h
//
// Copyright (c) 2003, Ingo Weinhold (bonefish@cs.tu-berlin.de)
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// You can alternatively use *this file* under the terms of the the MIT
// license included in this package.

#ifndef STAT_ITEM_H
#define STAT_ITEM_H

#include <sys/stat.h>

#include <SupportDefs.h>

#include "Block.h"
#include "Debug.h"
#include "endianess.h"
#include "Item.h"
#include "reiserfs.h"

// StatData
/*!
        \class StatData
        \brief Represents the on-disk structure for stat data (stat item contents).

        There are two different formats for stat data. This class hides this
        fact and provides convenient access to the fields.
*/
class StatData {
public:
        StatData() : fCurrentData(NULL), fVersion(STAT_DATA_V2) {}
        StatData(const StatData &data)
                : fCurrentData(NULL), fVersion(STAT_DATA_V2) { *this = data; }
        StatData(stat_data_v1 *data, bool clone = false)
                : fCurrentData(NULL), fVersion(STAT_DATA_V2) { SetTo(data, clone); }
        StatData(stat_data *data, bool clone = false)
                : fCurrentData(NULL), fVersion(STAT_DATA_V2) { SetTo(data, clone); }
        ~StatData() { Unset(); }

        status_t SetTo(stat_data_v1 *data, bool clone = false)
        {
                Unset();
                status_t error = B_OK;
                fVersion = STAT_DATA_V1;
                if (clone && data) {
                        fOldData = new(nothrow) stat_data_v1;
                        if (fOldData) {
                                *fOldData = *data;
                                fVersion |= ALLOCATED;
                        } else
                                error = B_NO_MEMORY;
                } else
                        fOldData = data;
                return error;
        }

        status_t SetTo(stat_data *data, bool clone = false)
        {
                Unset();
                status_t error = B_OK;
                fVersion = STAT_DATA_V2;
                if (clone && data) {
                        fCurrentData = new(nothrow) stat_data;
                        if (fCurrentData) {
                                *fCurrentData = *data;
                                fVersion |= ALLOCATED;
                        } else
                                error = B_NO_MEMORY;
                } else
                        fCurrentData = data;
                return error;
        }

        void Unset()
        {
                if (fVersion & ALLOCATED) {
                        if (GetVersion() == STAT_DATA_V2) {
                                delete fCurrentData;
                                fCurrentData = NULL;
                        } else {
                                delete fOldData;
                                fOldData = NULL;
                        }
                }
        }

        uint32 GetVersion() const { return (fVersion & VERSION_MASK); }

        uint16 GetMode() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_mode)
                                                                                        : le2h(fOldData->sd_mode));
        }

        uint32 GetNLink() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_nlink)
                                                                                        : le2h(fOldData->sd_nlink));
        }

        uint32 GetUID() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_uid)
                                                                                        : le2h(fOldData->sd_uid));
        }

        uint32 GetGID() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_gid)
                                                                                        : le2h(fOldData->sd_gid));
        }

        uint64 GetSize() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_size)
                                                                                        : le2h(fOldData->sd_size));
        }

        uint32 GetATime() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_atime)
                                                                                        : le2h(fOldData->sd_atime));
        }

        uint32 GetMTime() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_mtime)
                                                                                        : le2h(fOldData->sd_mtime));
        }

        uint32 GetCTime() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_ctime)
                                                                                        : le2h(fOldData->sd_ctime));
        }

        uint32 GetBlocks() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->sd_blocks)
                                                                                        : le2h(fOldData->u.sd_blocks));
        }

        uint32 GetRDev() const
        {
                return (GetVersion() == STAT_DATA_V2 ? le2h(fCurrentData->u.sd_rdev)
                                                                                        : le2h(fOldData->u.sd_rdev));
        }

        uint32 GetGeneration() const
        {
                return (GetVersion() == STAT_DATA_V2
                        ? le2h(fCurrentData->u.sd_generation) : 0);
        }

        bool IsDir() const { return S_ISDIR(GetMode()); }
        bool IsFile() const { return S_ISREG(GetMode()); }
        bool IsSymlink() const { return S_ISLNK(GetMode()); }
        bool IsEsoteric() const { return (!IsDir() && !IsFile() && !IsSymlink()); }


        void Dump()
        {
                PRINT(("StatData:\n"));
                PRINT(("  mode:       %hx\n", GetMode()));
                PRINT(("  nlink:      %" B_PRIu32 "\n", GetNLink()));
                PRINT(("  uid:        %" B_PRIx32 "\n", GetUID()));
                PRINT(("  gid:        %" B_PRIx32 "\n", GetGID()));
                PRINT(("  size:       %" B_PRIu64 "\n", GetSize()));
                PRINT(("  atime:      %" B_PRIu32 "\n", GetATime()));
                PRINT(("  mtime:      %" B_PRIu32 "\n", GetMTime()));
                PRINT(("  ctime:      %" B_PRIu32 "\n", GetCTime()));
                PRINT(("  blocks:     %" B_PRIu32 "\n", GetBlocks()));
                PRINT(("  rdev:       %" B_PRIu32 "\n", GetRDev()));
                PRINT(("  generation: %" B_PRIu32 "\n", GetGeneration()));
        }

        StatData &operator=(const StatData &data)
        {
                if (&data != this) {
                        if (data.GetVersion() == STAT_DATA_V2)
                                SetTo(data.fCurrentData, true);
                        else
                                SetTo(data.fOldData, true);
                }
                return *this;
        }

private:
        enum {
                VERSION_MASK    = STAT_DATA_V1 | STAT_DATA_V2,
                ALLOCATED               = 0x8000
        };

private:
        union {
                stat_data_v1    *fOldData;
                stat_data               *fCurrentData;
        };
        uint16  fVersion;
};

// StatItem
/*!
        \class StatItem
        \brief Provides access to the on-disk stat item structure.

        A stat item simply consists of StatData. This is only a convenience
        class to get hold of it.
*/
class StatItem : public Item {
public:
        StatItem() : Item() {}
        StatItem(LeafNode *node, ItemHeader *header)
                : Item(node, header) {}

        status_t GetStatData(StatData *statData, bool clone = false) const
        {
                status_t error = B_OK;
                if (GetLen() == sizeof(stat_data)) {
                        stat_data *data = (stat_data*)GetData();
                        statData->SetTo(data, clone);
                } else if (GetLen() == sizeof(stat_data_v1)) {
                        stat_data_v1 *data = (stat_data_v1*)GetData();
                        statData->SetTo(data, clone);
                } else {
                        FATAL(("WARNING: bad stat item %" B_PRId32 " "
                                "on node %" B_PRIu64 ": the item len "
                                "(%u) does not match the len of any stat data format!\n",
                                GetIndex(), fNode->GetNumber(), GetLen()));
                        error = B_BAD_DATA;
                }
                return error;
        }
};

#endif  // STAT_ITEM_H