/*
 * Copyright 2010-2017, Haiku, Inc. All Rights Reserved.
 * Copyright 2009, Pier Luigi Fiorini.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Pier Luigi Fiorini, pierluigi.fiorini@gmail.com
 *              Brian Hill, supernova@tycho.email
 */

#include <stdio.h>
#include <stdlib.h>

#include <vector>

#include <Alert.h>
#include <Box.h>
#include <Button.h>
#include <Catalog.h>
#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <Font.h>
#include <LayoutBuilder.h>
#include <Node.h>
#include <Path.h>
#include <Query.h>
#include <Roster.h>
#include <String.h>
#include <StringFormat.h>
#include <SymLink.h>
#include <Volume.h>
#include <VolumeRoster.h>

#include <notification/Notifications.h>

#include "GeneralView.h"
#include "NotificationsConstants.h"
#include "SettingsHost.h"

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "GeneralView"

const uint32 kToggleNotifications = '_TSR';
const uint32 kWidthChanged = '_WIC';
const uint32 kTimeoutChanged = '_TIC';
const uint32 kPositionChanged = '_NPC';
const uint32 kServerChangeTriggered = '_SCT';
const BString kSampleMessageID("NotificationsSample");


static int32
notification_position_to_index(uint32 notification_position) {
        if (notification_position == B_FOLLOW_NONE)
                return 0;
        else if (notification_position == (B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM))
                return 1;
        else if (notification_position == (B_FOLLOW_LEFT | B_FOLLOW_BOTTOM))
                return 2;
        else if (notification_position == (B_FOLLOW_RIGHT | B_FOLLOW_TOP))
                return 3;
        else if (notification_position == (B_FOLLOW_LEFT | B_FOLLOW_TOP))
                return 4;
        return 0;
}


GeneralView::GeneralView(SettingsHost* host)
        :
        SettingsPane("general", host)
{
        // Notification server
        fNotificationBox = new BCheckBox("server",
                B_TRANSLATE("Enable notifications"),
                new BMessage(kToggleNotifications));
        BBox* box = new BBox("box");
        box->SetLabel(fNotificationBox);

        // Window width
        float ratio = be_plain_font->Size() / 12.f;
        int32 minWidth = int32(kMinimumWidth / kWidthStep * ratio);
        int32 maxWidth = int32(kMaximumWidth / kWidthStep * ratio);
        fWidthSlider = new BSlider("width", B_TRANSLATE("Window width"),
                new BMessage(kWidthChanged), minWidth, maxWidth, B_HORIZONTAL);
        fWidthSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
        fWidthSlider->SetHashMarkCount(maxWidth - minWidth + 1);
        fWidthSlider->SetLimitLabels(
                B_TRANSLATE_COMMENT("narrow", "Window width: Slider low text"),
                B_TRANSLATE_COMMENT("wide", "Window width: Slider high text"));

        // Display time
        fDurationSlider = new BSlider("duration", B_TRANSLATE("Duration:"),
                new BMessage(kTimeoutChanged), kMinimumTimeout, kMaximumTimeout,
                B_HORIZONTAL);
        fDurationSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
        fDurationSlider->SetHashMarkCount(kMaximumTimeout - kMinimumTimeout + 1);
        BString minLabel;
        minLabel << kMinimumTimeout;
        BString maxLabel;
        maxLabel << kMaximumTimeout;
        fDurationSlider->SetLimitLabels(
                B_TRANSLATE_COMMENT(minLabel.String(), "Slider low text"),
                B_TRANSLATE_COMMENT(maxLabel.String(), "Slider high text"));

        // Notification Position
        fPositionMenu = new BPopUpMenu(B_TRANSLATE("Follow Deskbar"));
        const char* positionLabels[] = {
                B_TRANSLATE_MARK("Follow Deskbar"),
                B_TRANSLATE_MARK("Lower right"),
                B_TRANSLATE_MARK("Lower left"),
                B_TRANSLATE_MARK("Upper right"),
                B_TRANSLATE_MARK("Upper left")
        };
        const uint32 positions[] = {
                B_FOLLOW_DESKBAR,                   // Follow Deskbar
                B_FOLLOW_BOTTOM | B_FOLLOW_RIGHT,   // Lower right
                B_FOLLOW_BOTTOM | B_FOLLOW_LEFT,    // Lower left
                B_FOLLOW_TOP    | B_FOLLOW_RIGHT,   // Upper right
                B_FOLLOW_TOP    | B_FOLLOW_LEFT     // Upper left
        };
        for (int i=0; i < 5; i++) {
                BMessage* message = new BMessage(kPositionChanged);
                message->AddInt32(kNotificationPositionName, positions[i]);

                fPositionMenu->AddItem(new BMenuItem(B_TRANSLATE_NOCOLLECT(
                        positionLabels[i]), message));
        }
        BMenuField* positionField = new BMenuField(B_TRANSLATE("Position:"), 
                fPositionMenu);

        box->AddChild(BLayoutBuilder::Group<>(B_VERTICAL)
                .SetInsets(B_USE_DEFAULT_SPACING)
                .Add(fWidthSlider)
                .Add(fDurationSlider)
                .Add(positionField)
                .AddGlue()
                .View());
        
        BLayoutBuilder::Group<>(this, B_VERTICAL)
                .SetInsets(B_USE_WINDOW_SPACING)
                .Add(box)
        .End();
}


void
GeneralView::AttachedToWindow()
{
        BView::AttachedToWindow();
        fNotificationBox->SetTarget(this);
        fWidthSlider->SetTarget(this);
        fDurationSlider->SetTarget(this);
        fPositionMenu->SetTargetForItems(this);
}


void
GeneralView::MessageReceived(BMessage* msg)
{
        switch (msg->what) {
                case kToggleNotifications:
                {
                        SettingsPane::SettingsChanged(false);
                        _EnableControls();
                        break;
                }
                case kWidthChanged: {
                        SettingsPane::SettingsChanged(true);
                        break;
                }
                case kTimeoutChanged:
                {
                        int32 value = fDurationSlider->Value();
                        _SetTimeoutLabel(value);
                        SettingsPane::SettingsChanged(true);
                        break;
                }
                case kPositionChanged:
                {
                        int32 position;
                        if (msg->FindInt32(kNotificationPositionName, &position) == B_OK) {
                                fNewPosition = position;
                                SettingsPane::SettingsChanged(true);
                        }
                        break;
                }
                default:
                        BView::MessageReceived(msg);
                        break;
        }
}


status_t
GeneralView::Load(BMessage& settings)
{
        bool autoStart = settings.GetBool(kAutoStartName, true);
        fNotificationBox->SetValue(autoStart ? B_CONTROL_ON : B_CONTROL_OFF);

        if (settings.FindFloat(kWidthName, &fOriginalWidth) != B_OK
                || fOriginalWidth > kMaximumWidth
                || fOriginalWidth < kMinimumWidth)
                fOriginalWidth = kDefaultWidth;

        if (settings.FindInt32(kTimeoutName, &fOriginalTimeout) != B_OK
                || fOriginalTimeout > kMaximumTimeout
                || fOriginalTimeout < kMinimumTimeout)
                fOriginalTimeout = kDefaultTimeout;
// TODO need to save again if values outside of expected range
        int32 setting;
        if (settings.FindInt32(kIconSizeName, &setting) != B_OK)
                fOriginalIconSize = kDefaultIconSize;
        else
                fOriginalIconSize = (icon_size)setting;

        int32 position;
        if (settings.FindInt32(kNotificationPositionName, &position) != B_OK)
                fOriginalPosition = kDefaultNotificationPosition;
        else
                fOriginalPosition = position;

        _EnableControls();
        
        return Revert();
}


status_t
GeneralView::Save(BMessage& settings)
{
        bool autoStart = (fNotificationBox->Value() == B_CONTROL_ON);
        settings.AddBool(kAutoStartName, autoStart);

        int32 timeout = fDurationSlider->Value();
        settings.AddInt32(kTimeoutName, timeout);

        float width = fWidthSlider->Value() * kWidthStep;
        settings.AddFloat(kWidthName, width);

        icon_size iconSize = B_LARGE_ICON;
        settings.AddInt32(kIconSizeName, (int32)iconSize);

        settings.AddInt32(kNotificationPositionName, (int32)fNewPosition);

        return B_OK;
}


status_t
GeneralView::Revert()
{
        fDurationSlider->SetValue(fOriginalTimeout);
        _SetTimeoutLabel(fOriginalTimeout);
        
        fWidthSlider->SetValue(fOriginalWidth / kWidthStep);

        fNewPosition = fOriginalPosition;
        BMenuItem* item = fPositionMenu->ItemAt(
                notification_position_to_index(fNewPosition));
        if (item != NULL)
                item->SetMarked(true);
        
        return B_OK;
}


bool
GeneralView::RevertPossible()
{
        int32 timeout = fDurationSlider->Value();
        if (fOriginalTimeout != timeout)
                return true;
        
        int32 width = fWidthSlider->Value() * kWidthStep;
        if (fOriginalWidth != width)
                return true;

        if (fOriginalPosition != fNewPosition)
                return true;

        return false;
}


status_t
GeneralView::Defaults()
{
        fDurationSlider->SetValue(kDefaultTimeout);
        _SetTimeoutLabel(kDefaultTimeout);

        fWidthSlider->SetValue(kDefaultWidth / kWidthStep);

        fNewPosition = kDefaultNotificationPosition;
        BMenuItem* item = fPositionMenu->ItemAt(
                notification_position_to_index(fNewPosition));
        if (item != NULL)
                item->SetMarked(true);

        return B_OK;
}


bool
GeneralView::DefaultsPossible()
{
        int32 timeout = fDurationSlider->Value();
        if (kDefaultTimeout != timeout)
                return true;

        int32 width = fWidthSlider->Value() * kWidthStep;
        if (kDefaultWidth != width)
                return true;

        if (kDefaultNotificationPosition != fNewPosition)
                return true;
        
        return false;
}


bool
GeneralView::UseDefaultRevertButtons()
{
        return true;
}


void
GeneralView::_EnableControls()
{
        bool enabled = fNotificationBox->Value() == B_CONTROL_ON;
        fWidthSlider->SetEnabled(enabled);
        fDurationSlider->SetEnabled(enabled);
        BMenuItem* item = fPositionMenu->ItemAt(
                notification_position_to_index(fOriginalPosition));
        if (item != NULL)
                item->SetMarked(true);
}


void
GeneralView::_SetTimeoutLabel(int32 value)
{
        static BStringFormat format(B_TRANSLATE("{0, plural, "
                "=1{Timeout: # second}"
                "other{Timeout: # seconds}}"));
        BString label;
        format.Format(label, value);
        fDurationSlider->SetLabel(label.String());
}


bool
GeneralView::_IsServerRunning()
{
        return be_roster->IsRunning(kNotificationServerSignature);
}