/*
 * Copyright 2005, Jérôme Duval. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Inspired by SoundCapture from Be newsletter (Media Kit Basics: Consumers 
 * and Producers)
 */

#include <Bitmap.h>
#include <Debug.h>
#include <MessageFilter.h>
#include <Window.h>

#include <map>

#include "TransportButton.h"
#include "DrawingTidbits.h"

using std::map;

class BitmapStash {
// Bitmap stash is a simple class to hold all the lazily-allocated
// bitmaps that the TransportButton needs when rendering itself.
// signature is a combination of the different enabled, pressed, playing, etc.
// flavors of a bitmap. If the stash does not have a particular bitmap,
// it turns around to ask the button to create one and stores it for next time.
public:
        BitmapStash(TransportButton *);
        ~BitmapStash();
        BBitmap *GetBitmap(uint32 signature);
        
private:
        TransportButton *owner;
        map<uint32, BBitmap *> stash;
};


BitmapStash::BitmapStash(TransportButton *owner)
        :       owner(owner)
{
}


BBitmap *
BitmapStash::GetBitmap(uint32 signature)
{
        if (stash.find(signature) == stash.end()) {
                BBitmap *newBits = owner->MakeBitmap(signature);
                ASSERT(newBits);
                stash[signature] = newBits;
        }
        
        return stash[signature];
}


BitmapStash::~BitmapStash()
{
        // delete all the bitmaps
        for (map<uint32, BBitmap *>::iterator i = stash.begin(); 
                i != stash.end(); i++)
                delete (*i).second;
}


class PeriodicMessageSender {
        // used to send a specified message repeatedly when holding down a button
public:
        static PeriodicMessageSender *Launch(BMessenger target,
                const BMessage *message, bigtime_t period);
        void Quit();

private:
        PeriodicMessageSender(BMessenger target, const BMessage *message,
                bigtime_t period);
        ~PeriodicMessageSender() {}
                // use quit

        static status_t TrackBinder(void *);
        void Run();
        
        BMessenger target;
        BMessage message;

        bigtime_t period;
        
        bool requestToQuit;
};


PeriodicMessageSender::PeriodicMessageSender(BMessenger target,
        const BMessage *message, bigtime_t period)
        :       target(target),
                message(*message),
                period(period),
                requestToQuit(false)
{
}


PeriodicMessageSender *
PeriodicMessageSender::Launch(BMessenger target, const BMessage *message,
        bigtime_t period)
{
        PeriodicMessageSender *result = new PeriodicMessageSender(target, 
                message, period);
        thread_id thread = spawn_thread(&PeriodicMessageSender::TrackBinder,
                "ButtonRepeatingThread", B_NORMAL_PRIORITY, result);
        
        if (thread <= 0 || resume_thread(thread) != B_OK) {
                // didn't start, don't leak self
                delete result;
                result = 0;
        }

        return result;
}


void 
PeriodicMessageSender::Quit()
{
        requestToQuit = true;
}


status_t 
PeriodicMessageSender::TrackBinder(void *castToThis)
{
        ((PeriodicMessageSender *)castToThis)->Run();
        return 0;
}


void 
PeriodicMessageSender::Run()
{
        for (;;) {
                snooze(period);
                if (requestToQuit)
                        break;
                target.SendMessage(&message);
        }
        delete this;
}


class SkipButtonKeypressFilter : public BMessageFilter {
public:
        SkipButtonKeypressFilter(uint32 shortcutKey, uint32 shortcutModifier,
                TransportButton *target);

protected:
        filter_result Filter(BMessage *message, BHandler **handler);

private:
        uint32 shortcutKey;
        uint32 shortcutModifier;
        TransportButton *target;
};


SkipButtonKeypressFilter::SkipButtonKeypressFilter(uint32 shortcutKey,
        uint32 shortcutModifier, TransportButton *target)
        :       BMessageFilter(B_ANY_DELIVERY, B_ANY_SOURCE),
                shortcutKey(shortcutKey),
                shortcutModifier(shortcutModifier),
                target(target)
{
}


filter_result 
SkipButtonKeypressFilter::Filter(BMessage *message, BHandler **handler)
{
        if (target->IsEnabled()
                && (message->what == B_KEY_DOWN || message->what == B_KEY_UP)) {
                uint32 modifiers;
                uint32 rawKeyChar = 0;
                uint8 byte = 0;
                int32 key = 0;
                
                if (message->FindInt32("modifiers", (int32 *)&modifiers) != B_OK
                        || message->FindInt32("raw_char", (int32 *)&rawKeyChar) != B_OK
                        || message->FindInt8("byte", (int8 *)&byte) != B_OK
                        || message->FindInt32("key", &key) != B_OK)
                        return B_DISPATCH_MESSAGE;

                modifiers &= B_SHIFT_KEY | B_COMMAND_KEY | B_CONTROL_KEY
                        | B_OPTION_KEY | B_MENU_KEY;
                        // strip caps lock, etc.

                if (modifiers == shortcutModifier && rawKeyChar == shortcutKey) {
                        if (message->what == B_KEY_DOWN)
                                target->ShortcutKeyDown();
                        else
                                target->ShortcutKeyUp();
                        
                        return B_SKIP_MESSAGE;
                }
        }

        // let others deal with this
        return B_DISPATCH_MESSAGE;
}


TransportButton::TransportButton(BRect frame, const char *name,
        const unsigned char *normalBits,
        const unsigned char *pressedBits,
        const unsigned char *disabledBits,
        BMessage *invokeMessage, BMessage *startPressingMessage,
        BMessage *pressingMessage, BMessage *donePressingMessage, bigtime_t period,
        uint32 key, uint32 modifiers, uint32 resizeFlags)
        :       BControl(frame, name, "", invokeMessage, resizeFlags, 
                        B_WILL_DRAW | B_NAVIGABLE),
                bitmaps(new BitmapStash(this)),
                normalBits(normalBits),
                pressedBits(pressedBits),
                disabledBits(disabledBits),
                startPressingMessage(startPressingMessage),
                pressingMessage(pressingMessage),
                donePressingMessage(donePressingMessage),
                pressingPeriod(period),
                mouseDown(false),
                keyDown(false),
                messageSender(0),
                keyPressFilter(0)
{
        if (key)
                keyPressFilter = new SkipButtonKeypressFilter(key, modifiers, this);
}


void 
TransportButton::AttachedToWindow()
{
        _inherited::AttachedToWindow();
        if (keyPressFilter)
                Window()->AddCommonFilter(keyPressFilter);
        
        // transparent to reduce flicker
        SetViewColor(B_TRANSPARENT_COLOR);
}


void 
TransportButton::DetachedFromWindow()
{
        if (keyPressFilter) {
                Window()->RemoveCommonFilter(keyPressFilter);
                delete keyPressFilter;
        }
        _inherited::DetachedFromWindow();
}


TransportButton::~TransportButton()
{
        delete startPressingMessage;
        delete pressingMessage;
        delete donePressingMessage;
        delete bitmaps;
}


void 
TransportButton::WindowActivated(bool state)
{
        if (!state)
                ShortcutKeyUp();
        
        _inherited::WindowActivated(state);
}


void 
TransportButton::SetEnabled(bool on)
{
        _inherited::SetEnabled(on);
        if (!on)
                ShortcutKeyUp();        
}


const unsigned char *
TransportButton::BitsForMask(uint32 mask) const
{
        switch (mask) {
                case 0:
                        return normalBits;
                case kDisabledMask:
                        return disabledBits;
                case kPressedMask:
                        return pressedBits;
                default:
                        break;
        }       
        TRESPASS();
        return 0;
}


BBitmap *
TransportButton::MakeBitmap(uint32 mask)
{
        BBitmap *result = new BBitmap(Bounds(), B_CMAP8);
        result->SetBits(BitsForMask(mask), (Bounds().Width() + 1) 
                * (Bounds().Height() + 1), 0, B_CMAP8);

        ReplaceTransparentColor(result, Parent()->ViewColor());
        
        return result;
}


uint32 
TransportButton::ModeMask() const
{
        return (IsEnabled() ? 0 : kDisabledMask)
                | (Value() ? kPressedMask : 0);
}


void 
TransportButton::Draw(BRect)
{
        DrawBitmapAsync(bitmaps->GetBitmap(ModeMask()));
}


void 
TransportButton::StartPressing()
{
        SetValue(1);
        if (startPressingMessage)
                Invoke(startPressingMessage);
        
        if (pressingMessage) {
                ASSERT(pressingMessage);
                messageSender = PeriodicMessageSender::Launch(Messenger(),
                        pressingMessage, pressingPeriod);
        }
}


void 
TransportButton::MouseCancelPressing()
{
        if (!mouseDown || keyDown)
                return;

        mouseDown = false;

        if (pressingMessage) {
                ASSERT(messageSender);
                PeriodicMessageSender *sender = messageSender;
                messageSender = 0;
                sender->Quit();
        }

        if (donePressingMessage)
                Invoke(donePressingMessage);
        SetValue(0);
}


void 
TransportButton::DonePressing()
{       
        if (pressingMessage) {
                ASSERT(messageSender);
                PeriodicMessageSender *sender = messageSender;
                messageSender = 0;
                sender->Quit();
        }

        Invoke();
        SetValue(0);
}


void 
TransportButton::MouseStartPressing()
{
        if (mouseDown)
                return;
        
        mouseDown = true;
        if (!keyDown)
                StartPressing();
}


void 
TransportButton::MouseDonePressing()
{
        if (!mouseDown)
                return;
        
        mouseDown = false;
        if (!keyDown)
                DonePressing();
}


void 
TransportButton::ShortcutKeyDown()
{
        if (!IsEnabled())
                return;

        if (keyDown)
                return;
        
        keyDown = true;
        if (!mouseDown)
                StartPressing();
}


void 
TransportButton::ShortcutKeyUp()
{
        if (!keyDown)
                return;
        
        keyDown = false;
        if (!mouseDown)
                DonePressing();
}


void 
TransportButton::MouseDown(BPoint)
{
        if (!IsEnabled())
                return;

        ASSERT(Window()->Flags() & B_ASYNCHRONOUS_CONTROLS);
        SetTracking(true);
        SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
        MouseStartPressing();
}

void 
TransportButton::MouseMoved(BPoint point, uint32 code, const BMessage *)
{
        if (IsTracking() && Bounds().Contains(point) != Value()) {
                if (!Value())
                        MouseStartPressing();
                else
                        MouseCancelPressing();
        }
}

void 
TransportButton::MouseUp(BPoint point)
{
        if (IsTracking()) {
                if (Bounds().Contains(point))
                        MouseDonePressing();
                else
                        MouseCancelPressing();
                SetTracking(false);
        }
}

void 
TransportButton::SetStartPressingMessage(BMessage *message)
{
        delete startPressingMessage;
        startPressingMessage = message;
}

void 
TransportButton::SetPressingMessage(BMessage *message)
{
        delete pressingMessage;
        pressingMessage = message;
}

void 
TransportButton::SetDonePressingMessage(BMessage *message)
{
        delete donePressingMessage;
        donePressingMessage = message;
}

void 
TransportButton::SetPressingPeriod(bigtime_t newTime)
{
        pressingPeriod = newTime;
}


PlayPauseButton::PlayPauseButton(BRect frame, const char *name,
        BMessage *invokeMessage, BMessage *blinkMessage,
        uint32 key, uint32 modifiers, uint32 resizeFlags)
        :       TransportButton(frame, name, kPlayButtonBitmapBits, 
                        kPressedPlayButtonBitmapBits,
                        kDisabledPlayButtonBitmapBits, invokeMessage, NULL,
                        NULL, NULL, 0, key, modifiers, resizeFlags),
                fState(PlayPauseButton::kStopped),
                fLastModeMask(0),
                fRunner(NULL),
                fBlinkMessage(blinkMessage)
{
}

void 
PlayPauseButton::SetStopped()
{
        if (fState == kStopped || fState == kAboutToPlay)
                return;
        
        fState = kStopped;
        delete fRunner;
        fRunner = NULL;
        Invalidate();
}

void 
PlayPauseButton::SetPlaying()
{
        if (fState == kAboutToPause)
                return;
        
        // in playing state blink the LED on and off
        if (fState == kPlayingLedOn)
                fState = kPlayingLedOff;
        else
                fState = kPlayingLedOn;
        
        Invalidate();
}

const bigtime_t kPlayingBlinkPeriod = 600000;

void 
PlayPauseButton::SetPaused()
{
        if (fState == kAboutToPlay)
                return;

        // in paused state blink the LED on and off
        if (fState == kPausedLedOn)
                fState = kPausedLedOff;
        else
                fState = kPausedLedOn;
        
        Invalidate();
}

uint32 
PlayPauseButton::ModeMask() const
{
        if (!IsEnabled())
                return kDisabledMask;
        
        uint32 result = 0;

        if (Value())
                result = kPressedMask;

        if (fState == kPlayingLedOn || fState == kAboutToPlay)
                result |= kPlayingMask;
        else if (fState == kAboutToPause || fState == kPausedLedOn)     
                result |= kPausedMask;
        
        return result;
}

const unsigned char *
PlayPauseButton::BitsForMask(uint32 mask) const
{
        switch (mask) {
                case kPlayingMask:
                        return kPlayingPlayButtonBitmapBits;
                case kPlayingMask | kPressedMask:
                        return kPressedPlayingPlayButtonBitmapBits;
                case kPausedMask:
                        return kPausedPlayButtonBitmapBits;
                case kPausedMask | kPressedMask:
                        return kPressedPausedPlayButtonBitmapBits;
                default:
                        return _inherited::BitsForMask(mask);
        }       
        TRESPASS();
        return 0;
}


void 
PlayPauseButton::StartPressing()
{
        if (fState == kPlayingLedOn || fState == kPlayingLedOff)
                fState = kAboutToPause;
        else
                fState = kAboutToPlay;
        
        _inherited::StartPressing();
}

void 
PlayPauseButton::MouseCancelPressing()
{
        if (fState == kAboutToPause)
                fState = kPlayingLedOn;
        else
                fState = kStopped;
        
        _inherited::MouseCancelPressing();
}

void 
PlayPauseButton::DonePressing()
{
        if (fState == kAboutToPause) {
                fState = kPausedLedOn;
        } else if (fState == kAboutToPlay) {
                fState = kPlayingLedOn;
                if (!fRunner && fBlinkMessage)
                        fRunner = new BMessageRunner(Messenger(), fBlinkMessage, 
                                kPlayingBlinkPeriod);
        }
        
        _inherited::DonePressing();
}


RecordButton::RecordButton(BRect frame, const char *name,
        BMessage *invokeMessage, BMessage *blinkMessage,
        uint32 key, uint32 modifiers, uint32 resizeFlags)
        :       TransportButton(frame, name, kRecordButtonBitmapBits, 
                        kPressedRecordButtonBitmapBits,
                        kDisabledRecordButtonBitmapBits, invokeMessage, NULL, NULL,
                        NULL, 0, key, modifiers, resizeFlags),
                fState(RecordButton::kStopped),
                fLastModeMask(0),
                fRunner(NULL),
                fBlinkMessage(blinkMessage)
{
}

void 
RecordButton::SetStopped()
{
        if (fState == kStopped || fState == kAboutToRecord)
                return;
        
        fState = kStopped;
        delete fRunner;
        fRunner = NULL;
        Invalidate();
}

const bigtime_t kRecordingBlinkPeriod = 600000;

void 
RecordButton::SetRecording()
{
        if (fState == kAboutToStop)
                return;

        if (fState == kRecordingLedOff)
                fState = kRecordingLedOn;
        else
                fState = kRecordingLedOff;
        
        Invalidate();
}

uint32 
RecordButton::ModeMask() const
{
        if (!IsEnabled())
                return kDisabledMask;
        
        uint32 result = 0;

        if (Value())
                result = kPressedMask;

        if (fState == kAboutToStop || fState == kRecordingLedOn)
                result |= kRecordingMask;
        
        return result;
}

const unsigned char *
RecordButton::BitsForMask(uint32 mask) const
{
        switch (mask) {
                case kRecordingMask:
                        return kRecordingRecordButtonBitmapBits;
                case kRecordingMask | kPressedMask:
                        return kPressedRecordingRecordButtonBitmapBits;
                default:
                        return _inherited::BitsForMask(mask);
        }       
        TRESPASS();
        return 0;
}


void 
RecordButton::StartPressing()
{
        if (fState == kRecordingLedOn || fState == kRecordingLedOff)
                fState = kAboutToStop;
        else
                fState = kAboutToRecord;
        
        _inherited::StartPressing();
}

void 
RecordButton::MouseCancelPressing()
{
        if (fState == kAboutToStop)
                fState = kRecordingLedOn;
        else
                fState = kStopped;
        
        _inherited::MouseCancelPressing();
}

void 
RecordButton::DonePressing()
{
        if (fState == kAboutToStop) {
                fState = kStopped;
                delete fRunner;
                fRunner = NULL;
        } else if (fState == kAboutToRecord) {
                fState = kRecordingLedOn;
                if (!fRunner && fBlinkMessage)
                        fRunner = new BMessageRunner(Messenger(), fBlinkMessage, 
                                kRecordingBlinkPeriod);
        }
        
        _inherited::DonePressing();
}