/*
 * Copyright 2004-2013 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus, superstippi@gmx.de
 *              Andrew Bachmann
 *              John Scipione, jscipione@gmail.com
 */


#include "AddOnMonitorHandler.h"

#include <string.h>
#include <strings.h>

#include <Autolock.h>
#include <Directory.h>
#include <FindDirectory.h>
#include <Path.h>

#include <driver_settings.h>
#include <safemode_defs.h>
#include <syscalls.h>


#ifndef ADD_ON_STABLE_SECONDS
#       define ADD_ON_STABLE_SECONDS 1
#endif


AddOnMonitorHandler::AddOnMonitorHandler(const char* name)
        :
        NodeMonitorHandler(name != NULL ? name : "AddOnMonitorHandler")
{
}


AddOnMonitorHandler::~AddOnMonitorHandler()
{
        // TODO: Actually calling watch_node() here should be too late, since we
        // are likely not attached to a looper anymore, and thus consitute no valid
        // BMessenger at this time.
        DirectoryList::iterator it = fDirectories.begin();
        for (; it != fDirectories.end(); it++) {
                EntryList::iterator eiter = it->entries.begin();
                for (; eiter != it->entries.end(); eiter++)
                        watch_node(&eiter->addon_nref, B_STOP_WATCHING, this);
                watch_node(&it->nref, B_STOP_WATCHING, this);
        }
}


void
AddOnMonitorHandler::MessageReceived(BMessage* msg)
{
        if (msg->what == B_PULSE)
                _HandlePendingEntries();

        inherited::MessageReceived(msg);
}


status_t
AddOnMonitorHandler::AddDirectory(const node_ref* nref, bool sync)
{
        // Keep the looper thread locked, since this method is likely to be called
        // in a thread other than the looper thread. Otherwise we may access the
        // lists concurrently with the looper thread, when node monitor
        // notifications arrive while we are still adding initial entries from the
        // directory, or (much more likely) if the looper thread handles a pulse
        // message and wants to process pending entries while we are still adding
        // them.
        BAutolock _(Looper());

        // ignore directories added twice
        DirectoryList::iterator it = fDirectories.begin();
        for (; it != fDirectories.end(); it++) {
                if (it->nref == *nref)
                        return B_OK;
        }

        BDirectory directory(nref);
        status_t status = directory.InitCheck();
        if (status != B_OK)
                return status;

        status = watch_node(nref, B_WATCH_DIRECTORY, this);
        if (status != B_OK)
                return status;

        add_on_directory_info dirInfo;
        dirInfo.nref = *nref;
        fDirectories.push_back(dirInfo);

        add_on_entry_info entryInfo;
        entryInfo.dir_nref = *nref;

        BEntry entry;
        while (directory.GetNextEntry(&entry) == B_OK) {
                if (entry.GetName(entryInfo.name) != B_OK
                        || entry.GetNodeRef(&entryInfo.nref) != B_OK) {
                        continue;
                }

                fPendingEntries.push_back(entryInfo);
        }

        if (sync)
                _HandlePendingEntries();

        return B_OK;
}


status_t
AddOnMonitorHandler::AddAddOnDirectories(const char* leafPath)
{
        char parameter[32];
        size_t parameterLength = sizeof(parameter);
        uint32 start = 0;

        const directory_which addOnDirectories[] = {
                B_USER_NONPACKAGED_ADDONS_DIRECTORY,
                B_USER_ADDONS_DIRECTORY,
                B_SYSTEM_NONPACKAGED_ADDONS_DIRECTORY,
                B_SYSTEM_ADDONS_DIRECTORY
        };

        if (_kern_get_safemode_option(B_SAFEMODE_DISABLE_USER_ADD_ONS, parameter,
                        &parameterLength) == B_OK) {
                if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
                        || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
                        || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1")) {
                        // skip user add on directories
                        start = 2;
                }
        }

        if (_kern_get_safemode_option(B_SAFEMODE_SAFE_MODE, parameter,
                        &parameterLength) == B_OK) {
                if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
                        || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
                        || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1")) {
                        // safe mode, only B_SYSTEM_ADDONS_DIRECTORY is used
                        start = 3;
                }
        }

        for (uint32 i = start;
                        i < sizeof(addOnDirectories) / sizeof(directory_which); i++) {
                BDirectory directory;
                node_ref nodeRef;
                BPath path;
                if (find_directory(addOnDirectories[i], &path) == B_OK
                        && path.Append(leafPath) == B_OK
                        && directory.SetTo(path.Path()) == B_OK
                        && directory.GetNodeRef(&nodeRef) == B_OK) {
                        status_t result = this->AddDirectory(&nodeRef);
                        if (result != B_OK)
                                return result;
                }
        }

        return B_OK;
}


//      #pragma mark - AddOnMonitorHandler hooks


void
AddOnMonitorHandler::AddOnCreated(const add_on_entry_info* entryInfo)
{

}


void
AddOnMonitorHandler::AddOnEnabled(const add_on_entry_info* entryInfo)
{
}


void
AddOnMonitorHandler::AddOnDisabled(const add_on_entry_info* entryInfo)
{
}


void
AddOnMonitorHandler::AddOnRemoved(const add_on_entry_info* entryInfo)
{
}


//      #pragma mark - NodeMonitorHandler hooks


void
AddOnMonitorHandler::EntryCreated(const char* name, ino_t directory,
        dev_t device, ino_t node)
{
        add_on_entry_info entryInfo;
        strlcpy(entryInfo.name, name, sizeof(entryInfo.name));
        make_node_ref(device, node, &entryInfo.nref);
        make_node_ref(device, directory, &entryInfo.dir_nref);
        fPendingEntries.push_back(entryInfo);
}


void
AddOnMonitorHandler::EntryRemoved(const char* name, ino_t directory,
        dev_t device, ino_t node)
{
        node_ref entryNodeRef;
        make_node_ref(device, node, &entryNodeRef);

        // Search pending entries first, which can simply be discarded
        // We might have this entry in the pending list multiple times,
        // so we search entire list through, even after finding one.
        EntryList::iterator eiter = fPendingEntries.begin();
        while (eiter != fPendingEntries.end()) {
                if (eiter->nref == entryNodeRef)
                        eiter = fPendingEntries.erase(eiter);
                else
                        eiter++;
        }

        // Find the directory of the entry.
        DirectoryList::iterator diter = fDirectories.begin();
        if (!_FindDirectory(directory, device, diter)) {
                // If it was not found, we're done
                return;
        }

        eiter = diter->entries.begin();
        if (!_FindEntry(entryNodeRef, diter->entries, eiter)) {
                // This must be the directory, but we didn't find the entry.
                return;
        }

        add_on_entry_info info = *eiter;
        watch_node(&entryNodeRef, B_STOP_WATCHING, this);
        diter->entries.erase(eiter);

        // Start at the top again, and search until the directory we found
        // the old add-on in. If we find an add-on with the same name then
        // the old add-on was not enabled. So we deallocate the old add-on and
        // return.
        DirectoryList::iterator diter2 = fDirectories.begin();
        for (; diter2 != diter; diter2++) {
                if (_HasEntry(info.name, diter2->entries)) {
                        AddOnRemoved(&info);
                        return;
                }
        }

        // An active add-on was removed. We need to disable and then subsequently
        // deallocate it.
        AddOnDisabled(&info);
        AddOnRemoved(&info);

        // Continue searching for an add-on below us. If we find an add-on
        // with the same name, we must enable it.
        for (diter++; diter != fDirectories.end(); diter++) {
                eiter = diter->entries.begin();
                if (_FindEntry(info.name, diter->entries, eiter)) {
                        AddOnEnabled(&*eiter);
                        break;
                }
        }
}


void
AddOnMonitorHandler::EntryMoved(const char* name, const char* fromName,
        ino_t fromDirectory, ino_t toDirectory, dev_t device, ino_t node,
        dev_t nodeDevice)
{
        node_ref toNodeRef;
        make_node_ref(device, toDirectory, &toNodeRef);

        // Search the "from" and "to" directory in the known directories
        DirectoryList::iterator fromIter = fDirectories.begin();
        bool watchingFromDirectory = _FindDirectory(fromDirectory, device,
                fromIter);

        DirectoryList::iterator toIter = fDirectories.begin();
        bool watchingToDirectory = _FindDirectory(toNodeRef, toIter);

        if (!watchingFromDirectory && !watchingToDirectory) {
                // It seems the notification was for a directory we are not
                // actually watching (at least not by intention).
                return;
        }

        add_on_entry_info info;

        node_ref entryNodeRef;
        make_node_ref(device, node, &entryNodeRef);

        if (!watchingToDirectory) {
                // moved out of our view
                EntryList::iterator eiter = fromIter->entries.begin();
                if (!_FindEntry(entryNodeRef, fromIter->entries, eiter)) {
                        // we don't know anything about this entry yet.. ignore it
                        return;
                }

                // save the info and remove the entry
                info = *eiter;
                watch_node(&entryNodeRef, B_STOP_WATCHING, this);
                fromIter->entries.erase(eiter);

                // Start at the top again, and search until the from directory.
                // If we find a add-on with the same name then the moved add-on
                // was not enabled.  So we are done.
                DirectoryList::iterator diter = fDirectories.begin();
                for (; diter != fromIter; diter++) {
                        eiter = diter->entries.begin();
                        if (_FindEntry(info.name, diter->entries, eiter))
                                return;
                }

                // finally disable the add-on
                AddOnDisabled(&info);

                // Continue searching for a add-on below us.  If we find a add-on
                // with the same name, we must enable it.
                for (fromIter++; fromIter != fDirectories.end(); fromIter++) {
                        eiter = fromIter->entries.begin();
                        if (_FindEntry(info.name, fromIter->entries, eiter)) {
                                AddOnEnabled(&*eiter);
                                return;
                        }
                }

                // finally destroy the addon
                AddOnRemoved(&info);

                // done
                return;
        }

        if (!watchingFromDirectory) {
                // moved into our view

                // update the info
                strlcpy(info.name, name, sizeof(info.name));
                info.nref = entryNodeRef;
                info.dir_nref = toNodeRef;

                AddOnCreated(&info);

                // Start at the top again, and search until the to directory.
                // If we find an add-on with the same name then the moved add-on
                // is not to be enabled. So we are done.
                DirectoryList::iterator diter = fDirectories.begin();
                for (; diter != toIter; diter++) {
                        if (_HasEntry(info.name, diter->entries)) {
                                // The new add-on is being shadowed.
                                return;
                        }
                }

                // The new add-on should be enabled, but first we check to see
                // if there is an add-on below us. If we find one, we disable it.
                for (diter++ ; diter != fDirectories.end(); diter++) {
                        EntryList::iterator eiter = diter->entries.begin();
                        if (_FindEntry(info.name, diter->entries, eiter)) {
                                AddOnDisabled(&*eiter);
                                break;
                        }
                }

                // enable the new add-on
                AddOnEnabled(&info);

                // put the new entry into the target directory
                _AddNewEntry(toIter->entries, info);

                // done
                return;
        }

        // The add-on was renamed, or moved within our hierarchy.

        EntryList::iterator eiter = fromIter->entries.begin();
        if (_FindEntry(entryNodeRef, fromIter->entries, eiter)) {
                // save the old info and remove the entry
                info = *eiter;
        } else {
                // If an entry moved from one watched directory into another watched
                // directory, there will be two notifications, and this may be the
                // second. We have handled everything in the first. In that case the
                // entry was already removed from the fromDirectory and added in the
                // toDirectory list.
                return;
        }

        if (strcmp(info.name, name) == 0) {
                // It should be impossible for the name to stay the same, unless the
                // node moved in the watched hierarchy. Handle this case by removing
                // the entry and readding it. TODO: This can temporarily enable add-ons
                // which should in fact stay hidden (moving add-on from home to common
                // folder or vice versa, the system add-on should remain hidden).
                EntryRemoved(name, fromDirectory, device, node);
                info.dir_nref = toNodeRef;
                _EntryCreated(info);
        } else {
                // Erase the entry
                fromIter->entries.erase(eiter);

                // check to see if it was formerly enabled
                bool wasEnabled = true;
                DirectoryList::iterator oldIter = fDirectories.begin();
                for (; oldIter != fromIter; oldIter++) {
                        if (_HasEntry(info.name, oldIter->entries)) {
                                wasEnabled = false;
                                break;
                        }
                }

                // If it was enabled, disable it and enable the one under us, if it
                // exists.
                if (wasEnabled) {
                        AddOnDisabled(&info);
                        for (; oldIter != fDirectories.end(); oldIter++) {
                                eiter = oldIter->entries.begin();
                                if (_FindEntry(info.name, oldIter->entries, eiter)) {
                                        AddOnEnabled(&*eiter);
                                        break;
                                }
                        }
                }

                // kaboom!
                AddOnRemoved(&info);

                // set up new addon info
                strlcpy(info.name, name, sizeof(info.name));
                info.dir_nref = toNodeRef;

                // presto!
                AddOnCreated(&info);

                // check to see if we are newly enabled
                bool isEnabled = true;
                DirectoryList::iterator newIter = fDirectories.begin();
                for (; newIter != toIter; newIter++) {
                        if (_HasEntry(info.name, newIter->entries)) {
                                isEnabled = false;
                                break;
                        }
                }

                // if it is newly enabled, check under us for an enabled one, and
                // disable that first
                if (isEnabled) {
                        for (; newIter != fDirectories.end(); newIter++) {
                                eiter = newIter->entries.begin();
                                if (_FindEntry(info.name, newIter->entries, eiter)) {
                                        AddOnDisabled(&*eiter);
                                        break;
                                }
                        }
                        AddOnEnabled(&info);
                }
                // put the new entry into the target directory
                toIter->entries.push_back(info);
        }
}


void
AddOnMonitorHandler::StatChanged(ino_t node, dev_t device, int32 statFields)
{
        // This notification is received for the add-ons themselves.

        // TODO: Add the entry to the pending list, disable/enable it
        // when the modification time remains stable.

        node_ref entryNodeRef;
        make_node_ref(device, node, &entryNodeRef);

        DirectoryList::iterator diter = fDirectories.begin();
        for (; diter != fDirectories.end(); diter++) {
                EntryList::iterator eiter = diter->entries.begin();
                for (; eiter != diter->entries.end(); eiter++) {
                        if (eiter->addon_nref == entryNodeRef) {
                                // Trigger reloading of the add-on
                                const add_on_entry_info* info = &*eiter;
                                AddOnDisabled(info);
                                AddOnRemoved(info);
                                AddOnCreated(info);
                                AddOnEnabled(info);
                                return;
                        }
                }
        }
}


// #pragma mark - private


//!     Process pending entries.
void
AddOnMonitorHandler::_HandlePendingEntries()
{
        BDirectory directory;
        EntryList::iterator iter = fPendingEntries.begin();
        while (iter != fPendingEntries.end()) {
                add_on_entry_info info = *iter;

                // Initialize directory, or re-use from previous iteration, if
                // directory node_ref remained the same from the last pending entry.
                node_ref dirNodeRef;
                if (directory.GetNodeRef(&dirNodeRef) != B_OK
                        || dirNodeRef != info.dir_nref) {
                        if (directory.SetTo(&info.dir_nref) != B_OK) {
                                // invalid directory, discard this pending entry
                                iter = fPendingEntries.erase(iter);
                                continue;
                        }
                        dirNodeRef = info.dir_nref;
                }

                struct stat st;
                if (directory.GetStatFor(info.name, &st) != B_OK) {
                        // invalid file name, discard this pending entry
                        iter = fPendingEntries.erase(iter);
                        continue;
                }

                // stat units are seconds, real_time_clock units are seconds
                if (real_time_clock() - st.st_mtime < ADD_ON_STABLE_SECONDS) {
                        // entry not stable, skip the entry for this pulse
                        iter++;
                        continue;
                }

                // we are going to deal with the stable entry, so remove it
                iter = fPendingEntries.erase(iter);

                _EntryCreated(info);
        }
}


void
AddOnMonitorHandler::_EntryCreated(add_on_entry_info& info)
{
        // put the new entry into the directory info
        DirectoryList::iterator diter = fDirectories.begin();
        for (; diter != fDirectories.end(); diter++) {
                if (diter->nref == info.dir_nref) {
                        _AddNewEntry(diter->entries, info);
                        break;
                }
        }

        // report it
        AddOnCreated(&info);

        // Start at the top again, and search until the directory we put
        // the new add-on in.  If we find an add-on with the same name then
        // the new add-on should not be enabled.
        bool enabled = true;
        DirectoryList::iterator diter2 = fDirectories.begin();
        for (; diter2 != diter; diter2++) {
                if (_HasEntry(info.name, diter2->entries)) {
                        enabled = false;
                        break;
                }
        }
        if (!enabled)
                return;

        // The new add-on should be enabled, but first we check to see
        // if there is an add-on shadowed by the new one.  If we find one,
        // we disable it.
        for (diter++ ; diter != fDirectories.end(); diter++) {
                EntryList::iterator eiter = diter->entries.begin();
                if (_FindEntry(info.name, diter->entries, eiter)) {
                        AddOnDisabled(&*eiter);
                        break;
                }
        }

        // enable the new entry
        AddOnEnabled(&info);
}


bool
AddOnMonitorHandler::_FindEntry(const node_ref& entry, const EntryList& list,
        EntryList::iterator& it) const
{
        for (; EntryList::const_iterator(it) != list.end(); it++) {
                if (it->nref == entry)
                        return true;
        }
        return false;
}


bool
AddOnMonitorHandler::_FindEntry(const char* name, const EntryList& list,
        EntryList::iterator& it) const
{
        for (; EntryList::const_iterator(it) != list.end(); it++) {
                if (strcmp(it->name, name) == 0)
                        return true;
        }
        return false;
}


bool
AddOnMonitorHandler::_HasEntry(const node_ref& entry, EntryList& list) const
{
        EntryList::iterator it = list.begin();
        return _FindEntry(entry, list, it);
}


bool
AddOnMonitorHandler::_HasEntry(const char* name, EntryList& list) const
{
        EntryList::iterator it = list.begin();
        return _FindEntry(name, list, it);
}


bool
AddOnMonitorHandler::_FindDirectory(ino_t directory, dev_t device,
        DirectoryList::iterator& it) const
{
        node_ref nodeRef;
        make_node_ref(device, directory, &nodeRef);
        return _FindDirectory(nodeRef, it, fDirectories.end());
}


bool
AddOnMonitorHandler::_FindDirectory(const node_ref& directoryNodeRef,
        DirectoryList::iterator& it) const
{
        return _FindDirectory(directoryNodeRef, it, fDirectories.end());
}


bool
AddOnMonitorHandler::_FindDirectory(ino_t directory, dev_t device,
        DirectoryList::iterator& it,
        const DirectoryList::const_iterator& end) const
{
        node_ref nodeRef;
        make_node_ref(device, directory, &nodeRef);
        return _FindDirectory(nodeRef, it, end);
}


bool
AddOnMonitorHandler::_FindDirectory(const node_ref& directoryNodeRef,
        DirectoryList::iterator& it,
        const DirectoryList::const_iterator& end) const
{
        for (; DirectoryList::const_iterator(it) != end; it++) {
                if (it->nref == directoryNodeRef)
                        return true;
        }
        return false;
}


void
AddOnMonitorHandler::_AddNewEntry(EntryList& list, add_on_entry_info& info)
{
        BDirectory directory(&info.dir_nref);
        BEntry entry(&directory, info.name, true);

        node_ref addOnRef;      
        if (entry.GetNodeRef(&addOnRef) == B_OK) {
                watch_node(&addOnRef, B_WATCH_STAT, this);
                info.addon_nref = addOnRef;
        } else
                info.addon_nref = info.nref;

        list.push_back(info);
}