/*
 * Copyright 2013, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include "PackageDaemon.h"

#include <errno.h>
#include <string.h>

#include <Directory.h>
#include <NodeMonitor.h>

#include <AutoDeleter.h>
#include <package/DaemonDefs.h>

#include "DebugSupport.h"
#include "Root.h"
#include "Volume.h"


using namespace BPackageKit::BPrivate;


PackageDaemon::PackageDaemon(status_t* _error)
        :
        BServer(B_PACKAGE_DAEMON_APP_SIGNATURE, false, _error),
        fSystemRoot(NULL),
        fRoots(10),
        fVolumeWatcher()
{
}


PackageDaemon::~PackageDaemon()
{
        for (int32 i = 0; Root* root = fRoots.ItemAt(i); i++)
                root->ReleaseReference();
        fRoots.MakeEmpty(false);
}


status_t
PackageDaemon::Init()
{
        status_t error = fVolumeWatcher.StartWatching(BMessenger(this, this));
        if (error != B_OK) {
                ERROR("PackageDaemon::Init(): failed to start volume watching: %s\n",
                        strerror(error));
        }

        // register all packagefs volumes
        for (int32 cookie = 0;;) {
                dev_t device = next_dev(&cookie);
                if (device < 0)
                        break;

                _RegisterVolume(device);
        }

        return B_OK;
}


void
PackageDaemon::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case B_NODE_MONITOR:
                {
                        int32 opcode;
                        if (message->FindInt32("opcode", &opcode) != B_OK)
                                break;

                        if (opcode == B_DEVICE_MOUNTED)
                                _HandleVolumeMounted(message);
                        else if (opcode == B_DEVICE_UNMOUNTED)
                                _HandleVolumeUnmounted(message);
                        break;
                }

                case B_MESSAGE_GET_INSTALLATION_LOCATION_INFO:
                case B_MESSAGE_COMMIT_TRANSACTION:
                {
                        status_t error;
                        node_ref nodeRef;

                        // Get the node_ref of the filesystem root to see which one it is
                        error = message->FindInt32("volume", &nodeRef.device);
                        if (error == B_OK)
                                error = message->FindInt64("root", &nodeRef.node);

                        if (fSystemRoot != NULL && (error != B_OK
                                        || fSystemRoot->NodeRef() == nodeRef)) {
                                fSystemRoot->HandleRequest(DetachCurrentMessage());
                        } else if (error == B_OK) {
                                Root* root = _FindRoot(nodeRef);
                                if (root != NULL) {
                                        root->HandleRequest(DetachCurrentMessage());
                                }
                        }
                        break;
                }

                default:
                        BServer::MessageReceived(message);
                        break;
        }
}


status_t
PackageDaemon::_RegisterVolume(dev_t deviceID)
{
        // get the FS info and check whether this is a package FS volume at all
        fs_info info;
        status_t error = fs_stat_dev(deviceID, &info);
        if (error != 0)
                RETURN_ERROR(error);

        if (strcmp(info.fsh_name, "packagefs") != 0)
                RETURN_ERROR(B_BAD_VALUE);

        // create a volume
        Volume* volume = new(std::nothrow) Volume(this);
        if (volume == NULL)
                RETURN_ERROR(B_NO_MEMORY);
        ObjectDeleter<Volume> volumeDeleter(volume);

        node_ref rootRef;
        error = volume->Init(node_ref(info.dev, info.root), rootRef);
        if (error != B_OK)
                RETURN_ERROR(error);

        if (volume->MountType() == PACKAGE_FS_MOUNT_TYPE_CUSTOM) {
// TODO: Or maybe not?
                INFORM("skipping custom mounted volume at \"%s\"\n",
                        volume->Path().String());
                return B_OK;
        }

        // get the root for the volume and register it
        Root* root;
        error = _GetOrCreateRoot(rootRef, root);
        if (error != B_OK)
                RETURN_ERROR(error);

        error = root->RegisterVolume(volume);
        if (error != B_OK) {
                _PutRoot(root);
                RETURN_ERROR(error);
        }
        volumeDeleter.Detach();

        INFORM("volume at \"%s\" registered\n", volume->Path().String());

        return B_OK;
}


void
PackageDaemon::_UnregisterVolume(Volume* volume)
{
        volume->Unmounted();

        INFORM("volume at \"%s\" unregistered\n", volume->Path().String());

        Root* root = volume->GetRoot();
        root->UnregisterVolume(volume);

        _PutRoot(root);
}


status_t
PackageDaemon::_GetOrCreateRoot(const node_ref& nodeRef, Root*& _root)
{
        Root* root = _FindRoot(nodeRef);
        if (root != NULL) {
                root->AcquireReference();
        } else {
                root = new(std::nothrow) Root;
                if (root == NULL)
                        RETURN_ERROR(B_NO_MEMORY);
                ObjectDeleter<Root> rootDeleter(root);

                bool isSystemRoot = false;
                if (fSystemRoot == NULL) {
                        struct stat st;
                        isSystemRoot = stat("/boot", &st) == 0
                                && node_ref(st.st_dev, st.st_ino) == nodeRef;
                }

                status_t error = root->Init(nodeRef, isSystemRoot);
                if (error != B_OK)
                        RETURN_ERROR(error);

                if (!fRoots.AddItem(root))
                        RETURN_ERROR(B_NO_MEMORY);

                rootDeleter.Detach();

                if (isSystemRoot)
                        fSystemRoot = root;

                INFORM("root at \"%s\" (device: %" B_PRIdDEV ", node: %" B_PRIdINO ") "
                        "registered\n", root->Path().String(), nodeRef.device,
                        nodeRef.node);
        }

        _root = root;
        return B_OK;
}


Root*
PackageDaemon::_FindRoot(const node_ref& nodeRef) const
{
        for (int32 i = 0; Root* root = fRoots.ItemAt(i); i++) {
                if (root->NodeRef() == nodeRef)
                        return root;
        }

        return NULL;
}


void
PackageDaemon::_PutRoot(Root* root)
{
        if (root->ReleaseReference() == 1) {
                INFORM("root at \"%s\" unregistered\n", root->Path().String());
                fRoots.RemoveItem(root, true);
                        // deletes the object
        }
}


Volume*
PackageDaemon::_FindVolume(dev_t deviceID) const
{
        for (int32 i = 0; Root* root = fRoots.ItemAt(i); i++) {
                if (Volume* volume = root->FindVolume(deviceID))
                        return volume;
        }

        return NULL;
}


void
PackageDaemon::_HandleVolumeMounted(const BMessage* message)
{
        int32 device;
        if (message->FindInt32("new device", &device) != B_OK)
                return;

        // _RegisterVolume() also checks whether it is a package FS volume, so we
        // don't need to bother.
        _RegisterVolume(device);
}


void
PackageDaemon::_HandleVolumeUnmounted(const BMessage* message)
{
        int32 device;
        if (message->FindInt32("device", &device) != B_OK)
                return;

        if (Volume* volume = _FindVolume(device))
                _UnregisterVolume(volume);
}


// #pragma mark -


int
main(int argc, const char* const* argv)
{
        status_t error;
        PackageDaemon daemon(&error);
        if (error == B_OK)
                error = daemon.Init();
        if (error != B_OK) {
                FATAL("failed to init server application: %s\n", strerror(error));
                return 1;
        }

        daemon.Run();
        return 0;
}