#include "BitmapView.h"
#include <Alert.h>
#include <BitmapStream.h>
#include <Clipboard.h>
#include <Font.h>
#include <MenuItem.h>
#include <Entry.h>
#include <TranslationUtils.h>
#include <TranslatorRoster.h>
#include <TranslatorFormats.h>

// TODO: Add support for labels

#define M_REMOVE_IMAGE 'mrmi'
#define M_PASTE_IMAGE 'mpsi'

enum
{
        CLIP_NONE = 0,
        CLIP_BEOS = 1,
        CLIP_SHOWIMAGE = 2,
        CLIP_PRODUCTIVE = 3
};


inline void SetRGBColor(rgb_color *col, uint8 r, uint8 g, uint8 b, uint8 a = 255);


void
SetRGBColor(rgb_color *col, uint8 r, uint8 g, uint8 b, uint8 a)
{
        if (col) {
                col->red = r;
                col->green = g;
                col->blue = b;
                col->alpha = a;
        }
}


BitmapView::BitmapView(BRect frame, const char *name, BMessage *mod, BBitmap *bitmap,
                                                const char *label, border_style borderstyle, int32 resize, int32 flags)
  :     BView(frame, name, resize, flags)
{
        SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
        
        if (bitmap && bitmap->IsValid())
                fBitmap = bitmap;
        else
                fBitmap = NULL;
        
        if (mod)
                SetMessage(mod);
        
        fLabel = label;
        fBorderStyle = borderstyle;
        fFixedSize = false;
        fEnabled = true;
        fRemovableBitmap = false;
        fAcceptDrops = true;
        fAcceptPaste = true;
        fConstrainDrops = true;
        fMaxWidth = 100;
        fMaxHeight = 100;
        
        fPopUpMenu = new BPopUpMenu("deletepopup", false, false);
        fPopUpMenu->AddItem(new BMenuItem("Close This Menu", new BMessage(B_CANCEL)));
        fPopUpMenu->AddSeparatorItem();
        
        fPasteItem = new BMenuItem("Paste Photo from Clipboard", new BMessage(M_PASTE_IMAGE));
        fPopUpMenu->AddItem(fPasteItem);
        
        fPopUpMenu->AddSeparatorItem();
        
        fRemoveItem = new BMenuItem("Remove Photo", new BMessage(M_REMOVE_IMAGE));
        fPopUpMenu->AddItem(fRemoveItem);
        
        CalculateBitmapRect();
        
        // Calculate the offsets for each of the words -- the phrase will be center justified
        fNoPhotoWidths[0] = StringWidth("Drop");
        fNoPhotoWidths[1] = StringWidth("a");
        fNoPhotoWidths[2] = StringWidth("Photo");
        fNoPhotoWidths[3] = StringWidth("Here");
        
        font_height fh;
        GetFontHeight(&fh);
        float totalheight = fh.ascent + fh.descent + fh.leading;
        float yoffset = (Bounds().Height() - 10 - (totalheight * 4)) / 2;
        fNoPhotoOffsets[0].Set((Bounds().Width() - fNoPhotoWidths[0]) / 2, totalheight + yoffset);
        fNoPhotoOffsets[1].Set((Bounds().Width() - fNoPhotoWidths[1]) / 2,
                                                        fNoPhotoOffsets[0].y + totalheight);
        fNoPhotoOffsets[2].Set((Bounds().Width() - fNoPhotoWidths[2]) / 2,
                                                        fNoPhotoOffsets[1].y + totalheight);
        fNoPhotoOffsets[3].Set((Bounds().Width() - fNoPhotoWidths[3]) / 2,
                                                        fNoPhotoOffsets[2].y + totalheight);
}


BitmapView::~BitmapView(void)
{
        delete fPopUpMenu;
}


void
BitmapView::AttachedToWindow(void)
{
        SetTarget((BHandler*)Window());
        fPopUpMenu->SetTargetForItems(this);
}


void
BitmapView::SetBitmap(BBitmap *bitmap)
{
        if (bitmap && bitmap->IsValid()) {
                if (fBitmap == bitmap)
                        return;
                fBitmap = bitmap;
        } else {
                if (!fBitmap)
                        return;
                fBitmap = NULL;
        }
        
        CalculateBitmapRect();
        if (!IsHidden())
                Invalidate();
}


void
BitmapView::SetEnabled(bool value)
{
        if (fEnabled != value) {
                fEnabled = value;
                Invalidate();
        }
}


/*
void
BitmapView::SetLabel(const char *label)
{
        if (fLabel.Compare(label) != 0) {
                fLabel = label;
                
                CalculateBitmapRect();
                if (!IsHidden())
                        Invalidate();
        }
}
*/


void
BitmapView::SetStyle(border_style style)
{
        if (fBorderStyle != style) {
                fBorderStyle = style;
                
                CalculateBitmapRect();
                if (!IsHidden())
                        Invalidate();
        }
}


void
BitmapView::SetFixedSize(bool isfixed)
{
        if (fFixedSize != isfixed) {
                fFixedSize = isfixed;
                
                CalculateBitmapRect();
                if (!IsHidden())
                        Invalidate();
        }
}


void
BitmapView::MessageReceived(BMessage *msg)
{
        if (msg->WasDropped() && AcceptsDrops()) {
                // We'll handle two types of drops: those from Tracker and those from ShowImage
                if (msg->what == B_SIMPLE_DATA) {
                        int32 actions;
                        if (msg->FindInt32("be:actions", &actions) == B_OK) {
                                // ShowImage drop. This is a negotiated drag&drop, so send a reply
                                BMessage reply(B_COPY_TARGET), response;
                                reply.AddString("be:types", "image/jpeg");
                                reply.AddString("be:types", "image/png");
                                
                                msg->SendReply(&reply, &response);
                                
                                // now, we've gotten the response
                                if (response.what == B_MIME_DATA) {
                                        // Obtain and translate the received data
                                        uint8 *imagedata;
                                        ssize_t datasize;
                                                                                
                                        // Try JPEG first
                                        if (response.FindData("image/jpeg", B_MIME_DATA, 
                                                (const void **)&imagedata, &datasize) != B_OK) {
                                                // Try PNG next and piddle out if unsuccessful
                                                if (response.FindData("image/png", B_PNG_FORMAT, 
                                                        (const void **)&imagedata, &datasize) != B_OK)
                                                        return;
                                        }
                                        
                                        // Set up to decode into memory
                                        BMemoryIO memio(imagedata, datasize);
                                        BTranslatorRoster *roster = BTranslatorRoster::Default();
                                        BBitmapStream bstream;
                                        
                                        if (roster->Translate(&memio, NULL, NULL, &bstream, B_TRANSLATOR_BITMAP) == B_OK)
                                        {
                                                BBitmap *bmp;
                                                if (bstream.DetachBitmap(&bmp) != B_OK)
                                                        return;
                                                SetBitmap(bmp);
                                                
                                                if (fConstrainDrops)
                                                        ConstrainBitmap();
                                                Invoke();
                                        }
                                }
                                return;
                        }
                        
                        entry_ref ref;
                        if (msg->FindRef("refs", &ref) == B_OK) {
                                // Tracker drop
                                BBitmap *bmp = BTranslationUtils::GetBitmap(&ref);
                                if (bmp) {
                                        SetBitmap(bmp);
                                        
                                        if (fConstrainDrops)
                                                ConstrainBitmap();
                                        Invoke();
                                }
                        }
                }
                return;
        }
        
        switch (msg->what)
        {
                case M_REMOVE_IMAGE: {
                        BAlert *alert = new BAlert("ResEdit", "This cannot be undone. "
                                "Remove the image?", "Remove", "Cancel");
                        alert->SetShortcut(1, B_ESCAPE);
                        int32 value = alert->Go();
                        if (value == 0) {
                                SetBitmap(NULL);
                                
                                if (Target()) {
                                        BMessenger msgr(Target());
                                        
                                        msgr.SendMessage(new BMessage(M_BITMAP_REMOVED));
                                        return;
                                }
                        }
                }
                case M_PASTE_IMAGE:
                {
                        PasteBitmap();
                        Invoke();
                }
        }
        BView::MessageReceived(msg);
}


void
BitmapView::Draw(BRect rect)
{
        if (fBitmap)
                DrawBitmap(fBitmap, fBitmap->Bounds(), fBitmapRect);
        else {
                SetHighColor(0, 0, 0, 80);
                SetDrawingMode(B_OP_ALPHA);
                DrawString("Drop", fNoPhotoOffsets[0]);
                DrawString("a", fNoPhotoOffsets[1]);
                DrawString("Photo", fNoPhotoOffsets[2]);
                DrawString("Here", fNoPhotoOffsets[3]);
                SetDrawingMode(B_OP_COPY);
        }
        
        if (fBorderStyle == B_FANCY_BORDER) {
                rgb_color base= { 216, 216, 216, 255 };
                rgb_color work;
                
                SetHighColor(base);
                StrokeRect(Bounds().InsetByCopy(2, 2));
                
                BeginLineArray(12);
                
                BRect r(Bounds());

                work = tint_color(base, B_DARKEN_2_TINT);
                AddLine(r.LeftTop(), r.RightTop(), work);
                AddLine(r.LeftTop(), r.LeftBottom(), work);
                r.left++;
                
                work = tint_color(base, B_DARKEN_4_TINT);
                AddLine(r.RightTop(), r.RightBottom(), work);
                AddLine(r.LeftBottom(), r.RightBottom(), work);
                
                r.right--;
                r.top++;
                r.bottom--;

                
                work = tint_color(base, B_LIGHTEN_MAX_TINT);
                AddLine(r.LeftTop(), r.RightTop(), work);
                AddLine(r.LeftTop(), r.LeftBottom(), work);
                r.left++;
                
                work = tint_color(base, B_DARKEN_3_TINT);
                AddLine(r.RightTop(), r.RightBottom(), work);
                AddLine(r.LeftBottom(), r.RightBottom(), work);
                
                // this rect handled by the above StrokeRect, so inset a total of 2 pixels
                r.left++;
                r.right -= 2;
                r.top += 2;
                r.bottom -= 2;
                
                
                work = tint_color(base, B_DARKEN_3_TINT);
                AddLine(r.LeftTop(), r.RightTop(), work);
                AddLine(r.LeftTop(), r.LeftBottom(), work);
                r.left++;
                
                work = tint_color(base, B_LIGHTEN_MAX_TINT);
                AddLine(r.RightTop(), r.RightBottom(), work);
                AddLine(r.LeftBottom(), r.RightBottom(), work);

                r.right--;
                r.top++;
                r.bottom--;
                EndLineArray();
                
                SetHighColor(tint_color(base, B_DARKEN_2_TINT));
                StrokeRect(r);
        } else {
                // Plain border
                SetHighColor(0, 0, 0);  
                StrokeRect(fBitmapRect);
        }
}


void
BitmapView::MouseDown(BPoint pt)
{
        BPoint mousept;
        uint32 buttons;
        
        GetMouse(&mousept, &buttons);
        if (buttons & B_SECONDARY_MOUSE_BUTTON) {
                ConvertToScreen(&mousept);
                
                mousept.x= (mousept.x>5) ? mousept.x-5 : 0;
                mousept.y= (mousept.y>5) ? mousept.y-5 : 0;
                
                if (AcceptsPaste() && ClipboardHasBitmap())
                        fPasteItem->SetEnabled(true);
                else
                        fPasteItem->SetEnabled(false);
                
                if (fRemovableBitmap && fBitmap)
                        fRemoveItem->SetEnabled(true);
                else
                        fRemoveItem->SetEnabled(false);
                
                fPopUpMenu->Go(mousept, true, true, true);
        }
}


void
BitmapView::FrameResized(float w, float h)
{
        CalculateBitmapRect();
}


void
BitmapView::CalculateBitmapRect(void)
{
        if (!fBitmap || fFixedSize) {
                fBitmapRect = Bounds().InsetByCopy(1, 1);
                return;
        }
        
        uint8 borderwidth = (fBorderStyle == B_FANCY_BORDER) ? 5 : 1;

        BRect r(Bounds());
        fBitmapRect= ScaleRectToFit(fBitmap->Bounds(), r.InsetByCopy(borderwidth, borderwidth));
}


void
BitmapView::SetAcceptDrops(bool accept)
{
        fAcceptDrops = accept;
}


void
BitmapView::SetAcceptPaste(bool accept)
{
        fAcceptPaste = accept;
}


void
BitmapView::SetConstrainDrops(bool value)
{
        fConstrainDrops = value;
}


void
BitmapView::MaxBitmapSize(float *width, float *height) const
{
        *width = fMaxWidth;
        *height = fMaxHeight;
}


void
BitmapView::SetMaxBitmapSize(const float &width, const float &height)
{
        fMaxWidth = width;
        fMaxHeight = height;
        
        ConstrainBitmap();
}


void
BitmapView::SetBitmapRemovable(bool isremovable)
{
        fRemovableBitmap = isremovable;
}


void
BitmapView::ConstrainBitmap(void)
{
        if (!fBitmap || fMaxWidth < 1 || fMaxHeight < 1)
                return;
        
        BRect r = ScaleRectToFit(fBitmap->Bounds(), BRect(0, 0, fMaxWidth - 1, fMaxHeight - 1));
        r.OffsetTo(0, 0);
        
        BBitmap *scaled = new BBitmap(r, fBitmap->ColorSpace(), true);
        BView *view = new BView(r, "drawview", 0, 0);
        
        scaled->Lock();
        scaled->AddChild(view);
        view->DrawBitmap(fBitmap, fBitmap->Bounds(), scaled->Bounds());
        scaled->Unlock();
        
        delete fBitmap;
        fBitmap = new BBitmap(scaled, false);
}


bool
BitmapView::ClipboardHasBitmap(void)
{
        BMessage *clip = NULL, flattened;
        uint8 clipval = CLIP_NONE;
        bool returnval;
        
        if (be_clipboard->Lock()) {
                clip = be_clipboard->Data();
                if (!clip->IsEmpty()) {
                        returnval = (clip->FindMessage("image/bitmap", &flattened) == B_OK);
                        if (returnval)
                                clipval = CLIP_BEOS;
                        else {
                                BString string;
                                returnval = (clip->FindString("class", &string) == B_OK && string == "BBitmap");
                                
                                // Try method Gobe Productive uses if that, too, didn't work
                                if (returnval)
                                        clipval = CLIP_SHOWIMAGE;
                                else {
                                        returnval = (clip->FindMessage("image/x-vnd.Be-bitmap", &flattened) == B_OK);
                                        if (returnval)
                                                clipval = CLIP_SHOWIMAGE;
                                        else
                                                clipval = CLIP_NONE;
                                }
                        }
                }
                be_clipboard->Unlock();
        }
        return (clipval != CLIP_NONE)?true:false;
}


BBitmap *
BitmapView::BitmapFromClipboard(void)
{
        BMessage *clip = NULL, flattened;
        BBitmap *bitmap;
        
        if (!be_clipboard->Lock()) 
                return NULL;
        
        clip = be_clipboard->Data();
        if (!clip)
                return NULL;
        
        uint8 clipval = CLIP_NONE;
        
        // Try ArtPaint-style storage
        status_t status = clip->FindMessage("image/bitmap", &flattened);
        
        // If that didn't work, try ShowImage-style
        if (status != B_OK) {
                BString string;
                status = clip->FindString("class", &string);
                
                // Try method Gobe Productive uses if that, too, didn't work
                if (status == B_OK && string == "BBitmap")
                        clipval = CLIP_SHOWIMAGE;
                else {
                        status = clip->FindMessage("image/x-vnd.Be-bitmap", &flattened);
                        if (status == B_OK)
                                clipval = CLIP_PRODUCTIVE;
                        else
                                clipval = CLIP_NONE;
                }
        }
        else
                clipval = CLIP_BEOS;
        
        be_clipboard->Unlock();
        
        switch (clipval) {
                case CLIP_SHOWIMAGE: {
                        // Showimage does it a slightly different way -- it dumps the BBitmap
                        // data directly to the clipboard message instead of packaging it in
                        // a bitmap like everyone else.
                        
                        if (!be_clipboard->Lock())
                                return NULL;
                        
                        BMessage datamsg(*be_clipboard->Data());
                        
                        be_clipboard->Unlock();
                        
                        const void *buffer;
                        ssize_t bufferLength;
                        
                        BRect frame;
                        color_space cspace = B_NO_COLOR_SPACE;
                        
                        status = datamsg.FindRect("_frame", &frame);
                        if (status != B_OK)
                                return NULL;
                        
                        status = datamsg.FindInt32("_cspace", (int32)cspace);
                        if (status != B_OK)
                                return NULL;
                        cspace = B_RGBA32;
                        bitmap = new BBitmap(frame, cspace, true);
                        
                        status = datamsg.FindData("_data", B_RAW_TYPE, (const void **)&buffer, &bufferLength);
                        if (status != B_OK) {
                                delete bitmap;
                                return NULL;
                        }
                        
                        memcpy(bitmap->Bits(), buffer, bufferLength);
                        return bitmap;
                }
                case CLIP_PRODUCTIVE:
                // Productive doesn't name the packaged BBitmap data message the same, but
                // uses exactly the same data format.
                
                case CLIP_BEOS: {
                        const void *buffer;
                        ssize_t bufferLength;
                        
                        BRect frame;
                        color_space cspace = B_NO_COLOR_SPACE;
                        
                        status = flattened.FindRect("_frame", &frame);
                        if (status != B_OK)
                                return NULL;
                        
                        status = flattened.FindInt32("_cspace", (int32)cspace);
                        if (status != B_OK)
                                return NULL;
                        cspace = B_RGBA32;
                        bitmap = new BBitmap(frame, cspace, true);
                        
                        status = flattened.FindData("_data", B_RAW_TYPE, (const void **)&buffer, &bufferLength);
                        if (status != B_OK) {
                                delete bitmap;
                                return NULL;
                        }
                        
                        memcpy(bitmap->Bits(), buffer, bufferLength);
                        return bitmap;
                }
                default:
                        return NULL;
        }
        
        // shut the compiler up
        return NULL;
}


BRect
ScaleRectToFit(const BRect &from, const BRect &to)
{
        // Dynamic sizing algorithm
        // 1) Check to see if either dimension is bigger than the view's display area
        // 2) If smaller along both axes, make bitmap rect centered and return
        // 3) Check to see if scaling is to be horizontal or vertical on basis of longer axis
        // 4) Calculate scaling factor
        // 5) Scale both axes down by scaling factor, accounting for border width
        // 6) Center the rectangle in the direction of the smaller axis
        
        if (!to.IsValid())
                return from;
        if (!from.IsValid())
                return to;
        
        BRect r(to);
        
        if ((from.Width() <= r.Width()) && (from.Height() <= r.Height())) {
                // Smaller than view, so just center and return
                r = from;
                r.OffsetBy((to.Width() - r.Width()) / 2, (to.Height() - r.Height()) / 2);
                return r;
        }
        
        float multiplier = from.Width()/from.Height();
        if (multiplier > 1)     {
                // Landscape orientation
                
                // Scale rectangle to bounds width and center height
                r.bottom = r.top + (r.Width() / multiplier);
                r.OffsetBy(0, (to.Height() - r.Height()) / 2);
        } else {
                // Portrait orientation

                // Scale rectangle to bounds height and center width
                r.right = r.left + (r.Height() * multiplier);
                r.OffsetBy((to.Width() - r.Width()) / 2, 0);
        }
        return r;
}


void
BitmapView::RemoveBitmap(void)
{
        SetBitmap(NULL);
}


void
BitmapView::PasteBitmap(void)
{
        BBitmap *bmp = BitmapFromClipboard();
        if (bmp)
                SetBitmap(bmp);
        
        if (fConstrainDrops)
                ConstrainBitmap();
}