/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "SettingsMenu.h"

#include <new>

#include <Looper.h>
#include <Menu.h>

#include <AutoDeleter.h>

#include "AppMessageCodes.h"
#include "SettingsDescription.h"


// #pragma mark - SettingsMenu


SettingsMenu::SettingsMenu()
{
}


SettingsMenu::~SettingsMenu()
{
}


// #pragma mark - SettingMenuItem


SettingMenuItem::SettingMenuItem(Setting* setting, const char* label,
        BMessage* message, char shortcut, uint32 modifiers)
        :
        BMenuItem(label, message, shortcut, modifiers),
        fSetting(setting)
{
        fSetting->AcquireReference();
}


SettingMenuItem::SettingMenuItem(Setting* setting, BMenu* menu,
        BMessage* message)
        :
        BMenuItem(menu, message),
        fSetting(setting)
{
        fSetting->AcquireReference();
}


SettingMenuItem::~SettingMenuItem()
{
        fSetting->ReleaseReference();
}


void
SettingMenuItem::PrepareToShow(BLooper* parentLooper, BHandler* targetHandler,
                Settings* settings)
{
}


bool
SettingMenuItem::Finish(BLooper* parentLooper, BHandler* targetHandler,
        bool force)
{
        return false;
}


void
SettingMenuItem::ItemSelected(Settings* settings)
{
}


// #pragma mark - BoolMenuItem


class SettingsMenuImpl::MenuItem : public SettingMenuItem {
public:
        MenuItem(Setting* setting,
                const char* label, BMessage* message,
                char shortcut = 0, uint32 modifiers = 0)
                :
                SettingMenuItem(setting, label, message, shortcut, modifiers)
        {
        }

        MenuItem(Setting* setting, BMenu* menu, BMessage* message = NULL)
                :
                SettingMenuItem(setting, menu, message)
        {
        }

        virtual void PrepareToShow(BLooper* parentLooper, BHandler* targetHandler,
                Settings* settings)
        {
                BMessage* message = new BMessage(
                        MSG_SETTINGS_MENU_IMPL_ITEM_SELECTED);
                if (message == NULL)
                        return;
                message->AddPointer("setting", fSetting);

                SetMessage(message);
                SetTarget(targetHandler);
        }
};


class SettingsMenuImpl::BoolMenuItem : public MenuItem {
public:
        BoolMenuItem(BoolSetting* setting)
                :
                MenuItem(setting, setting->Name(), NULL)
        {
        }
};


// #pragma mark - OptionMenuItem


class SettingsMenuImpl::OptionMenuItem : public BMenuItem {
public:
        OptionMenuItem(SettingsOption* option)
                :
                BMenuItem(option->Name(), NULL),
                fOption(option)
        {
        }

        SettingsOption* Option() const
        {
                return fOption;
        }

        void PrepareToShow(BLooper* parentLooper, BHandler* targetHandler,
                Settings* settings, OptionsSetting* setting)
        {
                BMessage* message = new BMessage(
                        MSG_SETTINGS_MENU_IMPL_OPTION_ITEM_SELECTED);
                if (message == NULL)
                        return;
                message->AddPointer("setting", static_cast<Setting*>(setting));
                message->AddPointer("option", fOption);

                SetMessage(message);
                SetTarget(targetHandler);
        }

private:
        SettingsOption* fOption;
};


// #pragma mark - OptionsMenuItem


class SettingsMenuImpl::OptionsMenuItem : public MenuItem {
public:
        OptionsMenuItem(OptionsSetting* setting, BMenu* menu)
                :
                MenuItem(setting, menu)
        {
        }

        virtual void PrepareToShow(BLooper* parentLooper, BHandler* targetHandler,
                Settings* settings)
        {
                SettingsOption* selectedOption = settings->OptionValue(
                        dynamic_cast<OptionsSetting*>(GetSetting()));

                for (int32 i = 0; BMenuItem* item = Submenu()->ItemAt(i); i++) {
                        OptionMenuItem* optionItem = dynamic_cast<OptionMenuItem*>(item);
                        if (optionItem != NULL)
                                optionItem->PrepareToShow(parentLooper, targetHandler,
                                        settings, dynamic_cast<OptionsSetting*>(GetSetting()));

                        optionItem->SetMarked(optionItem->Option() == selectedOption);
                }
        }

        void OptionItemSelected(Settings* settings, SettingsOption* option)
        {
                settings->SetValue(fSetting,
                        BVariant(option->ID(), B_VARIANT_DONT_COPY_DATA));
        }
};


// #pragma mark - SettingsMenuImpl


SettingsMenuImpl::SettingsMenuImpl(Settings* settings)
        :
        fSettings(settings),
        fMenu(NULL)
{
        fSettings->AcquireReference();
}


SettingsMenuImpl::~SettingsMenuImpl()
{
        RemoveFromMenu();
        fSettings->ReleaseReference();
}


bool
SettingsMenuImpl::AddItem(SettingMenuItem* item)
{
        return fMenuItems.AddItem(item);
}


bool
SettingsMenuImpl::AddBoolItem(BoolSetting* setting)
{
        SettingMenuItem* item = new(std::nothrow) BoolMenuItem(setting);
        if (item == NULL || !AddItem(item)) {
                delete item;
                return false;
        }

        return true;
}


bool
SettingsMenuImpl::AddOptionsItem(OptionsSetting* setting)
{
        // create the submenu
        BMenu* menu = new(std::nothrow) BMenu(setting->Name());
        if (menu == NULL)
                return false;

        // create the menu item
        OptionsMenuItem* item = new(std::nothrow) OptionsMenuItem(setting, menu);
        if (item == NULL) {
                delete menu;
                return false;
        }
        ObjectDeleter<OptionsMenuItem> itemDeleter(item);

        // create sub menu items for the options
        int32 count = setting->CountOptions();
        for (int32 i = 0; i < count; i++) {
                SettingsOption* option = setting->OptionAt(i);
                BMenuItem* optionItem = new(std::nothrow) OptionMenuItem(option);
                if (optionItem == NULL || !menu->AddItem(optionItem)) {
                        delete optionItem;
                        return false;
                }
        }

        if (!AddItem(item))
                return false;

        itemDeleter.Detach();
        return true;
}


status_t
SettingsMenuImpl::AddToMenu(BMenu* menu, int32 index)
{
        if (fMenu != NULL)
                return B_BAD_VALUE;

        fMenu = menu;

        for (int32 i = 0; SettingMenuItem* item = fMenuItems.ItemAt(i); i++) {
                if (!fMenu->AddItem(item, index + i)) {
                        for (i--; i >= 0; i--)
                                fMenu->RemoveItem(fMenuItems.ItemAt(i));

                        menu = NULL;
                        return B_NO_MEMORY;
                }
        }

        return B_OK;
}


void
SettingsMenuImpl::RemoveFromMenu()
{
        if (fMenu == NULL)
                return;

        for (int32 i = 0; SettingMenuItem* item = fMenuItems.ItemAt(i); i++)
                fMenu->RemoveItem(item);

        fMenu = NULL;
}


void
SettingsMenuImpl::PrepareToShow(BLooper* parentLooper)
{
        parentLooper->AddHandler(this);

        for (int32 i = 0; SettingMenuItem* item = fMenuItems.ItemAt(i); i++)
                item->PrepareToShow(parentLooper, this, fSettings);
}


bool
SettingsMenuImpl::Finish(BLooper* parentLooper, bool force)
{
        bool stillActive = false;

        for (int32 i = 0; SettingMenuItem* item = fMenuItems.ItemAt(i); i++)
                stillActive |= item->Finish(parentLooper, this, force);

        parentLooper->RemoveHandler(this);

        return stillActive;
}


void
SettingsMenuImpl::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_SETTINGS_MENU_IMPL_ITEM_SELECTED:
                {
                        Setting* setting;
                        if (message->FindPointer("setting", (void**)&setting) != B_OK)
                                break;

                        if (SettingMenuItem* item = _FindMenuItem(setting))
                                item->ItemSelected(fSettings);

                        break;
                }

                case MSG_SETTINGS_MENU_IMPL_OPTION_ITEM_SELECTED:
                {
                        Setting* setting;
                        SettingsOption* option;
                        if (message->FindPointer("setting", (void**)&setting) != B_OK
                                || message->FindPointer("option", (void**)&option) != B_OK) {
                                break;
                        }

                        // get the options setting item
                        OptionsMenuItem* optionsItem = dynamic_cast<OptionsMenuItem*>(
                                _FindMenuItem(setting));
                        if (optionsItem == NULL)
                                break;

                        optionsItem->OptionItemSelected(fSettings, option);
                        break;
                }

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


SettingMenuItem*
SettingsMenuImpl::_FindMenuItem(Setting* setting) const
{
        for (int32 i = 0; SettingMenuItem* item = fMenuItems.ItemAt(i); i++) {
                if (item->GetSetting() == setting)
                        return item;
        }

        return NULL;
}