/*
 * Copyright 2002-2025 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              DarkWyrm, darkwyrm@earthlink.net
 *              Rene Gollent, rene@gollent.com
 *              John Scipione, jscipione@gmail.com
 *              Joseph Groover <looncraz@looncraz.net>
 */



#include <stdio.h>

#include <Alert.h>
#include <Catalog.h>
#include <ColorItem.h>
#include <ColorListView.h>
#include <DefaultColors.h>
#include <Directory.h>
#include <Entry.h>
#include <File.h>
#include <HSL.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <Messenger.h>
#include <Path.h>
#include <SpaceLayoutItem.h>

#include "AppearanceWindow.h"
#include "Colors.h"
#include "ColorsView.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Colors tab"


#define COLOR_DROPPED 'cldp'
#define AUTO_ADJUST_CHANGED 'madj'
#define UPDATE_COLOR 'upcl'
#define ATTRIBUTE_CHOSEN 'atch'

using BPrivate::BColorItem;
using BPrivate::BColorListView;
using BPrivate::BColorPreview;


ColorsView::ColorsView(const char* name)
        :
        BView(name, B_WILL_DRAW)
{
        SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

        LoadSettings();

        fAutoSelectCheckBox = new BCheckBox(B_TRANSLATE("Automatically pick secondary colors"),
                new BMessage(AUTO_ADJUST_CHANGED));
        fAutoSelectCheckBox->SetValue(true);

        // Set up list of color attributes
        fAttrList = new BColorListView("AttributeList");

        fScrollView = new BScrollView("ScrollView", fAttrList, 0, false, true);
        fScrollView->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

        _CreateItems();

        fColorPreview = new BColorPreview("color preview", "", new BMessage(COLOR_DROPPED));

        fPicker = new BColorControl(B_ORIGIN, B_CELLS_32x8, 8.0,
                "picker", new BMessage(UPDATE_COLOR));

        BLayoutBuilder::Group<>(this, B_VERTICAL)
                .Add(fAutoSelectCheckBox)
                .Add(fScrollView, 10.0)
                .AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING)
                        .Add(fColorPreview)
                        .AddGlue()
                        .Add(fPicker)
                        .End()
                .SetInsets(B_USE_WINDOW_SPACING);

        fColorPreview->Parent()->SetExplicitMaxSize(BSize(B_SIZE_UNSET, fPicker->Bounds().Height()));
        fAttrList->SetSelectionMessage(new BMessage(ATTRIBUTE_CHOSEN));
}


ColorsView::~ColorsView()
{
}


void
ColorsView::AttachedToWindow()
{
        fAutoSelectCheckBox->SetTarget(this);
        fPicker->SetTarget(this);
        fAttrList->SetTarget(this);
        fColorPreview->SetTarget(this);

        fAttrList->Select(0);
        SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
}


void
ColorsView::MessageReceived(BMessage* message)
{
        if (message->WasDropped()) {
                char* name;
                type_code type;
                rgb_color* color;
                ssize_t size;
                if (message->GetInfo(B_RGB_COLOR_TYPE, 0, &name, &type) == B_OK
                        && message->FindData(name, type, (const void**)&color, &size) == B_OK) {
                        BPoint dropLoc = message->DropPoint();
                        if (fAttrList->Bounds().Contains(fAttrList->ConvertFromScreen(dropLoc))) {
                                // dropped on color list view
                                int32 index = fAttrList->IndexOf(fAttrList->ConvertFromScreen(dropLoc));
                                bool selected = index == fAttrList->CurrentSelection();
                                if (index < 0 || index >= fAttrList->CountItems() || selected)
                                        _SetCurrentColor(*color);
                                else
                                        _SetColor(index, *color);

                                Window()->PostMessage(kMsgUpdate);
                        } else if (fColorPreview->Bounds().Contains(fColorPreview->ConvertFromScreen(dropLoc))
                                || fPicker->Bounds().Contains(fPicker->ConvertFromScreen(dropLoc))) {
                                // dropped on color preview or color control
                                _SetCurrentColor(*color);
                                Window()->PostMessage(kMsgUpdate);
                        }
                }
        }

        switch (message->what) {
                case UPDATE_COLOR:
                {
                        // Received from the color fPicker when its color changes

                        rgb_color color = fPicker->ValueAsColor();
                        _SetCurrentColor(color);
                        Window()->PostMessage(kMsgUpdate);
                        break;
                }

                case ATTRIBUTE_CHOSEN:
                {
                        // Received when the user chooses a GUI fAttribute from the list

                        int32 index = fAttrList->CurrentSelection();
                        if (index < 0 || index >= fAttrList->CountItems())
                                break;

                        BColorItem* item = dynamic_cast<BColorItem*>(fAttrList->ItemAt(index));
                        if (item != NULL) {
                                fWhich = item->ColorWhich();
                                rgb_color color = ui_color(fWhich);
                                _SetCurrentColor(color);
                        }
                        break;
                }

                case AUTO_ADJUST_CHANGED:
                {
                        _CreateItems();
                        break;
                }

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


void
ColorsView::LoadSettings()
{
        get_default_colors(&fDefaultColors);
        get_current_colors(&fCurrentColors);
        fPrevColors = fCurrentColors;
}


void
ColorsView::SetDefaults()
{
        _SetUIColors(fDefaultColors);
        _UpdatePreviews(fDefaultColors);

        // Use a default color that stands out to show errors clearly
        rgb_color color = fDefaultColors.GetColor(ui_color_name(fWhich),
                make_color(255, 0, 255));

        fPicker->SetValue(color);
        fColorPreview->SetColor(color);
        fColorPreview->Invalidate();

        Window()->PostMessage(kMsgUpdate);
}


void
ColorsView::Revert()
{
        _SetUIColors(fPrevColors);
        _UpdatePreviews(fPrevColors);

        rgb_color color = fPrevColors.GetColor(ui_color_name(fWhich), make_color(255, 0, 255));
        fPicker->SetValue(color);
        fColorPreview->SetColor(color);
        fColorPreview->Invalidate();

        Window()->PostMessage(kMsgUpdate);
}


bool
ColorsView::IsDefaultable()
{
        return !fDefaultColors.HasSameData(fCurrentColors);
}


bool
ColorsView::IsRevertable()
{
        return !fPrevColors.HasSameData(fCurrentColors);
}


void
ColorsView::_CreateItems()
{
        while (fAttrList->CountItems() > 0)
                delete fAttrList->RemoveItem((int32)0);

        const bool autoSelect = fAutoSelectCheckBox->Value();
        const int32 count = color_description_count();
        for (int32 i = 0; i < count; i++) {
                const ColorDescription& description = *get_color_description(i);
                const color_which which = description.which;
                if (autoSelect) {
                        if (which != B_PANEL_BACKGROUND_COLOR
                                        && which != B_STATUS_BAR_COLOR
                                        && which != B_WINDOW_TAB_COLOR) {
                                continue;
                        }
                }

                const char* text = B_TRANSLATE_NOCOLLECT(description.text);
                fAttrList->AddItem(new BColorItem(text, which, ui_color(which)));
        }

        if (Window() != NULL)
                fAttrList->Select(0);
}


void
ColorsView::_UpdatePreviews(const BMessage& colors)
{
        rgb_color color;
        for (int32 i = color_description_count() - 1; i >= 0; i--) {
                BColorItem* item = static_cast<BColorItem*>(fAttrList->ItemAt(i));
                if (item == NULL)
                        continue;

                color = colors.GetColor(ui_color_name(item->ColorWhich()),
                        make_color(255, 0, 255));

                item->SetColor(color);
                fAttrList->InvalidateItem(i);
        }
}


void
ColorsView::_SetUIColors(const BMessage& colors)
{
        set_ui_colors(&colors);
        fCurrentColors = colors;
}


void
ColorsView::_SetCurrentColor(rgb_color color)
{
        _SetColor(fAttrList->CurrentSelection(), color);
        fPicker->SetValue(color);
        fColorPreview->SetColor(color);
}


void
ColorsView::_SetColor(int32 index, rgb_color color)
{
        BColorItem* item = dynamic_cast<BColorItem*>(fAttrList->ItemAt(index));
        if (item != NULL) {
                item->SetColor(color);
                fAttrList->InvalidateItem(index);
                _SetColor(item->ColorWhich(), color);
        }
}


void
ColorsView::_SetColor(color_which which, rgb_color color)
{
        fCurrentColors.SetColor(ui_color_name(which), color);

        if (!fAutoSelectCheckBox->Value()) {
                if (ui_color(which) != color)
                        set_ui_color(which, color);
                return;
        }

        // Protect against accidentally overwriting colors.
        if (ui_color(which) == color)
                return;

        if (which == B_PANEL_BACKGROUND_COLOR) {
                const bool isDark = color.IsDark();

                fCurrentColors.SetColor(ui_color_name(B_MENU_BACKGROUND_COLOR), color);

                const rgb_color menuSelectedBackground
                        = tint_color(color, isDark ? 0.8 /* lighten "< 1" */ : B_DARKEN_2_TINT);
                fCurrentColors.SetColor(ui_color_name(B_MENU_SELECTED_BACKGROUND_COLOR),
                        menuSelectedBackground);

                const rgb_color controlBackground = tint_color(color,
                        0.84 /* lighten "< 1" */);
                fCurrentColors.SetColor(ui_color_name(B_CONTROL_BACKGROUND_COLOR), controlBackground);
                fCurrentColors.SetColor(ui_color_name(B_SCROLL_BAR_THUMB_COLOR), controlBackground);

                const rgb_color controlBorder
                        = tint_color(color, isDark ? 0.4875 : 1.20 /* lighten/darken "1.5" */);
                fCurrentColors.SetColor(ui_color_name(B_CONTROL_BORDER_COLOR), controlBorder);

                const rgb_color windowBorder = tint_color(color, 0.75);
                fCurrentColors.SetColor(ui_color_name(B_WINDOW_BORDER_COLOR), windowBorder);

                const rgb_color inactiveWindowBorder = tint_color(color, B_LIGHTEN_1_TINT);
                fCurrentColors.SetColor(ui_color_name(B_WINDOW_INACTIVE_TAB_COLOR),
                        inactiveWindowBorder);
                fCurrentColors.SetColor(ui_color_name(B_WINDOW_INACTIVE_BORDER_COLOR),
                        inactiveWindowBorder);

                const rgb_color listSelectedBackground
                        = tint_color(color, isDark ? 0.77 : 1.12 /* lighten/darken "< 1" */ );
                fCurrentColors.SetColor(ui_color_name(B_LIST_SELECTED_BACKGROUND_COLOR),
                        listSelectedBackground);

                const color_which fromDefaults[] = {
                        B_MENU_ITEM_TEXT_COLOR,
                        B_MENU_SELECTED_ITEM_TEXT_COLOR,
                        B_MENU_SELECTED_BORDER_COLOR,
                        B_PANEL_TEXT_COLOR,
                        B_DOCUMENT_BACKGROUND_COLOR,
                        B_DOCUMENT_TEXT_COLOR,
                        B_CONTROL_TEXT_COLOR,
                        B_NAVIGATION_PULSE_COLOR,
                        B_WINDOW_INACTIVE_TEXT_COLOR,
                        B_LIST_BACKGROUND_COLOR,
                        B_LIST_ITEM_TEXT_COLOR,
                        B_LIST_SELECTED_ITEM_TEXT_COLOR,

                        B_SHINE_COLOR,
                        B_SHADOW_COLOR,

                        B_LINK_TEXT_COLOR,
                        B_LINK_HOVER_COLOR,
                        B_LINK_ACTIVE_COLOR,
                        B_LINK_VISITED_COLOR,
                };
                for (size_t i = 0; i < B_COUNT_OF(fromDefaults); i++)
                        fCurrentColors.SetColor(ui_color_name(fromDefaults[i])
                                , BPrivate::GetSystemColor(fromDefaults[i], isDark));
        } else if (which == B_STATUS_BAR_COLOR) {
                const hsl_color statusColorHSL = hsl_color::from_rgb(color);

                hsl_color controlHighlight = statusColorHSL;
                controlHighlight.saturation = max_c(0.2f, controlHighlight.saturation / 2.f);
                fCurrentColors.SetColor(ui_color_name(B_CONTROL_HIGHLIGHT_COLOR)
                        , controlHighlight.to_rgb());

                hsl_color controlMark = statusColorHSL;
                controlMark.saturation = max_c(0.2f, controlMark.saturation * 0.67f);
                controlMark.lightness = max_c(0.25f, controlMark.lightness * 0.55f);
                fCurrentColors.SetColor(ui_color_name(B_CONTROL_MARK_COLOR), controlMark.to_rgb());

                rgb_color keyboardNav; {
                        hsl_color keyboardNavHSL = statusColorHSL;
                        keyboardNavHSL.lightness = max_c(0.2f, keyboardNavHSL.lightness * 0.75f);
                        keyboardNav = keyboardNavHSL.to_rgb();

                        // Use primary color channel only.
                        if (keyboardNav.blue >= max_c(keyboardNav.red, keyboardNav.green))
                                keyboardNav.red = keyboardNav.green = 0;
                        else if (keyboardNav.red >= max_c(keyboardNav.green, keyboardNav.blue))
                                keyboardNav.green = keyboardNav.blue = 0;
                        else
                                keyboardNav.red = keyboardNav.blue = 0;
                }
                fCurrentColors.SetColor(ui_color_name(B_KEYBOARD_NAVIGATION_COLOR), keyboardNav);
        } else if (which == B_WINDOW_TAB_COLOR) {
                const bool isDark = color.IsDark();
                const hsl_color tabColorHSL = hsl_color::from_rgb(color);
                const float tabColorSaturation
                        = tabColorHSL.saturation != 0 ? tabColorHSL.saturation : tabColorHSL.lightness;

                fCurrentColors.SetColor(ui_color_name(B_WINDOW_TEXT_COLOR),
                        BPrivate::GetSystemColor(B_WINDOW_TEXT_COLOR, isDark));
                fCurrentColors.SetColor(ui_color_name(B_TOOL_TIP_TEXT_COLOR),
                        BPrivate::GetSystemColor(B_TOOL_TIP_TEXT_COLOR, isDark));

                const rgb_color toolTipBackground = tint_color(color, isDark ? 1.7 : 0.15);
                fCurrentColors.SetColor(ui_color_name(B_TOOL_TIP_BACKGROUND_COLOR), toolTipBackground);

                hsl_color success = hsl_color::from_rgb(BPrivate::GetSystemColor(B_SUCCESS_COLOR, isDark));
                success.saturation = max_c(0.25f, tabColorSaturation * 0.68f);
                fCurrentColors.SetColor(ui_color_name(B_SUCCESS_COLOR), success.to_rgb());

                hsl_color failure = hsl_color::from_rgb(BPrivate::GetSystemColor(B_FAILURE_COLOR, isDark));
                failure.saturation = max_c(0.25f, tabColorSaturation);
                fCurrentColors.SetColor(ui_color_name(B_FAILURE_COLOR), failure.to_rgb());
        }
        set_ui_colors(&fCurrentColors);
}