/*
 * Copyright 2009-2010, Philippe Houdoin, phoudoin@haiku-os.org. All rights reserved.
 * Copyright 2013-2018, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */

#include "TeamsListView.h"

#include <algorithm>
#include <new>

#include <stdio.h>
#include <string.h>

#include <AppMisc.h>
#include <Bitmap.h>
#include <ColumnTypes.h>
#include <ControlLook.h>
#include <FindDirectory.h>
#include <MimeType.h>
#include <MessageRunner.h>
#include <NodeInfo.h>
#include <Path.h>
#include <Roster.h>
#include <String.h>

#include <AutoLocker.h>

#include "TargetHostInterface.h"


enum {
        MSG_SELECTED_INTERFACE_CHANGED = 'seic',
        MSG_TEAM_ADDED = 'tead',
        MSG_TEAM_REMOVED = 'tere',
        MSG_TEAM_RENAMED = 'tern'
};


// #pragma mark - BitmapStringField


BBitmapStringField::BBitmapStringField(BBitmap* bitmap, const char* string)
        :
        Inherited(string),
        fBitmap(bitmap)
{
}


BBitmapStringField::~BBitmapStringField()
{
        delete fBitmap;
}


void
BBitmapStringField::SetBitmap(BBitmap* bitmap)
{
        delete fBitmap;
        fBitmap = bitmap;
        // TODO: cause a redraw?
}


// #pragma mark - TeamsColumn


float TeamsColumn::sTextMargin = 0.0;


TeamsColumn::TeamsColumn(const char* title, float width, float minWidth,
                float maxWidth, uint32 truncateMode, alignment align)
        :
        Inherited(title, width, minWidth, maxWidth, align),
        fTruncateMode(truncateMode)
{
        SetWantsEvents(true);
}


void
TeamsColumn::DrawField(BField* field, BRect rect, BView* parent)
{
        BBitmapStringField* bitmapField
                = dynamic_cast<BBitmapStringField*>(field);
        BStringField* stringField = dynamic_cast<BStringField*>(field);

        if (bitmapField) {
                const BBitmap* bitmap = bitmapField->Bitmap();

                // figure out the placement
                float x = 0.0;
                BRect r = bitmap ? bitmap->Bounds() : BRect(0, 0, 15, 15);
                float y = rect.top + ((rect.Height() - r.Height()) / 2);
                float width = 0.0;

                switch (Alignment()) {
                        default:
                        case B_ALIGN_LEFT:
                        case B_ALIGN_CENTER:
                                x = rect.left + sTextMargin;
                                width = rect.right - (x + r.Width()) - (2 * sTextMargin);
                                r.Set(x + r.Width(), rect.top, rect.right - width, rect.bottom);
                                break;

                        case B_ALIGN_RIGHT:
                                x = rect.right - sTextMargin - r.Width();
                                width = (x - rect.left - (2 * sTextMargin));
                                r.Set(rect.left, rect.top, rect.left + width, rect.bottom);
                                break;
                }

                if (width != bitmapField->Width()) {
                        BString truncatedString(bitmapField->String());
                        parent->TruncateString(&truncatedString, fTruncateMode, width + 2);
                        bitmapField->SetClippedString(truncatedString.String());
                        bitmapField->SetWidth(width);
                }

                // draw the bitmap
                if (bitmap) {
                        parent->SetDrawingMode(B_OP_ALPHA);
                        parent->DrawBitmap(bitmap, BPoint(x, y));
                        parent->SetDrawingMode(B_OP_OVER);
                }

                // draw the string
                DrawString(bitmapField->ClippedString(), parent, r);

        } else if (stringField) {

                float width = rect.Width() - (2 * sTextMargin);

                if (width != stringField->Width()) {
                        BString truncatedString(stringField->String());

                        parent->TruncateString(&truncatedString, fTruncateMode, width + 2);
                        stringField->SetClippedString(truncatedString.String());
                        stringField->SetWidth(width);
                }

                DrawString(stringField->ClippedString(), parent, rect);
        }
}


float
TeamsColumn::GetPreferredWidth(BField *_field, BView* parent) const
{
        BBitmapStringField* bitmapField
                = dynamic_cast<BBitmapStringField*>(_field);
        BStringField* stringField = dynamic_cast<BStringField*>(_field);

        float parentWidth = Inherited::GetPreferredWidth(_field, parent);
        float width = 0.0;

        if (bitmapField) {
                const BBitmap* bitmap = bitmapField->Bitmap();
                BFont font;
                parent->GetFont(&font);
                width = font.StringWidth(bitmapField->String()) + 3 * sTextMargin;
                if (bitmap)
                        width += bitmap->Bounds().Width();
                else
                        width += 16;
        } else if (stringField) {
                BFont font;
                parent->GetFont(&font);
                width = font.StringWidth(stringField->String()) + 2 * sTextMargin;
        }
        return max_c(width, parentWidth);
}


bool
TeamsColumn::AcceptsField(const BField* field) const
{
        return dynamic_cast<const BStringField*>(field) != NULL;
}


void
TeamsColumn::InitTextMargin(BView* parent)
{
        BFont font;
        parent->GetFont(&font);
        sTextMargin = ceilf(font.Size() * 0.8);
}


// #pragma mark - TeamRow


enum {
        kNameColumn,
        kIDColumn
};


TeamRow::TeamRow(TeamInfo* info)
        : BRow(ceilf(be_control_look->DefaultLabelSpacing() * 3.3f))
{
        _SetTo(info);
}


bool
TeamRow::NeedsUpdate(TeamInfo* info)
{
        // Check if we need to rebuilt the row's fields because the team critical
        // info (basically, app image running under that team ID) has changed

        if (info->Arguments() != fTeamInfo.Arguments()) {
                _SetTo(info);
                return true;
        }

        return false;
}


status_t
TeamRow::_SetTo(TeamInfo* info)
{
        fTeamInfo = *info;

        app_info appInfo;
        status_t status = be_roster->GetRunningAppInfo(fTeamInfo.TeamID(),
                &appInfo);
        if (status != B_OK) {
                // Not an application known to be_roster

                if (fTeamInfo.TeamID() == B_SYSTEM_TEAM) {
                        // Get icon and name from kernel image
                        system_info     systemInfo;
                        get_system_info(&systemInfo);

                        BPath kernelPath;
                        find_directory(B_BEOS_SYSTEM_DIRECTORY, &kernelPath);
                        kernelPath.Append(systemInfo.kernel_name);

                        get_ref_for_path(kernelPath.Path(), &appInfo.ref);

                } else
                        BPrivate::get_app_ref(fTeamInfo.TeamID(), &appInfo.ref);
        }

        BBitmap* icon = new BBitmap(BRect(BPoint(0, 0),
                be_control_look->ComposeIconSize(B_MINI_ICON)), B_RGBA32);

        icon_size iconSize = (icon_size)(icon->Bounds().Width() + 1);
        status = BNodeInfo::GetTrackerIcon(&appInfo.ref, icon, iconSize);
        if (status != B_OK) {
                BMimeType genericAppType(B_APP_MIME_TYPE);
                status = genericAppType.GetIcon(icon, iconSize);
        }

        if (status != B_OK) {
                delete icon;
                icon = NULL;
        }

        BString tmp;
        tmp << fTeamInfo.TeamID();

        SetField(new BBitmapStringField(icon, fTeamInfo.Arguments()), kNameColumn);
        SetField(new BStringField(tmp), kIDColumn);

        return status;
}


//      #pragma mark - TeamsListView


TeamsListView::TeamsListView(const char* name)
        :
        Inherited(name, B_NAVIGABLE, B_PLAIN_BORDER),
        TargetHost::Listener(),
        TeamsWindow::Listener(),
        fInterface(NULL),
        fHost(NULL)
{
        AddColumn(new TeamsColumn("Name", 400, 100, 600,
                B_TRUNCATE_BEGINNING), kNameColumn);
        AddColumn(new TeamsColumn("ID", 80, 40, 100,
                B_TRUNCATE_MIDDLE, B_ALIGN_RIGHT), kIDColumn);
        SetSortingEnabled(false);
}


TeamsListView::~TeamsListView()
{
        if (fHost != NULL)
                fHost->ReleaseReference();
}


void
TeamsListView::AttachedToWindow()
{
        Inherited::AttachedToWindow();
        TeamsColumn::InitTextMargin(ScrollView());
}


void
TeamsListView::DetachedFromWindow()
{
        Inherited::DetachedFromWindow();
        _SetInterface(NULL);
}


void
TeamsListView::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_SELECTED_INTERFACE_CHANGED:
                {
                        TargetHostInterface* interface;
                        if (message->FindPointer("interface", reinterpret_cast<void**>(
                                        &interface)) == B_OK) {
                                _SetInterface(interface);
                        }
                        break;
                }

                case MSG_TEAM_ADDED:
                {
                        TeamInfo* info;
                        team_id team;
                        if (message->FindInt32("team", &team) != B_OK)
                                break;

                        TargetHost* host = fInterface->GetTargetHost();
                        AutoLocker<TargetHost> hostLocker(host);
                        info = host->TeamInfoByID(team);
                        if (info == NULL)
                                break;

                        TeamRow* row = new TeamRow(info);
                        AddRow(row);
                        break;
                }

                case MSG_TEAM_REMOVED:
                {
                        team_id team;
                        if (message->FindInt32("team", &team) != B_OK)
                                break;

                        TeamRow* row = FindTeamRow(team);
                        if (row != NULL) {
                                RemoveRow(row);
                                delete row;
                        }
                        break;
                }

                case MSG_TEAM_RENAMED:
                {
                        TeamInfo* info;
                        team_id team;
                        if (message->FindInt32("team", &team) != B_OK)
                                break;

                        TargetHost* host = fInterface->GetTargetHost();
                        AutoLocker<TargetHost> hostLocker(host);
                        info = host->TeamInfoByID(team);
                        if (info == NULL)
                                break;

                        TeamRow* row = FindTeamRow(info->TeamID());
                        if (row != NULL && row->NeedsUpdate(info))
                                UpdateRow(row);

                        break;
                }

                default:
                        Inherited::MessageReceived(message);
        }
}


TeamRow*
TeamsListView::FindTeamRow(team_id teamId)
{
        for (int32 i = CountRows(); i-- > 0;) {
                TeamRow* row = dynamic_cast<TeamRow*>(RowAt(i));
                if (row == NULL)
                        continue;

                if (row->TeamID() == teamId)
                        return row;
        }

        return NULL;
}


void
TeamsListView::TeamAdded(TeamInfo* info)
{
        BMessage message(MSG_TEAM_ADDED);
        message.AddInt32("team", info->TeamID());
        BMessenger(this).SendMessage(&message);
}


void
TeamsListView::TeamRemoved(team_id team)
{
        BMessage message(MSG_TEAM_REMOVED);
        message.AddInt32("team", team);
        BMessenger(this).SendMessage(&message);
}


void
TeamsListView::TeamRenamed(TeamInfo* info)
{
        BMessage message(MSG_TEAM_RENAMED);
        message.AddInt32("team", info->TeamID());
        BMessenger(this).SendMessage(&message);
}


void
TeamsListView::SelectedInterfaceChanged(TargetHostInterface* interface)
{
        BMessage message(MSG_SELECTED_INTERFACE_CHANGED);
        message.AddPointer("interface", interface);
        BMessenger(this).SendMessage(&message);
}


void
TeamsListView::_InitList()
{
        AutoLocker<TargetHost> hostLocker(fHost);
        for (int32 i = 0; TeamInfo* info = fHost->TeamInfoAt(i); i++) {
                BRow* row = new TeamRow(info);
                AddRow(row);
        }
}


void
TeamsListView::_SetInterface(TargetHostInterface* interface)
{
        if (interface == fInterface)
                return;

        if (fInterface != NULL) {
                Clear();
                fHost->RemoveListener(this);
                fHost->ReleaseReference();
                fHost = NULL;
        }

        fInterface = interface;
        if (fInterface == NULL)
                return;

        fHost = fInterface->GetTargetHost();
        fHost->AcquireReference();
        fHost->AddListener(this);
        _InitList();
}