/**

 * This file is part of the CernVM File System

 */

#ifndef CVMFS_SYNC_ITEM_H_

#define CVMFS_SYNC_ITEM_H_

#include <sys/types.h>

#if !defined(__APPLE__)

#include <sys/sysmacros.h>

#endif  // __APPLE__

#include <cstring>

#include <map>

#include <string>

#include "directory_entry.h"

#include "duplex_libarchive.h"

#include "file_chunk.h"

#include "hash.h"

#include "platform.h"

#include "util/shared_ptr.h"

class IngestionSource;

namespace publish {

enum SyncItemType {

  kItemDir,

  kItemFile,

  kItemSymlink,

  kItemCharacterDevice,

  kItemBlockDevice,

  kItemFifo,

  kItemSocket,

  kItemNew,

  kItemMarker,

  kItemUnknown,

};

class SyncUnion;

/**

 * Every directory entry emitted by the FileSystemTraversal is wrapped in a

 * SyncItem structure by the factory method SyncUnion::CreateSyncItem().

 *

 * Since we are dealing with a union file system setup, this class represents

 * potentially three concrete files:

 *   - <read-only path>/<filename>                 | cf. rdonly_stat_

 *   - <scratch (read-write) branch>/<filename>    | cf. scratch_stat_

 *   - <union volume path>/<filename>              | cf. union_stat_

 *

 * This class caches stat calls to the underlying files in different branches of

 * the union file system and hides some interpretation details.

 */

class SyncItem {

  // only SyncUnion can create SyncItems (see SyncUnion::CreateSyncItem).

  // SyncUnionTarball can create SyncItemTar and SyncItemDummyDir.

 public:

  SyncItem();

  virtual ~SyncItem();

  inline bool IsTouched() const {

    return (GetRdOnlyFiletype() == GetUnionFiletype()) &&

           (GetRdOnlyFiletype() == GetScratchFiletype()) &&

           (GetUnionFiletype() == GetScratchFiletype());

  }

  }

    return WasType(kItemCharacterDevice) ||

           WasType(kItemBlockDevice) ||

           WasType(kItemFifo) ||

  }

  }

  }

  inline bool HasContentHash() const { return !content_hash_.IsNull(); }

  }

  }

  /**

   * Generates a DirectoryEntry that can be directly stored into a catalog db.

   * Note: this sets the inode fields to kInvalidInode as well as the link

   *       count to 1 if MaskHardlink() has been called before (cf. OverlayFS)

   * @return  a DirectoryEntry structure to be written into a catalog

   */

  virtual catalog::DirectoryEntryBase CreateBasicCatalogDirent() const = 0;

    return (relative_parent_path_.empty()) ?

      filename_                            :

  }

  std::string GetRdOnlyPath() const;

  std::string GetUnionPath() const;

  std::string GetScratchPath() const;

  void MarkAsWhiteout(const std::string &actual_filename);

  void MarkAsOpaqueDirectory();

  /**

   * Union file systems (i.e. OverlayFS) might not properly support hardlinks,

   * forcing us to ignore them during publishing. A 'masked hardlink' will be

   * treated as a normal file (linkcount == 1). Hence, any created hardlinks

   * will be broken up into individual files with differing inodes.

   */

  }

  unsigned int GetRdOnlyLinkcount() const;

  uint64_t GetRdOnlyInode() const;

  unsigned int GetUnionLinkcount() const;

  uint64_t GetUnionInode() const;

  uint64_t GetScratchSize() const;

  uint64_t GetRdOnlySize() const;

  }

  virtual IngestionSource *CreateIngestionSource() const = 0;

  virtual void MakePlaceholderDirectory() const = 0;

    return ((relative_parent_path_ == other.relative_parent_path_) &&

  }

 protected:

  /**

   * create a new SyncItem

   * Note: SyncItems cannot be created by any using code. SyncUnion will take

   *       care of their creating through a factory method to make sure they

   *       are initialised correctly (whiteout, hardlink handling, ...)

   *

   * @param dirPath the RELATIVE path to the file

   * @param filename the name of the file ;-)

   * @param entryType well...

   */

  SyncItem(const std::string  &relative_parent_path,

           const std::string  &filename,

           const SyncUnion    *union_engine,

           const SyncItemType  entry_type);

  }

  SyncItemType GetRdOnlyFiletype() const;

  SyncItemType GetUnionFiletype() const;

  virtual SyncItemType GetScratchFiletype() const = 0;

  /**

   * Checks if the SyncItem _is_ the given file type (file, dir, symlink, ...)

   * in the union file system volume. Hence: After the publish operation, the

   * file will be this type in CVMFS.

   * @param expected_type  the file type to be checked against

   * @return               true if file type matches the expected type

   */

  virtual bool IsType(const SyncItemType expected_type) const = 0;

  /**

   * Checks if the SyncItem _was_ the given file type (file, dir, symlink, ...)

   * in CVMFS (or the lower layer of the union file system). Hence: Before the

   * current transaction the file _was_ this type in CVMFS.

   * @param expected_type  the file type to be checked against

   * @return               true if file type was the expected type in CVMFS

   */

    }

  }

  /**

   * Structure to cache stat calls to the different file locations.

   */

  struct EntryStat {

    }

    }

    bool obtained;   /**< false at the beginning, true after first stat call */

    int error_code;  /**< errno value of the stat call */

    platform_stat64 stat;

  };

  static void StatGeneric(const std::string  &path,

                          EntryStat          *info,

                          const bool          refresh);

  SyncItemType GetGenericFiletype(const EntryStat &stat) const;

  void CheckMarkerFiles();

  mutable SyncItemType rdonly_type_;

  mutable EntryStat scratch_stat_;

  ssize_t graft_size_;

  // The hash of regular file's content

  shash::Any content_hash_;

  mutable SyncItemType scratch_type_;

 private:

  void CheckCatalogMarker();

  std::string filename_;

  std::string GetGraftMarkerPath() const;

  void CheckGraft();

  const SyncUnion *union_engine_;     /**< this SyncUnion created this object */

  mutable EntryStat rdonly_stat_;

  mutable EntryStat union_stat_;

  bool whiteout_;                     /**< SyncUnion marked this as whiteout  */

  bool opaque_;                       /**< SyncUnion marked this as opaque dir*/

  bool masked_hardlink_;              /**< SyncUnion masked out the linkcount */

  bool has_catalog_marker_;           /**< directory containing .cvmfscatalog */

  bool valid_graft_;                  /**< checksum and size in graft marker */

  bool graft_marker_present_;         /**< .cvmfsgraft-$filename exists */

  bool external_data_;

  std::string relative_parent_path_;

  /**

   * Chunklist from graft. Not initialized by default to save memory.

   */

  FileChunkList *graft_chunklist_;

  // The compression algorithm for the file

  zlib::Algorithms compression_algorithm_;

  // Lazy evaluation and caching of results of file stats

  }

  }

  virtual void StatScratch(const bool refresh = false) const = 0;

};

typedef std::map<std::string, SharedPtr<SyncItem> > SyncItemList;

  friend class SyncUnion;

  virtual catalog::DirectoryEntryBase CreateBasicCatalogDirent() const;

  virtual IngestionSource *CreateIngestionSource() const;

  virtual SyncItemType GetScratchFiletype() const;

  virtual bool IsType(const SyncItemType expected_type) const;

  }

 protected:

                 const std::string &filename, const SyncUnion *union_engine,

                 const SyncItemType entry_type)

  }

};

}  // namespace publish

#endif  // CVMFS_SYNC_ITEM_H_