/*

 * 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/.

 */

#include "Zone.h"

#include "Heap.h"

#include "Strings.h"

#include "Modules.h"

#include "Packages.h"

#include "FileSystem.h"

#include "List.h"

#include "Heap-inl.h"

#include "Handles-inl.h"

using namespace ke;

Package *

Package::NewNormalized(Zone *zone, Handle<Package> parent, Handle<String> path, Handle<String> name, unsigned flags)

{

    Local<Package> package(zone, Package::cast(zone->allocate(MapKind_Package, sizeof(Package), Heap::Tenure_Old)));

    if (!package)

        return NULL;

    // :TODO: assert path, name are atoms.

    package->flags_ = flags;

    package->name_ = name;

    package->parent_ = parent;

    package->path_ = path;

    package->nativeIdentity_ = parent ? parent->getNativeIdentity() : NULL;

    return package;

}

Package *

Package::New(Zone *zone, Handle<Package> parent, const char *path, Handle<String> name, unsigned flags)

{

    Local<String> strpath(zone, zone->makeSymbol(path));

    if (!strpath)

        return NULL;

    return Package::NewNormalized(zone, parent, strpath, name, flags);

}

bool

Package::add(Zone *zone, Handle<Importable> obj)

{

    Local<Package> pkg(zone, this);

    assert(obj->parent() == pkg);

    if (!pkg->contents_) {

        pkg->contents_ = List<Importable>::New(zone);

        if (!pkg->contents_)

            return false;

    }

    if (!pkg->contents_->append(zone, obj))

        return false;

    return true;

}

Importable *

Package::import(Handle<String> name)

{

    if (!contents_)

        return NULL;

    for (unsigned i = 0; i < contents_->length(); i++) {

        Importable *obj = contents_->at(i);

        if (obj->isPackage() && Package::cast(obj)->name() == name)

            return obj;

        if (obj->isModule() && Module::cast(obj)->name() == name)

            return obj;

    }

    return NULL;

}

PackageCache::PackageCache(Zone *zone)

  : zone_(zone)

{

}

bool

PackageCache::initialize()

{

    return true;

}

void

PackageCache::accept(VirtualObjectVisitor *visitor)

{

    for (size_t i = 0; i < roots_.length(); i++)

        visitor->visit(roots_[i].address());

}

bool

PackageCache::checkfs(Handle<Package> package, PathComponent *path, Importable **out)

{

    AutoFree<char> left(strdup(package->path()->chars()));

    AutoFree<char> right(strdup(path->name->chars()));

    AutoFree<char> result;

    if (!JoinPaths(zone_, result, *left, *right))

        return false;

    OS::PathType type = OS::InspectPath(*result);

    if (type == OS::Path_Folder) {

        // If there is a folder matching this path, create a new subpackage,

        // and then either return it (if this is the last link), or keep

        // trying to import the rest of the path.

        Local<String> strpath(zone_, zone_->makeSymbol(*result));

        Local<Package> subpackage(zone_, Package::NewNormalized(zone_, package, strpath, path->name, Package::Normal));

        if (!subpackage)

            return false;

        if (!path->next) {

            *out = subpackage;

            return true;

        }

        return import(subpackage, path->next, out);

    }

    // Otherwise, look for a file ending in ".sp".

    AutoFree<char> filepath((char *)zone_->malloc(strlen(*result) + strlen(".sp") + 1));

    if (!*filepath)

        return false;

    strcpy(*filepath, *result);

    strcat(*filepath, ".sp");

    type = OS::InspectPath(*filepath);

    if (type != OS::Path_File)

        return true;

    // Create a new, empty module.

    Local<String> strpath(zone_, zone_->makeSymbol(*filepath));

    if (!strpath)

        return false;

    Local<Module> module(zone_, Module::New(zone_, package, strpath, path->name));

    if (!module || !package->add(zone_, module))

        return false;

    *out = module;

    return true;

}

bool

PackageCache::import(Handle<Package> package, PathComponent *path, Importable **out)

{

    // If the package is jailed, none of its imports are visible.

    if (package->jailed())

        return true;

    Local<Importable> obj(zone_, package->import(path->name));

    if (!obj) {

        // We couldn't find anything. Try the file system.

        if (!checkfs(package, path, out))

            return false;

        // checkfs will keep trying to import, so if it fails, we just

        // propagate up.

        return true;

    }

    // If we found an existing module, or the path has no next link, then

    // we can't go any further.

    if (obj->is(MapKind_Module) || !path->next) {

        *out = obj;

        return true;

    }

    Local<Package> subpackage(zone_, Package::cast(obj));

    return import(subpackage, path->next, out);

}

bool

PackageCache::findOrAdd(Handle<Package> package, PathComponent *path, Importable **out)

{

    // Local rooters should have initialized this, but whatever.

    assert(*out == NULL);

    // Try to import locally first.

    if (!import(package, path, out))

        return false;

    if (*out)

        return true;

    // Otherwise, search system roots.

    Local<Package> root(zone_);

    for (size_t i = 0; i < roots_.length(); i++) {

        root = roots_[i];

        if (!import(root, path, out))

            return false;

        if (*out)

            return true;

    }

    return true;

}

PackageCache::~PackageCache()

{

}