/*
 * Copyright 2006-2012, Stephan Aßmus <superstippi@gmx.de>.
 * Copyright 2023, Haiku.
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Zardshard
 */


#include "StyleListView.h"

#include <new>
#include <stdio.h>

#include <Application.h>
#include <Catalog.h>
#include <ListItem.h>
#include <Locale.h>
#include <Menu.h>
#include <MenuItem.h>
#include <Message.h>
#include <Mime.h>
#include <Window.h>

#include "AddStylesCommand.h"
#include "AssignStyleCommand.h"
#include "CurrentColor.h"
#include "CommandStack.h"
#include "GradientTransformable.h"
#include "MoveStylesCommand.h"
#include "PathSourceShape.h"
#include "RemoveStylesCommand.h"
#include "Style.h"
#include "Observer.h"
#include "ResetTransformationCommand.h"
#include "Shape.h"
#include "Selection.h"
#include "Util.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Icon-O-Matic-StylesList"


using std::nothrow;

static const float kMarkWidth           = 14.0;
static const float kBorderOffset        = 3.0;
static const float kTextOffset          = 4.0;

enum {
        MSG_ADD                                                 = 'adst',
        MSG_REMOVE                                              = 'rmst',
        MSG_DUPLICATE                                   = 'dpst',
        MSG_RESET_TRANSFORMATION                = 'rstr',
};

class StyleListItem : public SimpleItem,
                                         public Observer {
public:
        StyleListItem(Style* s, StyleListView* listView, bool markEnabled)
                :
                SimpleItem(""),
                style(NULL),
                fListView(listView),
                fMarkEnabled(markEnabled),
                fMarked(false)
        {
                SetStyle(s);
        }

        virtual ~StyleListItem()
        {
                SetStyle(NULL);
        }

        // SimpleItem interface
        virtual void DrawItem(BView* owner, BRect itemFrame, bool even)
        {
                SimpleItem::DrawBackground(owner, itemFrame, even);

                float offset = kBorderOffset + kMarkWidth + kTextOffset;
                SimpleItem::DrawItem(owner, itemFrame.OffsetByCopy(offset, 0), even);

                if (!fMarkEnabled)
                        return;

                // mark
                BRect markRect = itemFrame;
                float markRectBorderTint = B_DARKEN_1_TINT;
                float markRectFillTint = 1.04;
                float markTint = B_DARKEN_4_TINT;
                                        // Dark Themes
                rgb_color lowColor = owner->LowColor();
                if (lowColor.red + lowColor.green + lowColor.blue < 128 * 3) {
                        markRectBorderTint = B_LIGHTEN_2_TINT;
                        markRectFillTint = 0.85;
                        markTint = 0.1;
                }
                markRect.left += kBorderOffset;
                markRect.right = markRect.left + kMarkWidth;
                markRect.top = (markRect.top + markRect.bottom - kMarkWidth) / 2.0;
                markRect.bottom = markRect.top + kMarkWidth;
                owner->SetHighColor(tint_color(owner->LowColor(), markRectBorderTint));
                owner->StrokeRect(markRect);
                markRect.InsetBy(1, 1);
                owner->SetHighColor(tint_color(owner->LowColor(), markRectFillTint));
                owner->FillRect(markRect);
                if (fMarked) {
                        markRect.InsetBy(2, 2);
                        owner->SetHighColor(tint_color(owner->LowColor(),
                                markTint));
                        owner->SetPenSize(2);
                        owner->StrokeLine(markRect.LeftTop(), markRect.RightBottom());
                        owner->StrokeLine(markRect.LeftBottom(), markRect.RightTop());
                        owner->SetPenSize(1);
                }
        }

        // Observer interface
        virtual void    ObjectChanged(const Observable* object)
        {
                UpdateText();
        }

        // StyleListItem
        void SetStyle(Style* s)
        {
                if (s == style)
                        return;

                if (style) {
                        style->RemoveObserver(this);
                        style->ReleaseReference();
                }

                style = s;

                if (style) {
                        style->AcquireReference();
                        style->AddObserver(this);
                        UpdateText();
                }
        }

        void UpdateText()
        {
                SetText(style->Name());
                Invalidate();
        }

        void SetMarkEnabled(bool enabled)
        {
                if (fMarkEnabled == enabled)
                        return;
                fMarkEnabled = enabled;
                Invalidate();
        }

        void SetMarked(bool marked)
        {
                if (fMarked == marked)
                        return;
                fMarked = marked;
                Invalidate();
        }

        void Invalidate()
        {
                if (fListView->LockLooper()) {
                        fListView->InvalidateItem(fListView->IndexOf(this));
                        fListView->UnlockLooper();
                }
        }

public:
        Style*                  style;

private:
        StyleListView*  fListView;
        bool                    fMarkEnabled;
        bool                    fMarked;
};


class ShapeStyleListener : public ShapeListener,
        public ContainerListener<Shape> {
public:
        ShapeStyleListener(StyleListView* listView)
                :
                fListView(listView),
                fShape(NULL)
        {
        }

        virtual ~ShapeStyleListener()
        {
                SetShape(NULL);
        }

        // ShapeListener interface
        virtual void TransformerAdded(Transformer* t, int32 index)
        {
        }
        
        virtual void TransformerRemoved(Transformer* t)
        {
        }

        virtual void StyleChanged(Style* oldStyle, Style* newStyle)
        {
                fListView->_SetStyleMarked(oldStyle, false);
                fListView->_SetStyleMarked(newStyle, true);
        }

        // ContainerListener<Shape> interface
        virtual void ItemAdded(Shape* shape, int32 index)
        {
        }

        virtual void ItemRemoved(Shape* shape)
        {
                fListView->SetCurrentShape(NULL);
        }

        // ShapeStyleListener
        void SetShape(PathSourceShape* shape)
        {
                if (fShape == shape)
                        return;

                if (fShape)
                        fShape->RemoveListener(this);

                fShape = shape;

                if (fShape)
                        fShape->AddListener(this);
        }

        PathSourceShape* CurrentShape() const
        {
                return fShape;
        }

private:
        StyleListView*          fListView;
        PathSourceShape*        fShape;
};


// #pragma mark -


StyleListView::StyleListView(BRect frame, const char* name, BMessage* message,
        BHandler* target)
        :
        SimpleListView(frame, name, NULL, B_SINGLE_SELECTION_LIST),
        fMessage(message),
        fStyleContainer(NULL),
        fShapeContainer(NULL),
        fCommandStack(NULL),
        fCurrentColor(NULL),

        fCurrentShape(NULL),
        fShapeListener(new ShapeStyleListener(this)),

        fMenu(NULL)
{
        SetTarget(target);
}


StyleListView::~StyleListView()
{
        _MakeEmpty();
        delete fMessage;

        if (fStyleContainer != NULL)
                fStyleContainer->RemoveListener(this);

        if (fShapeContainer != NULL)
                fShapeContainer->RemoveListener(fShapeListener);

        delete fShapeListener;
}


// #pragma mark -


void
StyleListView::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_ADD:
                {
                        Style* style;
                        AddStylesCommand* command;
                        rgb_color color;
                        if (fCurrentColor != NULL)
                                color = fCurrentColor->Color();
                        else {
                                color.red = 0;
                                color.green = 0;
                                color.blue = 0;
                                color.alpha = 255;
                        }
                        new_style(color, fStyleContainer, &style, &command);
                        fCommandStack->Perform(command);
                        break;
                }

                case MSG_REMOVE:
                        RemoveSelected();
                        break;

                case MSG_DUPLICATE:
                {
                        int32 count = CountSelectedItems();
                        int32 index = 0;
                        BList items;
                        for (int32 i = 0; i < count; i++) {
                                index = CurrentSelection(i);
                                BListItem* item = ItemAt(index);
                                if (item)
                                        items.AddItem((void*)item);
                        }
                        CopyItems(items, index + 1);
                        break;
                }

                case MSG_RESET_TRANSFORMATION:
                {
                        int32 count = CountSelectedItems();
                        BList gradients;
                        for (int32 i = 0; i < count; i++) {
                                StyleListItem* item = dynamic_cast<StyleListItem*>(
                                        ItemAt(CurrentSelection(i)));
                                if (item && item->style && item->style->Gradient()) {
                                        if (!gradients.AddItem((void*)item->style->Gradient()))
                                                break;
                                }
                        }
                        count = gradients.CountItems();
                        if (count <= 0)
                                break;

                        Transformable* transformables[count];
                        for (int32 i = 0; i < count; i++) {
                                Gradient* gradient = (Gradient*)gradients.ItemAtFast(i);
                                transformables[i] = gradient;
                        }

                        ResetTransformationCommand* command
                                = new ResetTransformationCommand(transformables, count);

                        fCommandStack->Perform(command);
                        break;
                }

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


void
StyleListView::SelectionChanged()
{
        SimpleListView::SelectionChanged();

        if (!fSyncingToSelection) {
                // NOTE: single selection list
                StyleListItem* item
                        = dynamic_cast<StyleListItem*>(ItemAt(CurrentSelection(0)));
                if (fMessage) {
                        BMessage message(*fMessage);
                        message.AddPointer("style", item ? (void*)item->style : NULL);
                        Invoke(&message);
                }
        }

        _UpdateMenu();
}


void
StyleListView::MouseDown(BPoint where)
{
        if (fCurrentShape == NULL) {
                SimpleListView::MouseDown(where);
                return;
        }

        bool handled = false;
        int32 index = IndexOf(where);
        StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(index));
        if (item != NULL) {
                BRect itemFrame(ItemFrame(index));
                itemFrame.right = itemFrame.left + kBorderOffset + kMarkWidth
                        + kTextOffset / 2.0;
                Style* style = item->style;
                if (itemFrame.Contains(where)) {
                        // set the style on the shape
                        if (fCommandStack) {
                                ::Command* command = new AssignStyleCommand(
                                                                                        fCurrentShape, style);
                                fCommandStack->Perform(command);
                        } else {
                                fCurrentShape->SetStyle(style);
                        }
                        handled = true;
                }
        }

        if (!handled)
                SimpleListView::MouseDown(where);
}


status_t
StyleListView::ArchiveSelection(BMessage* into, bool deep) const
{
        into->what = StyleListView::kSelectionArchiveCode;

        int32 count = CountSelectedItems();
        for (int32 i = 0; i < count; i++) {
                StyleListItem* item = dynamic_cast<StyleListItem*>(
                        ItemAt(CurrentSelection(i)));
                if (item != NULL) {
                        BMessage archive;
                        if (item->style->Archive(&archive, true) == B_OK)
                                into->AddMessage("style", &archive);
                } else
                        return B_ERROR;
        }
        return B_OK;
}


bool
StyleListView::InstantiateSelection(const BMessage* archive, int32 dropIndex)
{
        if (archive->what != StyleListView::kSelectionArchiveCode
                || fCommandStack == NULL || fStyleContainer == NULL)
                return false;

        // Drag may have come from another instance, like in another window.
        // Reconstruct the Styles from the archive and add them at the drop
        // index.
        int index = 0;
        BList styles;
        while (true) {
                BMessage styleArchive;
                if (archive->FindMessage("style", index, &styleArchive) != B_OK)
                        break;
                Style* style = new(std::nothrow) Style(&styleArchive);
                if (style == NULL)
                        break;

                if (!styles.AddItem(style)) {
                        delete style;
                        break;
                }

                index++;
        }

        int32 count = styles.CountItems();
        if (count == 0)
                return false;

        AddCommand<Style>* command = new(std::nothrow) AddCommand<Style>(
                fStyleContainer, (Style**)styles.Items(), count, true, dropIndex);

        if (command == NULL) {
                for (int32 i = 0; i < count; i++)
                        delete (Style*)styles.ItemAtFast(i);
                return false;
        }

        fCommandStack->Perform(command);

        return true;
}


void
StyleListView::MoveItems(BList& items, int32 toIndex)
{
        if (fCommandStack == NULL || fStyleContainer == NULL)
                return;

        int32 count = items.CountItems();
        Style** styles = new (nothrow) Style*[count];
        if (styles == NULL)
                return;

        for (int32 i = 0; i < count; i++) {
                StyleListItem* item
                        = dynamic_cast<StyleListItem*>((BListItem*)items.ItemAtFast(i));
                styles[i] = item ? item->style : NULL;
        }

        MoveStylesCommand* command = new (nothrow) MoveStylesCommand(
                fStyleContainer, styles, count, toIndex);
        if (command == NULL) {
                delete[] styles;
                return;
        }

        fCommandStack->Perform(command);
}


void
StyleListView::CopyItems(BList& items, int32 toIndex)
{
        if (fCommandStack == NULL || fStyleContainer == NULL)
                return;

        int32 count = items.CountItems();
        Style* styles[count];

        for (int32 i = 0; i < count; i++) {
                StyleListItem* item
                        = dynamic_cast<StyleListItem*>((BListItem*)items.ItemAtFast(i));
                styles[i] = item ? new (nothrow) Style(*item->style) : NULL;
        }

        AddCommand<Style>* command
                = new (nothrow) AddCommand<Style>(fStyleContainer, styles, count, true, toIndex);
        if (!command) {
                for (int32 i = 0; i < count; i++)
                        delete styles[i];
                return;
        }

        fCommandStack->Perform(command);
}


void
StyleListView::RemoveItemList(BList& items)
{
        if (!fCommandStack || !fStyleContainer)
                return;

        int32 count = items.CountItems();
        int32 indices[count];
        for (int32 i = 0; i < count; i++)
                indices[i] = IndexOf((BListItem*)items.ItemAtFast(i));

        RemoveStylesCommand* command
                = new (nothrow) RemoveStylesCommand(fStyleContainer, indices, count);
        fCommandStack->Perform(command);
}


BListItem*
StyleListView::CloneItem(int32 index) const
{
        if (StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(index))) {
                return new StyleListItem(item->style,
                        const_cast<StyleListView*>(this),
                        fCurrentShape != NULL);
        }
        return NULL;
}


int32
StyleListView::IndexOfSelectable(Selectable* selectable) const
{
        Style* style = dynamic_cast<Style*>(selectable);
        if (style == NULL)
                return -1;

        int count = CountItems();
        for (int32 i = 0; i < count; i++) {
                if (SelectableFor(ItemAt(i)) == style)
                        return i;
        }

        return -1;
}


Selectable*
StyleListView::SelectableFor(BListItem* item) const
{
        StyleListItem* styleItem = dynamic_cast<StyleListItem*>(item);
        if (styleItem != NULL)
                return styleItem->style;
        return NULL;
}


// #pragma mark -


void
StyleListView::ItemAdded(Style* style, int32 index)
{
        // NOTE: we are in the thread that messed with the
        // StyleContainer, so no need to lock the
        // container, when this is changed to asynchronous
        // notifications, then it would need to be read-locked!
        if (!LockLooper())
                return;

        if (_AddStyle(style, index))
                Select(index);

        UnlockLooper();
}


void
StyleListView::ItemRemoved(Style* style)
{
        // NOTE: we are in the thread that messed with the
        // StyleContainer, so no need to lock the
        // container, when this is changed to asynchronous
        // notifications, then it would need to be read-locked!
        if (!LockLooper())
                return;

        // NOTE: we're only interested in Style objects
        _RemoveStyle(style);

        UnlockLooper();
}


// #pragma mark -


void
StyleListView::SetMenu(BMenu* menu)
{
        if (fMenu == menu)
                return;

        fMenu = menu;
        if (fMenu == NULL)
                return;

        fAddItem = new BMenuItem(B_TRANSLATE("Add"), new BMessage(MSG_ADD));
        fMenu->AddItem(fAddItem);

        fMenu->AddSeparatorItem();

        fDuplicateItem = new BMenuItem(B_TRANSLATE("Duplicate"),
                new BMessage(MSG_DUPLICATE));
        fMenu->AddItem(fDuplicateItem);

        fResetTransformationItem = new BMenuItem(B_TRANSLATE("Reset transformation"),
                new BMessage(MSG_RESET_TRANSFORMATION));
        fMenu->AddItem(fResetTransformationItem);

        fMenu->AddSeparatorItem();

        fRemoveItem = new BMenuItem(B_TRANSLATE("Remove"), new BMessage(MSG_REMOVE));
        fMenu->AddItem(fRemoveItem);

        fMenu->SetTargetForItems(this);

        _UpdateMenu();
}


void
StyleListView::SetStyleContainer(Container<Style>* container)
{
        if (fStyleContainer == container)
                return;

        // detach from old container
        if (fStyleContainer != NULL)
                fStyleContainer->RemoveListener(this);

        _MakeEmpty();

        fStyleContainer = container;

        if (fStyleContainer == NULL)
                return;

        fStyleContainer->AddListener(this);

        // sync
        int32 count = fStyleContainer->CountItems();
        for (int32 i = 0; i < count; i++)
                _AddStyle(fStyleContainer->ItemAtFast(i), i);
}


void
StyleListView::SetShapeContainer(Container<Shape>* container)
{
        if (fShapeContainer == container)
                return;

        // detach from old container
        if (fShapeContainer)
                fShapeContainer->RemoveListener(fShapeListener);

        fShapeContainer = container;

        if (fShapeContainer)
                fShapeContainer->AddListener(fShapeListener);
}


void
StyleListView::SetCommandStack(CommandStack* stack)
{
        fCommandStack = stack;
}


void
StyleListView::SetCurrentColor(CurrentColor* color)
{
        fCurrentColor = color;
}


void
StyleListView::SetCurrentShape(Shape* shape)
{
        PathSourceShape* pathSourceShape = dynamic_cast<PathSourceShape*>(shape);

        if (fCurrentShape == pathSourceShape)
                return;

        fCurrentShape = pathSourceShape;
        fShapeListener->SetShape(pathSourceShape);

        _UpdateMarks();
}


// #pragma mark -


bool
StyleListView::_AddStyle(Style* style, int32 index)
{
        if (style != NULL) {
                 return AddItem(new StyleListItem(
                        style, this, fCurrentShape != NULL), index);
        }
        return false;
}


bool
StyleListView::_RemoveStyle(Style* style)
{
        StyleListItem* item = _ItemForStyle(style);
        if (item != NULL && RemoveItem(item)) {
                delete item;
                return true;
        }
        return false;
}


StyleListItem*
StyleListView::_ItemForStyle(Style* style) const
{
        int count = CountItems();
        for (int32 i = 0; i < count; i++) {
                StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(i));
                if (item == NULL)
                        continue;
                if (item->style == style)
                        return item;
        }
        return NULL;
}


// #pragma mark -


void
StyleListView::_UpdateMarks()
{
        int32 count = CountItems();
        if (fCurrentShape) {
                // enable display of marks and mark items whoes
                // style is contained in fCurrentShape
                for (int32 i = 0; i < count; i++) {
                        StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(i));
                        if (item == NULL)
                                continue;
                        item->SetMarkEnabled(true);
                        item->SetMarked(fCurrentShape->Style() == item->style);
                }
        } else {
                // disable display of marks
                for (int32 i = 0; i < count; i++) {
                        StyleListItem* item = dynamic_cast<StyleListItem*>(ItemAt(i));
                        if (item == NULL)
                                continue;
                        item->SetMarkEnabled(false);
                }
        }

        Invalidate();
}


void
StyleListView::_SetStyleMarked(Style* style, bool marked)
{
        StyleListItem* item = _ItemForStyle(style);
        if (item != NULL)
                item->SetMarked(marked);
}


void
StyleListView::_UpdateMenu()
{
        if (fMenu == NULL)
                return;

        bool hasSelection = CurrentSelection(0) >= 0;

        fDuplicateItem->SetEnabled(hasSelection);
        // TODO: only enable fResetTransformationItem if styles
        // with gradients are selected!
        fResetTransformationItem->SetEnabled(hasSelection);
        fRemoveItem->SetEnabled(hasSelection);
}