/*
 * Copyright 2009-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef PACKAGE_H
#define PACKAGE_H


#include <package/hpkg/DataReader.h>
#include <package/PackageFlags.h>
#include <package/PackageArchitecture.h>

#include <WeakReferenceable.h>

#include <util/DoublyLinkedList.h>
#include <util/OpenHashTable.h>
#include <util/StringHash.h>

#include <lock.h>

#include "Dependency.h"
#include "PackageNode.h"
#include "Resolvable.h"
#include "String.h"


using BPackageKit::BPackageArchitecture;
using BPackageKit::BHPKG::BAbstractBufferedDataReader;


class PackageLinkDirectory;
class PackagesDirectory;
class PackageSettings;
class Volume;
class Version;


class Package : public BWeakReferenceable,
        public DoublyLinkedListLinkImpl<Package> {
public:
                                                                Package(::Volume* volume,
                                                                        PackagesDirectory* directory,
                                                                        dev_t deviceID, ino_t nodeID);
                                                                ~Package();

                        status_t                        Init(const char* fileName);
                        status_t                        Load(const PackageSettings& settings);

                        ::Volume*                       Volume() const          { return fVolume; }
                        const String&           FileName() const        { return fFileName; }

                        void                            SetName(const String& name);
                        const String&           Name() const            { return fName; }

                        const String&           VersionedName() const
                                                                        { return fVersionedName; }

                        dev_t                           DeviceID() const
                                                                        { return fDeviceID; }
                        ino_t                           NodeID() const
                                                                        { return fNodeID; }
                        PackagesDirectory*      Directory() const
                                                                        { return fPackagesDirectory; }

                        void                            SetInstallPath(const String& installPath);
                        const String&           InstallPath() const     { return fInstallPath; }

                        void                            SetVersion(::Version* version);
                                                                        // takes over object ownership
                        ::Version*                      Version() const
                                                                        { return fVersion; }

                        void                            SetFlags(uint32 flags)
                                                                        { fFlags = flags; }
                        uint32                          Flags() const
                                                                        { return fFlags; }

                        void                            SetArchitecture(
                                                                        BPackageArchitecture architecture)
                                                                        { fArchitecture = architecture; }
                        BPackageArchitecture Architecture() const
                                                                        { return fArchitecture; }
                        const char*                     ArchitectureName() const;

                        void                            SetLinkDirectory(
                                                                        PackageLinkDirectory* linkDirectory)
                                                                        { fLinkDirectory = linkDirectory; }
                        PackageLinkDirectory* LinkDirectory() const
                                                                        { return fLinkDirectory; }

                        Package*&                       FileNameHashTableNext()
                                                                        { return fFileNameHashTableNext; }

                        void                            AddNode(PackageNode* node);
                        void                            AddResolvable(Resolvable* resolvable);
                        void                            AddDependency(Dependency* dependency);

                        int                                     Open();
                        void                            Close();

                        status_t                        CreateDataReader(const PackageData& data,
                                                                        BAbstractBufferedDataReader*& _reader);

                        const PackageNodeList& Nodes() const    { return fNodes; }
                        const ResolvableList& Resolvables() const
                                                                        { return fResolvables; }
                        const DependencyList& Dependencies() const
                                                                        { return fDependencies; }

private:
                        struct LoaderErrorOutput;
                        struct LoaderContentHandler;
                        struct LoaderContentHandlerV1;
                        struct HeapReader;
                        struct HeapReaderV1;
                        struct HeapReaderV2;
                        struct CachingPackageReader;

private:
                        status_t                        _Load(const PackageSettings& settings);
                        bool                            _InitVersionedName();

private:
                        mutex                           fLock;
                        ::Volume*                       fVolume;
                        PackagesDirectory*      fPackagesDirectory;
                        String                          fFileName;
                        String                          fName;
                        String                          fInstallPath;
                        String                          fVersionedName;
                        ::Version*                      fVersion;
                        uint32                          fFlags;
                        BPackageArchitecture fArchitecture;
                        PackageLinkDirectory* fLinkDirectory;
                        int                                     fFD;
                        uint32                          fOpenCount;
                        HeapReader*                     fHeapReader;
                        Package*                        fFileNameHashTableNext;
                        ino_t                           fNodeID;
                        dev_t                           fDeviceID;
                        PackageNodeList         fNodes;
                        ResolvableList          fResolvables;
                        DependencyList          fDependencies;
};


struct PackageCloser {
        PackageCloser(Package* package)
                :
                fPackage(package)
        {
        }

        ~PackageCloser()
        {
                if (fPackage != NULL)
                        fPackage->Close();
        }

        void Detach()
        {
                fPackage = NULL;
        }

private:
        Package*        fPackage;
};


struct PackageFileNameHashDefinition {
        typedef const char*             KeyType;
        typedef Package                 ValueType;

        size_t HashKey(const char* key) const
        {
                return hash_hash_string(key);
        }

        size_t Hash(const Package* value) const
        {
                return value->FileName().Hash();
        }

        bool Compare(const char* key, const Package* value) const
        {
                return strcmp(value->FileName(), key) == 0;
        }

        Package*& GetLink(Package* value) const
        {
                return value->FileNameHashTableNext();
        }
};


typedef BOpenHashTable<PackageFileNameHashDefinition> PackageFileNameHashTable;
typedef DoublyLinkedList<Package> PackageList;


#endif  // PACKAGE_H