/*

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn 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 3 of the License, or (at your option)

 * any later version.

 * 

 * SourcePawn 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

 * SourcePawn. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_sp2_packages_h_

#define _include_sp2_packages_h_

#include "PoolAllocator.h"

#include "Objects.h"

#include "HashTable.h"

namespace ke {

class String;

class Module;

class Package;

class ImportStatement;

class VirtualObjectVisitor;

template <typename T> class List;

struct PathComponent : PoolObject

{

    PathComponent(ScopedRoot<String> *name, PathComponent *next)

      : name(*name),

        next(next)

    {

    }

    ScopedRoot<String> &name;

    PathComponent *next;

};

class Importable : public Object

{

  public:

    Package *parent() {

        return parent_;

    }

    String *path() {

        return path_;

    }

    String *name() {

        return name_;

    }

    bool isModule() {

        return is(MapKind_Module);

    }

    bool isPackage() {

        return is(MapKind_Package);

    }

    static inline size_t offsetOfName() {

        return OFFSETOF(Importable, name_);

    }

    static inline size_t offsetOfParent() {

        return OFFSETOF(Importable, parent_);

    }

    static inline size_t offsetOfPath() {

        return OFFSETOF(Importable, path_);

    }

    static inline Importable *cast(Object *obj) {

        assert(!obj || obj->is(MapKind_Module) || obj->is(MapKind_Package));

        return reinterpret_cast<Importable *>(obj);

    }

  protected:

    Barriered<String> name_;

    Barriered<Package> parent_;

    Barriered<String> path_;

};

// A package is a single folder in the file system, and contains any number of

// modules and sub-packages. The package hierarchy forms a tree. For simplicity

// the root of the tree is an anonymous package that contains no modules.

//

// Each package in the package hierarchy has two components of path information:

//   (1) Canonical path. This is a normalized path used to compute the paths of

//       modules.

//   (2) Name. This is the package's name as it would appear in a path

//       component. It is optional.

//

// Packages may be "hidden", meaning that even if they have names, their name

// is not accessible from any import statements. Packages may also be "jailed",

// meaning that other names in the package are not visible to each other.

//

// Packages are created in a few ways:

//

//   (1) System Roots. A system root is a default search location for imports,

//       and they are installed at the top-level of the hierarchy by the host

//       application. A system root has a unique top-level name and path.

//       System roots are always hidden.

//

//   (2) Imports. When importing, the package hierarchy may be extended as

//       new paths are discovered. Packages discovered this way are never

//       hidden or jailed.

//

//   (3) Via Package::New(), which creates an empty package. This can be used

//       to create custom packages.

class Package : public Importable

{

  public:

    enum {

        Normal = 0,

        // These must match the flags in the public API for Package.

        Hidden = (1 << 0),

        Jailed = (1 << 1)

    };

  public:

    static Package *NewNormalized(Zone *zone,

                                  Handle<Package> parent,

                                  Handle<String> path,

                                  Handle<String> name,

                                  unsigned flags);

    static Package *New(Zone *zone,

                        Handle<Package> parent,

                        const char *path,

                        Handle<String> name,

                        unsigned flags);

    bool add(Zone *zone, Handle<Importable> component);

    bool hidden() {

        return !!(flags_ & Package::Hidden);

    }

    bool jailed() {

        return !!(flags_ & Package::Jailed);

    }

    void setNativeIdentity(void *identity) {

        nativeIdentity_ = identity;

    }

    void *getNativeIdentity() {

        return nativeIdentity_;

    }

    Importable *import(Handle<String> name);

    // Begin GC descriptor.

    static inline size_t offsetOfContents() {

        return OFFSETOF(Package, contents_);

    }

    // End GC descriptor.

    static inline Package *cast(Object *obj) {

        assert(!obj || obj->is(MapKind_Package));

        return reinterpret_cast<Package *>(obj);

    }

  private:

    unsigned flags_;

    Barriered<List<Importable> > contents_;

    void *nativeIdentity_;

};

class PackageCache

{

  public:

    PackageCache(Zone *zone);

    ~PackageCache();

    bool initialize();

    bool findOrAdd(Handle<Package> package, PathComponent *path, Importable **out);

    void accept(VirtualObjectVisitor *visitor);

  private:

    bool import(Handle<Package> package, PathComponent *path, Importable **out);

    bool checkfs(Handle<Package> package, PathComponent *path, Importable **out);

  private:

    Zone *zone_;

    Vector<Unbarriered<Package> > roots_;

};

} // namespace ke

#endif // _include_sp2_packages_h_