/*
 * Copyright 1999-2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Jeremy Friesner
 *              Jessica Hamilton, jessica.l.hamilton@gmail.com
 *              John Scipione, jscipione@gmail.com
 */


#include "KeyCommandMap.h"

#include <stdio.h>

#include <Beep.h>
#include <Entry.h>
#include <File.h>
#include <FindDirectory.h>
#include <MessageFilter.h>
#include <NodeMonitor.h>
#include <OS.h>
#include <Path.h>
#include <PathFinder.h>
#include <PathMonitor.h>
#include <StringList.h>
#include <WindowScreen.h>

#include "BitFieldTesters.h"
#include "CommandActuators.h"
#include "ShortcutsFilterConstants.h"


#define FILE_UPDATED 'fiUp'


//      #pragma mark - hks


class hks {
public:
        hks(int32 key, BitFieldTester* tester, CommandActuator* actuator,
                const BMessage& actuatorMessage)
                :
                fKey(key),
                fTester(tester),
                fActuator(actuator),
                fActuatorMessage(actuatorMessage)
        {
        }

        ~hks()
        {
                delete fActuator;
                delete fTester;
        }

        int32 GetKey() const
                { return fKey; }
        bool DoModifiersMatch(uint32 bits) const
                { return fTester->IsMatching(bits); }
        const BMessage& GetActuatorMessage() const
                { return fActuatorMessage; }
        CommandActuator* GetActuator()
                { return fActuator; }

private:
        int32                           fKey;
        BitFieldTester*         fTester;
        CommandActuator*        fActuator;
        const BMessage          fActuatorMessage;
};


//      #pragma mark - KeyCommandMap


KeyCommandMap::KeyCommandMap(const char* file)
        :
        BLooper("Shortcuts map watcher"),
        fSpecs(NULL)
{
        fFileName = new char[strlen(file) + 1];
        strcpy(fFileName, file);

        BEntry fileEntry(fFileName);

        BPrivate::BPathMonitor::StartWatching(fFileName,
                B_WATCH_STAT | B_WATCH_FILES_ONLY, this);

        if (fileEntry.InitCheck() == B_OK) {
                BMessage message(FILE_UPDATED);
                PostMessage(&message);
        }

        fPort = create_port(1, SHORTCUTS_CATCHER_PORT_NAME);
        _PutMessageToPort();
                // advertise our BMessenger to the world
}


KeyCommandMap::~KeyCommandMap()
{
        if (fPort >= 0)
                close_port(fPort);

        for (int32 i = fInjects.CountItems() - 1; i >= 0; i--)
                delete (BMessage*)fInjects.ItemAt(i);

        BPrivate::BPathMonitor::StopWatching(BMessenger(this, this));
                // don't know if this is necessary, but it can't hurt

        _DeleteHKSList(fSpecs);

        delete[] fFileName;
}


void
KeyCommandMap::MouseMessageReceived(const BMessage* message)
{
        // Save the mouse state for later...
        fLastMouseMessage = *message;
}


filter_result
KeyCommandMap::KeyEvent(const BMessage* keyMessage, BList* outList,
        const BMessenger& sendTo)
{
        filter_result result = B_DISPATCH_MESSAGE;
        uint32 modifiers;
        int32 key;

        if (keyMessage->FindInt32("modifiers", (int32*)&modifiers) == B_OK
                && keyMessage->FindInt32("key", &key) == B_OK
                && fSpecs != NULL && fSyncSpecs.Lock()) {
                int32 count = fSpecs->CountItems();
                for (int32 i = 0; i < count; i++) {
                        hks* next = (hks*)fSpecs->ItemAt(i);

                        if (key == next->GetKey() && next->DoModifiersMatch(modifiers)) {
                                void* asyncData = NULL;
                                result = next->GetActuator()->KeyEvent(keyMessage, outList,
                                        &asyncData, &fLastMouseMessage);

                                if (asyncData != NULL) {
                                        BMessage newMessage(*keyMessage);
                                        newMessage.AddMessage("act", &next->GetActuatorMessage());
                                        newMessage.AddPointer("adata", asyncData);
                                        sendTo.SendMessage(&newMessage);
                                }
                        }
                }
                fSyncSpecs.Unlock();
        }

        return result;
}


void
KeyCommandMap::DrainInjectedEvents(const BMessage* keyMessage, BList* outList,
        const BMessenger& sendTo)
{
        BList temp;
        if (fSyncSpecs.Lock()) {
                temp = fInjects;
                fInjects.MakeEmpty();
                fSyncSpecs.Unlock();
        }

        int32 count = temp.CountItems();
        for (int32 i = 0; i < count; i++) {
                BMessage* message = (BMessage*)temp.ItemAt(i);

                BArchivable* archive = instantiate_object(message);
                if (archive != NULL) {
                        CommandActuator* actuator
                                = dynamic_cast<CommandActuator*>(archive);
                        if (actuator != NULL) {
                                BMessage newMessage(*keyMessage);
                                newMessage.what = B_KEY_DOWN;

                                void* asyncData = NULL;
                                actuator->KeyEvent(&newMessage, outList, &asyncData,
                                        &fLastMouseMessage);

                                if (asyncData != NULL) {
                                        newMessage.AddMessage("act", message);
                                        newMessage.AddPointer("adata", asyncData);
                                        sendTo.SendMessage(&newMessage);
                                }
                        }
                        delete archive;
                }
                delete message;
        }
}


void
KeyCommandMap::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case EXECUTE_COMMAND:
                {
                        BMessage actuatorMessage;
                        if (message->FindMessage("act", &actuatorMessage) == B_OK) {
                                if (fSyncSpecs.Lock()) {
                                        fInjects.AddItem(new BMessage(actuatorMessage));
                                        fSyncSpecs.Unlock();

                                        // This evil hack forces input_server to call Filter() on
                                        // us so we can process the injected event.
                                        BPoint where;
                                        status_t err = fLastMouseMessage.FindPoint("where", &where);
                                        if (err == B_OK)
                                                set_mouse_position((int32)where.x, (int32)where.y);
                                }
                        }
                        break;
                }

                case REPLENISH_MESSENGER:
                        _PutMessageToPort();
                        break;

                case B_PATH_MONITOR:
                {
                        const char* path = "";
                        // only fall through for appropriate file
                        if (!(message->FindString("path", &path) == B_OK
                                        && strcmp(path, fFileName) == 0)) {
                                dev_t device;
                                ino_t node;
                                if (message->FindInt32("device", &device) != B_OK
                                        || message->FindInt64("node", &node) != B_OK
                                        || device != fNodeRef.device
                                        || node != fNodeRef.node) {
                                        break;
                                }
                        }
                }
                // fall-through
                case FILE_UPDATED:
                {
                        BMessage fileMessage;
                        BFile file(fFileName, B_READ_ONLY);
                        BList* newList = new BList;
                        BList* oldList = NULL;
                        if (file.InitCheck() == B_OK && fileMessage.Unflatten(&file)
                                        == B_OK) {
                                file.GetNodeRef(&fNodeRef);
                                int32 i = 0;
                                BMessage message;
                                while (fileMessage.FindMessage("spec", i++, &message) == B_OK) {
                                        uint32 key;
                                        BMessage testerMessage;
                                        BMessage actuatorMessage;

                                        if (message.FindInt32("key", (int32*)&key) == B_OK
                                                && message.FindMessage("act", &actuatorMessage) == B_OK
                                                && message.FindMessage("modtester", &testerMessage)
                                                        == B_OK) {
                                                // Leave handling of add-ons shortcuts to Tracker
                                                BString command;
                                                if (message.FindString("command", &command) == B_OK) {
                                                        BStringList paths;
                                                        BPathFinder::FindPaths(
                                                                B_FIND_PATH_ADD_ONS_DIRECTORY, "Tracker",
                                                                paths);
                                                        bool foundAddOn = false;
                                                        int32 count = paths.CountStrings();
                                                        for (int32 i = 0; i < count; i++) {
                                                                if (command.StartsWith(paths.StringAt(i))) {
                                                                        foundAddOn = true;
                                                                        break;
                                                                }
                                                        }
                                                        if (foundAddOn)
                                                                continue;
                                                }

                                                BArchivable* archive
                                                        = instantiate_object(&testerMessage);
                                                if (BitFieldTester* tester
                                                                = dynamic_cast<BitFieldTester*>(archive)) {
                                                        archive = instantiate_object(&actuatorMessage);
                                                        CommandActuator* actuator
                                                                = dynamic_cast<CommandActuator*>(archive);
                                                        if (actuator != NULL) {
                                                                newList->AddItem(new hks(key, tester, actuator,
                                                                        actuatorMessage));
                                                        } else {
                                                                delete archive;
                                                                delete tester;
                                                        }
                                                } else
                                                        delete archive;
                                        }
                                }
                        } else {
                                fNodeRef.device = -1;
                                fNodeRef.node = -1;
                        }

                        if (fSyncSpecs.Lock()) {
                                // swap in the new list
                                oldList = fSpecs;
                                fSpecs = newList;
                                fSyncSpecs.Unlock();
                        } else {
                                // This should never happen... but clean up if it does.
                                oldList = newList;
                        }

                        _DeleteHKSList(oldList);
                        break;
                }
        }
}


//      #pragma mark - KeyCommandMap private methods


//! Deletes an HKS-filled BList and its contents.
void
KeyCommandMap::_DeleteHKSList(BList* list)
{
        if (list == NULL)
                return;

        int32 count = list->CountItems();
        for (int32 i = 0; i < count; i++)
                delete (hks*)list->ItemAt(i);

        delete list;
}


void
KeyCommandMap::_PutMessageToPort()
{
        if (fPort >= 0) {
                BMessage message;
                message.AddMessenger("target", this);

                char buffer[2048];
                ssize_t size = message.FlattenedSize();
                if (size <= (ssize_t)sizeof(buffer)
                        && message.Flatten(buffer, size) == B_OK) {
                        write_port_etc(fPort, 0, buffer, size, B_TIMEOUT, 250000);
                }
        }
}