/*
 * Copyright 2016-2019 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT license
 *
 * Authors:
 *              Alexander von Gluck IV <kallisti5@unixzen.com>
 *              Brian Hill <supernova@tycho.email>
 *              Jacob Secunda
 */


#include "SoftwareUpdaterWindow.h"

#include <Alert.h>
#include <AppDefs.h>
#include <Application.h>
#include <Catalog.h>
#include <ControlLook.h>
#include <FindDirectory.h>
#include <LayoutBuilder.h>
#include <LayoutUtils.h>
#include <Message.h>
#include <Roster.h>
#include <RosterPrivate.h>
#include <Screen.h>
#include <String.h>

#include "constants.h"

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "SoftwareUpdaterWindow"


SoftwareUpdaterWindow::SoftwareUpdaterWindow()
        :
        BWindow(BRect(0, 0, 300, 10),
                B_TRANSLATE_SYSTEM_NAME("SoftwareUpdater"), B_TITLED_WINDOW,
                B_AUTO_UPDATE_SIZE_LIMITS | B_NOT_ZOOMABLE | B_NOT_RESIZABLE),
        fStripeView(NULL),
        fHeaderView(NULL),
        fDetailView(NULL),
        fUpdateButton(NULL),
        fCancelButton(NULL),
        fStatusBar(NULL),
        fCurrentState(STATE_HEAD),
        fWaitingSem(-1),
        fWaitingForButton(false),
        fUpdateConfirmed(false),
        fUserCancelRequested(false),
        fWarningAlertCount(0),
        fSettingsReadStatus(B_ERROR),
        fSaveFrameChanges(false),
        fMessageRunner(NULL),
        fFrameChangeMessage(kMsgWindowFrameChanged)
{
        // Layout
        BBitmap icon = GetIcon(32 * icon_layout_scale());
        fStripeView = new BStripeView(icon);

        fUpdateButton = new BButton(B_TRANSLATE("Update now"),
                new BMessage(kMsgUpdateConfirmed));
        fUpdateButton->MakeDefault(true);
        fCancelButton = new BButton(B_TRANSLATE("Cancel"),
                new BMessage(kMsgCancel));
        fRebootButton = new BButton(B_TRANSLATE("Reboot"),
                new BMessage(kMsgReboot));

        fHeaderView = new BStringView("header",
                B_TRANSLATE("Checking for updates"), B_WILL_DRAW);
        fHeaderView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
        fHeaderView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_TOP));
        fDetailView = new BStringView("detail", B_TRANSLATE("Contacting software "
                "repositories to check for package updates."), B_WILL_DRAW);
        fDetailView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
        fDetailView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_TOP));
        fStatusBar = new BStatusBar("progress");
        fStatusBar->SetMaxValue(100);

        fListView = new PackageListView();
        fScrollView = new BScrollView("scrollview", fListView, B_WILL_DRAW,
                false, true);

        fDetailsCheckbox = new BCheckBox("detailscheckbox",
                B_TRANSLATE("Show more details"),
                new BMessage(kMsgMoreDetailsToggle));

        BFont font;
        fHeaderView->GetFont(&font);
        font.SetFace(B_BOLD_FACE);
        font.SetSize(font.Size() * 1.5);
        fHeaderView->SetFont(&font,
                B_FONT_FAMILY_AND_STYLE | B_FONT_SIZE | B_FONT_FLAGS);

        BLayoutBuilder::Group<>(this, B_HORIZONTAL, B_USE_ITEM_SPACING)
                .Add(fStripeView)
                .AddGroup(B_VERTICAL, 0)
                        .SetInsets(0, B_USE_WINDOW_SPACING,
                                B_USE_WINDOW_SPACING, B_USE_WINDOW_SPACING)
                        .AddGroup(new BGroupView(B_VERTICAL, B_USE_ITEM_SPACING))
                                .Add(fHeaderView)
                                .Add(fDetailView)
                                .Add(fStatusBar)
                                .Add(fScrollView)
                        .End()
                        .AddStrut(B_USE_SMALL_SPACING)
                        .AddGroup(new BGroupView(B_HORIZONTAL))
                                .Add(fDetailsCheckbox)
                                .AddGlue()
                                .Add(fCancelButton)
                                .Add(fUpdateButton)
                                .Add(fRebootButton)
                        .End()
                .End()
        .End();

        fDetailsLayoutItem = layout_item_for(fDetailView);
        fProgressLayoutItem = layout_item_for(fStatusBar);
        fPackagesLayoutItem = layout_item_for(fScrollView);
        fCancelButtonLayoutItem = layout_item_for(fCancelButton);
        fUpdateButtonLayoutItem = layout_item_for(fUpdateButton);
        fRebootButtonLayoutItem = layout_item_for(fRebootButton);
        fDetailsCheckboxLayoutItem = layout_item_for(fDetailsCheckbox);

        _SetState(STATE_DISPLAY_STATUS);
        CenterOnScreen();
        SetFlags(Flags() ^ B_AUTO_UPDATE_SIZE_LIMITS);

        // Prevent resizing for now
        fDefaultRect = Bounds();
        SetSizeLimits(fDefaultRect.Width(), fDefaultRect.Width(),
                fDefaultRect.Height(), fDefaultRect.Height());

        // Read settings file
        status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &fSettingsPath);
        if (status == B_OK) {
                fSettingsPath.Append(kSettingsFilename);
                fSettingsReadStatus = _ReadSettings(fInitialSettings);
        }
        // Move to saved setting position
        if (fSettingsReadStatus == B_OK) {
                BRect windowFrame;
                status = fInitialSettings.FindRect(kKeyWindowFrame, &windowFrame);
                if (status == B_OK) {
                        BScreen screen(this);
                        if (screen.Frame().Contains(windowFrame.LeftTop()))
                                MoveTo(windowFrame.LeftTop());
                }
        }
        Show();

        BMessage registerMessage(kMsgRegister);
        registerMessage.AddMessenger(kKeyMessenger, BMessenger(this));
        be_app->PostMessage(&registerMessage);

        fCancelAlertResponse.SetMessage(new BMessage(kMsgCancelResponse));
        fCancelAlertResponse.SetTarget(this);
        fWarningAlertDismissed.SetMessage(new BMessage(kMsgWarningDismissed));
        fWarningAlertDismissed.SetTarget(this);

        // Common elements used for the zoom height and width calculations
        fZoomHeightBaseline = 6
                + be_control_look->ComposeSpacing(B_USE_SMALL_SPACING)
                + 2 * be_control_look->ComposeSpacing(B_USE_WINDOW_SPACING);
        fZoomWidthBaseline = fStripeView->PreferredSize().Width()
                + be_control_look->ComposeSpacing(B_USE_ITEM_SPACING)
                + fScrollView->ScrollBar(B_VERTICAL)->PreferredSize().Width()
                + be_control_look->ComposeSpacing(B_USE_WINDOW_SPACING);
}


bool
SoftwareUpdaterWindow::QuitRequested()
{
        PostMessage(kMsgCancel);
        return false;
}


void
SoftwareUpdaterWindow::FrameMoved(BPoint newPosition)
{
        BWindow::FrameMoved(newPosition);

        // Create a message runner to consolidate all function calls from a
        // move into one message post after moving has ceased for .5 seconds
        if (fSaveFrameChanges) {
                if (fMessageRunner == NULL) {
                        fMessageRunner = new BMessageRunner(this, &fFrameChangeMessage,
                                500000, 1);
                } else
                        fMessageRunner->SetInterval(500000);
        }
}


void
SoftwareUpdaterWindow::FrameResized(float newWidth, float newHeight)
{
        BWindow::FrameResized(newWidth, newHeight);

        // Create a message runner to consolidate all function calls from a
        // resize into one message post after resizing has ceased for .5 seconds
        if (fSaveFrameChanges) {
                if (fMessageRunner == NULL) {
                        fMessageRunner = new BMessageRunner(this, &fFrameChangeMessage,
                                500000, 1);
                } else
                        fMessageRunner->SetInterval(500000);
        }
}


void
SoftwareUpdaterWindow::Zoom(BPoint origin, float width, float height)
{
        // Override default zoom behavior and keep window at same position instead
        // of centering on screen
        BWindow::Zoom(Frame().LeftTop(), width, height);
}


void
SoftwareUpdaterWindow::MessageReceived(BMessage* message)
{
        switch (message->what) {

                case kMsgTextUpdate:
                {
                        if (fCurrentState == STATE_DISPLAY_PROGRESS)
                                _SetState(STATE_DISPLAY_STATUS);
                        else if (fCurrentState != STATE_DISPLAY_STATUS)
                                break;

                        BString header;
                        BString detail;
                        Lock();
                        status_t result = message->FindString(kKeyHeader, &header);
                        if (result == B_OK && header != fHeaderView->Text())
                                fHeaderView->SetText(header.String());
                        result = message->FindString(kKeyDetail, &detail);
                        if (result == B_OK)
                                fDetailView->SetText(detail.String());
                        Unlock();
                        break;
                }

                case kMsgProgressUpdate:
                {
                        if (fCurrentState == STATE_DISPLAY_STATUS)
                                _SetState(STATE_DISPLAY_PROGRESS);
                        else if (fCurrentState != STATE_DISPLAY_PROGRESS)
                                break;

                        BString packageName;
                        status_t result = message->FindString(kKeyPackageName,
                                &packageName);
                        if (result != B_OK)
                                break;
                        BString packageCount;
                        result = message->FindString(kKeyPackageCount, &packageCount);
                        if (result != B_OK)
                                break;
                        float percent;
                        result = message->FindFloat(kKeyPercentage, &percent);
                        if (result != B_OK)
                                break;

                        BString header;
                        Lock();
                        result = message->FindString(kKeyHeader, &header);
                        if (result == B_OK && header != fHeaderView->Text())
                                fHeaderView->SetText(header.String());
                        fStatusBar->SetTo(percent, packageName.String(),
                                packageCount.String());
                        Unlock();

                        fListView->UpdatePackageProgress(packageName.String(), percent);
                        break;
                }

                case kMsgCancel:
                {
                        if (_GetState() == STATE_FINAL_MESSAGE) {
                                be_app->PostMessage(kMsgFinalQuit);
                                break;
                        }
                        if (!fUpdateConfirmed) {
                                // Downloads have not started yet, we will request to cancel
                                // without confirming
                                Lock();
                                fHeaderView->SetText(B_TRANSLATE("Cancelling updates"));
                                fDetailView->SetText(
                                        B_TRANSLATE("Attempting to cancel the updates"
                                                B_UTF8_ELLIPSIS));
                                Unlock();
                                fUserCancelRequested = true;

                                if (fWaitingForButton) {
                                        fButtonResult = message->what;
                                        delete_sem(fWaitingSem);
                                        fWaitingSem = -1;
                                }
                                break;
                        }

                        // Confirm with the user to cancel
                        BAlert* alert = new BAlert("cancel request", B_TRANSLATE("Updates"
                                " have not been completed, are you sure you want to quit?"),
                                B_TRANSLATE("Quit"), B_TRANSLATE("Don't quit"), NULL,
                                B_WIDTH_AS_USUAL, B_WARNING_ALERT);
                        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                        alert->Go(&fCancelAlertResponse);
                        break;
                }

                case kMsgShowReboot:
                {
                        fRebootButtonLayoutItem->SetVisible(true);
                        fRebootButton->SetLabel(B_TRANSLATE_COMMENT("Reboot",
                                "Button label"));
                        fRebootButton->MakeDefault(true);
                        break;
                }

                case kMsgReboot:
                {
                        if (_GetState() != STATE_FINAL_MESSAGE)
                                break;

                        BRoster roster;
                        BRoster::Private rosterPrivate(roster);
                        status_t error = rosterPrivate.ShutDown(true, false, false);
                        if (error != B_OK) {
                                BAlert* alert = new BAlert("reboot request", B_TRANSLATE(
                                        "For some reason, we could not reboot your computer."),
                                        B_TRANSLATE("OK"), NULL, NULL,
                                        B_WIDTH_AS_USUAL, B_STOP_ALERT);
                                alert->Go();
                        }
                        break;
                }

                case kMsgCancelResponse:
                {
                        // Verify whether the cancel alert was confirmed
                        int32 selection = -1;
                        message->FindInt32("which", &selection);
                        if (selection != 0)
                                break;

                        Lock();
                        fHeaderView->SetText(B_TRANSLATE("Cancelling updates"));
                        fDetailView->SetText(
                                B_TRANSLATE("Attempting to cancel the updates"
                                        B_UTF8_ELLIPSIS));
                        Unlock();
                        fUserCancelRequested = true;

                        if (fWaitingForButton) {
                                fButtonResult = message->what;
                                delete_sem(fWaitingSem);
                                fWaitingSem = -1;
                        }
                        break;
                }

                case kMsgUpdateConfirmed:
                {
                        if (fWaitingForButton) {
                                fButtonResult = message->what;
                                delete_sem(fWaitingSem);
                                fWaitingSem = -1;
                                fUpdateConfirmed = true;
                        }
                        break;
                }

                case kMsgMoreDetailsToggle:
                        fListView->SetMoreDetails(fDetailsCheckbox->Value() != 0);
                        PostMessage(kMsgSetZoomLimits);
                        _WriteSettings();
                        break;

                case kMsgSetZoomLimits:
                {
                        int32 count = fListView->CountItems();
                        if (count < 1)
                                break;
                        // Convert last item's bottom point to its layout group coordinates
                        BPoint zoomPoint = fListView->ZoomPoint();
                        fScrollView->ConvertToParent(&zoomPoint);
                        // Determine which BControl object height to use
                        float controlHeight;
                        if (fUpdateButtonLayoutItem->IsVisible())
                                fUpdateButton->GetPreferredSize(NULL, &controlHeight);
                        else
                                fDetailsCheckbox->GetPreferredSize(NULL, &controlHeight);
                        // Calculate height and width values
                        float zoomHeight = fZoomHeightBaseline + zoomPoint.y
                                + controlHeight;
                        float zoomWidth = fZoomWidthBaseline + zoomPoint.x;
                        SetZoomLimits(zoomWidth, zoomHeight);
                        break;
                }

                case kMsgWarningDismissed:
                        fWarningAlertCount--;
                        break;

                case kMsgWindowFrameChanged:
                        delete fMessageRunner;
                        fMessageRunner = NULL;
                        _WriteSettings();
                        break;

                case kMsgGetUpdateType:
                {
                        BString text(
                                B_TRANSLATE("Please choose from these update options:\n\n"
                                "Update:\n"
                                "       Updates all installed packages.\n"
                                "Full sync:\n"
                                "       Synchronizes the installed packages with the repositories."
                                ));
                        BAlert* alert = new BAlert("update_type",
                                text,
                                B_TRANSLATE_COMMENT("Cancel", "Alert button label"),
                                B_TRANSLATE_COMMENT("Full sync","Alert button label"),
                                B_TRANSLATE_COMMENT("Update","Alert button label"),
                                B_WIDTH_AS_USUAL, B_INFO_ALERT);
                        int32 result = alert->Go();
                        int32 action = INVALID_SELECTION;
                        switch(result) {
                                case 0:
                                        action = CANCEL_UPDATE;
                                        break;

                                case 1:
                                        action = FULLSYNC;
                                        break;

                                case 2:
                                        action = UPDATE;
                                        break;
                        }
                        BMessage reply;
                        reply.AddInt32(kKeyAlertResult, action);
                        message->SendReply(&reply);
                        break;
                }

                case kMsgNoRepositories:
                {
                        BString text(
                                B_TRANSLATE_COMMENT(
                                "No remote repositories are available. Please verify that some"
                                " repositories are enabled using the Repositories preflet or"
                                " the \'pkgman\' command.", "Error message"));
                        BAlert* alert = new BAlert("repositories", text,
                                B_TRANSLATE_COMMENT("Quit", "Alert button label"),
                                B_TRANSLATE_COMMENT("Open Repositories","Alert button label"),
                                NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
                        int32 result = alert->Go();
                        BMessage reply;
                        reply.AddInt32(kKeyAlertResult, result);
                        message->SendReply(&reply);
                        break;
                }

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


bool
SoftwareUpdaterWindow::ConfirmUpdates()
{
        Lock();
        fHeaderView->SetText(B_TRANSLATE("Updates found"));
        fDetailView->SetText(B_TRANSLATE("The following changes will be made:"));
        fListView->SortItems();
        Unlock();

        uint32 priorState = _GetState();
        _SetState(STATE_GET_CONFIRMATION);

        _WaitForButtonClick();
        _SetState(priorState);
        return fButtonResult == kMsgUpdateConfirmed;
}


void
SoftwareUpdaterWindow::UpdatesApplying(const char* header, const char* detail)
{
        Lock();
        fHeaderView->SetText(header);
        fDetailView->SetText(detail);
        Unlock();
        _SetState(STATE_APPLY_UPDATES);
}


bool
SoftwareUpdaterWindow::UserCancelRequested()
{
        if (_GetState() > STATE_GET_CONFIRMATION)
                return false;

        return fUserCancelRequested;
}


void
SoftwareUpdaterWindow::AddPackageInfo(uint32 install_type,
        const char* package_name, const char* cur_ver, const char* new_ver,
        const char* summary, const char* repository, const char* file_name)
{
        Lock();
        fListView->AddPackage(install_type, package_name, cur_ver, new_ver,
                summary, repository, file_name);
        Unlock();
}


void
SoftwareUpdaterWindow::ShowWarningAlert(const char* text)
{
        BAlert* alert = new BAlert("warning", text, B_TRANSLATE("OK"), NULL, NULL,
                B_WIDTH_AS_USUAL, B_WARNING_ALERT);
        alert->Go(&fWarningAlertDismissed);
        alert->CenterIn(Frame());
        // Offset multiple alerts
        alert->MoveBy(fWarningAlertCount * 15, fWarningAlertCount * 15);
        fWarningAlertCount++;
}


BBitmap
SoftwareUpdaterWindow::GetIcon(int32 iconSize)
{
        BBitmap icon(BRect(0, 0, iconSize - 1, iconSize - 1), 0, B_RGBA32);
        team_info teamInfo;
        get_team_info(B_CURRENT_TEAM, &teamInfo);
        app_info appInfo;
        be_roster->GetRunningAppInfo(teamInfo.team, &appInfo);
        BNodeInfo::GetTrackerIcon(&appInfo.ref, &icon, icon_size(iconSize));
        return icon;
}


void
SoftwareUpdaterWindow::FinalUpdate(const char* header, const char* detail)
{
        if (_GetState() == STATE_FINAL_MESSAGE)
                return;

        _SetState(STATE_FINAL_MESSAGE);
        Lock();
        fHeaderView->SetText(header);
        fDetailView->SetText(detail);
        Unlock();
}


BLayoutItem*
SoftwareUpdaterWindow::layout_item_for(BView* view)
{
        BLayout* layout = view->Parent()->GetLayout();
        int32 index = layout->IndexOfView(view);
        return layout->ItemAt(index);
}


uint32
SoftwareUpdaterWindow::_WaitForButtonClick()
{
        fButtonResult = 0;
        fWaitingForButton = true;
        fWaitingSem = create_sem(0, "WaitingSem");
        while (acquire_sem(fWaitingSem) == B_INTERRUPTED) {
        }
        fWaitingForButton = false;
        return fButtonResult;
}


void
SoftwareUpdaterWindow::_SetState(uint32 state)
{
        if (state <= STATE_HEAD || state >= STATE_MAX)
                return;

        Lock();

        // Initial settings
        if (fCurrentState == STATE_HEAD) {
                fProgressLayoutItem->SetVisible(false);
                fPackagesLayoutItem->SetVisible(false);
                fDetailsCheckboxLayoutItem->SetVisible(false);
                fCancelButtonLayoutItem->SetVisible(false);
                fRebootButtonLayoutItem->SetVisible(false);
        }
        fCurrentState = state;

        // Update confirmation button
        // Show only when asking for confirmation to update
        if (fCurrentState == STATE_GET_CONFIRMATION)
                fUpdateButtonLayoutItem->SetVisible(true);
        else
                fUpdateButtonLayoutItem->SetVisible(false);

        // View package info view and checkbox
        // Show at confirmation prompt, hide at final update
        if (fCurrentState == STATE_GET_CONFIRMATION) {
                fPackagesLayoutItem->SetVisible(true);
                fDetailsCheckboxLayoutItem->SetVisible(true);
                if (fSettingsReadStatus == B_OK) {
                        bool showMoreDetails;
                        status_t result = fInitialSettings.FindBool(kKeyShowDetails,
                                &showMoreDetails);
                        if (result == B_OK) {
                                fDetailsCheckbox->SetValue(showMoreDetails ? 1 : 0);
                                fListView->SetMoreDetails(showMoreDetails);
                        }
                }
        } else if (fCurrentState == STATE_FINAL_MESSAGE) {
                fPackagesLayoutItem->SetVisible(false);
                fDetailsCheckboxLayoutItem->SetVisible(false);
        }

        // Progress bar and string view
        // Hide detail text while showing status bar
        if (fCurrentState == STATE_DISPLAY_PROGRESS) {
                fDetailsLayoutItem->SetVisible(false);
                fProgressLayoutItem->SetVisible(true);
        } else {
                fProgressLayoutItem->SetVisible(false);
                fDetailsLayoutItem->SetVisible(true);
        }

        // Resizing and zooming
        if (fCurrentState == STATE_GET_CONFIRMATION) {
                // Enable resizing and zooming
                float defaultWidth = fDefaultRect.Width();
                SetSizeLimits(defaultWidth, B_SIZE_UNLIMITED,
                        fDefaultRect.Height() + 4 * fListView->ItemHeight(),
                        B_SIZE_UNLIMITED);
                SetFlags(Flags() ^ (B_NOT_RESIZABLE | B_NOT_ZOOMABLE));
                PostMessage(kMsgSetZoomLimits);
                // Recall saved settings
                BScreen screen(this);
                BRect screenFrame = screen.Frame();
                bool windowResized = false;
                if (fSettingsReadStatus == B_OK) {
                        BRect windowFrame;
                        status_t result = fInitialSettings.FindRect(kKeyWindowFrame,
                                &windowFrame);
                        if (result == B_OK) {
                                if (screenFrame.Contains(windowFrame)) {
                                        ResizeTo(windowFrame.Width(), windowFrame.Height());
                                        windowResized = true;
                                }
                        }
                }
                if (!windowResized)
                        ResizeTo(defaultWidth, .75 * defaultWidth);
                // Check that the bottom of window is on screen
                float screenBottom = screenFrame.bottom;
                float windowBottom = DecoratorFrame().bottom;
                if (windowBottom > screenBottom)
                        MoveBy(0, screenBottom - windowBottom);
                fSaveFrameChanges = true;
        } else if (fUpdateConfirmed && (fCurrentState == STATE_DISPLAY_PROGRESS
                        || fCurrentState == STATE_DISPLAY_STATUS)) {
                PostMessage(kMsgSetZoomLimits);
        } else if (fCurrentState == STATE_APPLY_UPDATES)
                fSaveFrameChanges = false;
        else if (fCurrentState == STATE_FINAL_MESSAGE) {
                // Disable resizing and zooming
                fSaveFrameChanges = false;
                ResizeTo(fDefaultRect.Width(), fDefaultRect.Height());
                SetFlags(Flags() | B_AUTO_UPDATE_SIZE_LIMITS | B_NOT_RESIZABLE
                        | B_NOT_ZOOMABLE);
        }

        // Quit button
        if (fCurrentState == STATE_FINAL_MESSAGE) {
                fCancelButtonLayoutItem->SetVisible(true);
                fCancelButton->SetLabel(B_TRANSLATE_COMMENT("Quit", "Button label"));
                fCancelButton->MakeDefault(true);
        }

        Unlock();
}


uint32
SoftwareUpdaterWindow::_GetState()
{
        return fCurrentState;
}


status_t
SoftwareUpdaterWindow::_WriteSettings()
{
        BFile file;
        status_t status = file.SetTo(fSettingsPath.Path(),
                B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
        if (status == B_OK) {
                BMessage settings;
                settings.AddBool(kKeyShowDetails, fDetailsCheckbox->Value() != 0);
                settings.AddRect(kKeyWindowFrame, Frame());
                status = settings.Flatten(&file);
        }
        file.Unset();
        return status;
}


status_t
SoftwareUpdaterWindow::_ReadSettings(BMessage& settings)
{
        BFile file;
        status_t status = file.SetTo(fSettingsPath.Path(), B_READ_ONLY);
        if (status == B_OK)
                status = settings.Unflatten(&file);
        file.Unset();
        return status;
}


SuperItem::SuperItem(const char* label)
        :
        BListItem(),
        fLabel(label),
        fRegularFont(be_plain_font),
        fBoldFont(be_plain_font),
        fShowMoreDetails(false),
        fPackageLessIcon(NULL),
        fPackageMoreIcon(NULL),
        fItemCount(0)
{
        fBoldFont.SetFace(B_BOLD_FACE);
        fBoldFont.GetHeight(&fBoldFontHeight);
        font_height fontHeight;
        fRegularFont.GetHeight(&fontHeight);
        fPackageItemLineHeight = fontHeight.ascent + fontHeight.descent
                + fontHeight.leading;
        fPackageLessIcon = _GetPackageIcon(GetPackageItemHeight(false));
        fPackageMoreIcon = _GetPackageIcon(GetPackageItemHeight(true));
}


SuperItem::~SuperItem()
{
        delete fPackageLessIcon;
        delete fPackageMoreIcon;
}


void
SuperItem::DrawItem(BView* owner, BRect item_rect, bool complete)
{
        owner->PushState();

        float width;
        owner->GetPreferredSize(&width, NULL);
        BString text(fItemText);
        owner->SetHighColor(ui_color(B_LIST_ITEM_TEXT_COLOR));
        owner->SetFont(&fBoldFont);
        owner->TruncateString(&text, B_TRUNCATE_END, width);
        owner->DrawString(text.String(), BPoint(item_rect.left,
                item_rect.bottom - fBoldFontHeight.descent));

        owner->PopState();
}


float
SuperItem::GetPackageItemHeight()
{
        return GetPackageItemHeight(fShowMoreDetails);
}


float
SuperItem::GetPackageItemHeight(bool showMoreDetails)
{
        int lineCount = showMoreDetails ? 3 : 2;
        return lineCount * fPackageItemLineHeight;
}


BBitmap*
SuperItem::GetIcon(bool showMoreDetails)
{
        if (showMoreDetails)
                return fPackageMoreIcon;
        else
                return fPackageLessIcon;
}


float
SuperItem::GetIconSize(bool showMoreDetails)
{
        if (showMoreDetails)
                return fPackageMoreIcon->Bounds().Height();
        else
                return fPackageLessIcon->Bounds().Height();
}


void
SuperItem::SetDetailLevel(bool showMoreDetails)
{
        fShowMoreDetails = showMoreDetails;
}


void
SuperItem::SetItemCount(int32 count)
{
        fItemCount = count;
        fItemText = fLabel;
        fItemText.Append(" (");
        fItemText << fItemCount;
        fItemText.Append(")");
}


float
SuperItem::ZoomWidth(BView *owner)
{
        owner->PushState();
        owner->SetFont(&fBoldFont);
        float width = owner->StringWidth(fItemText.String());
        owner->PopState();
        return width;
}


BBitmap*
SuperItem::_GetPackageIcon(float listItemHeight)
{
        int32 iconSize = int(listItemHeight * .8);
        status_t result = B_ERROR;
        BRect iconRect(0, 0, iconSize - 1, iconSize - 1);
        BBitmap* packageIcon = new BBitmap(iconRect, 0, B_RGBA32);
        BMimeType nodeType;
        nodeType.SetTo("application/x-vnd.haiku-package");
        result = nodeType.GetIcon(packageIcon, icon_size(iconSize));
        // Get super type icon
        if (result != B_OK) {
                BMimeType superType;
                if (nodeType.GetSupertype(&superType) == B_OK)
                        result = superType.GetIcon(packageIcon, icon_size(iconSize));
        }
        if (result != B_OK) {
                delete packageIcon;
                return NULL;
        }
        return packageIcon;
}


PackageItem::PackageItem(const char* name, const char* simple_version,
        const char* detailed_version, const char* repository, const char* summary,
        const char* file_name, SuperItem* super)
        :
        BListItem(),
        fName(name),
        fSimpleVersion(simple_version),
        fDetailedVersion(detailed_version),
        fRepository(repository),
        fSummary(summary),
        fSmallFont(be_plain_font),
        fSuperItem(super),
        fFileName(file_name),
        fDownloadProgress(0),
        fDrawBarFlag(false),
        fMoreDetailsWidth(0),
        fLessDetailsWidth(0)
{
        fLabelOffset = be_control_look->DefaultLabelSpacing();
        fSmallFont.SetSize(be_plain_font->Size() - 2);
        fSmallFont.GetHeight(&fSmallFontHeight);
        fSmallTotalHeight = fSmallFontHeight.ascent + fSmallFontHeight.descent
                + fSmallFontHeight.leading;
}


void
PackageItem::DrawItem(BView* owner, BRect item_rect, bool complete)
{
        owner->PushState();

        float width = owner->Frame().Width();
        float nameWidth = width / 2.0;
        float offsetWidth = 0;
        bool showMoreDetails = fSuperItem->GetDetailLevel();

        BBitmap* icon = fSuperItem->GetIcon(showMoreDetails);
        if (icon != NULL && icon->IsValid()) {
                float iconSize = icon->Bounds().Height();
                float offsetMarginHeight = floor((Height() - iconSize) / 2);
                owner->SetDrawingMode(B_OP_ALPHA);
                BPoint location = BPoint(item_rect.left,
                        item_rect.top + offsetMarginHeight);
                owner->DrawBitmap(icon, location);
                owner->SetDrawingMode(B_OP_COPY);
                offsetWidth = iconSize + fLabelOffset;

                if (fDrawBarFlag)
                        _DrawBar(location, owner, icon_size(iconSize));
        }

        owner->SetFont(be_plain_font);
        owner->SetHighColor(ui_color(B_LIST_ITEM_TEXT_COLOR));

        // Package name
        BString name(fName);
        owner->TruncateString(&name, B_TRUNCATE_END, nameWidth);
        BPoint cursor(item_rect.left + offsetWidth,
                item_rect.bottom - fSmallTotalHeight - fSmallFontHeight.descent - 2);
        if (showMoreDetails)
                cursor.y -= fSmallTotalHeight + 1;
        owner->DrawString(name.String(), cursor);
        cursor.x += owner->StringWidth(name.String()) + fLabelOffset;

        // Change font and color
        owner->SetFont(&fSmallFont);
        owner->SetHighColor(tint_color(ui_color(B_LIST_ITEM_TEXT_COLOR), 0.7));

        // Simple version or repository
        BString versionOrRepo;
        if (showMoreDetails)
                versionOrRepo.SetTo(fRepository);
        else
                versionOrRepo.SetTo(fSimpleVersion);
        owner->TruncateString(&versionOrRepo, B_TRUNCATE_END, width - cursor.x);
        owner->DrawString(versionOrRepo.String(), cursor);

        // Summary
        BString summary(fSummary);
        cursor.x = item_rect.left + offsetWidth;
        cursor.y += fSmallTotalHeight;
        owner->TruncateString(&summary, B_TRUNCATE_END, width - cursor.x);
        owner->DrawString(summary.String(), cursor);

        // Detailed version
        if (showMoreDetails) {
                BString version(fDetailedVersion);
                cursor.y += fSmallTotalHeight;
                owner->TruncateString(&version, B_TRUNCATE_END, width - cursor.x);
                owner->DrawString(version.String(), cursor);
        }

        owner->PopState();
}


// Modified slightly from Tracker's BPose::DrawBar
void
PackageItem::_DrawBar(BPoint where, BView* view, icon_size which)
{
        int32 yOffset;
        int32 size = which - 1;
        int32 barWidth = (int32)(7.0f / 32.0f * (float)which);
        if (barWidth < 4) {
                barWidth = 4;
                yOffset = 0;
        } else
                yOffset = 2;
        int32 barHeight = size - 3 - 2 * yOffset;


        // the black shadowed line
        view->SetHighColor(32, 32, 32, 92);
        view->MovePenTo(BPoint(where.x + size, where.y + 1 + yOffset));
        view->StrokeLine(BPoint(where.x + size, where.y + size - yOffset));
        view->StrokeLine(BPoint(where.x + size - barWidth + 1,
                where.y + size - yOffset));

        view->SetDrawingMode(B_OP_ALPHA);

        // the gray frame
        view->SetHighColor(76, 76, 76, 192);
        BRect rect(where.x + size - barWidth,where.y + yOffset,
                where.x + size - 1,where.y + size - 1 - yOffset);
        view->StrokeRect(rect);

        // calculate bar height
        int32 barPos = barHeight - int32(barHeight * fDownloadProgress / 100.0);
        if (barPos < 0)
                barPos = 0;
        else if (barPos > barHeight)
                barPos = barHeight;

        // the free space bar
        view->SetHighColor(255, 255, 255, 192);

        rect.InsetBy(1,1);
        BRect bar(rect);
        bar.bottom = bar.top + barPos - 1;
        if (barPos > 0)
                view->FillRect(bar);

        // the used space bar
        bar.top = bar.bottom + 1;
        bar.bottom = rect.bottom;
        view->SetHighColor(0, 203, 0, 192);
        view->FillRect(bar);
}


void
PackageItem::Update(BView *owner, const BFont *font)
{
        BListItem::Update(owner, font);
        SetHeight(fSuperItem->GetPackageItemHeight());
}


void
PackageItem::CalculateZoomWidths(BView *owner)
{
        owner->PushState();

        // More details
        float offsetWidth = 2 * be_control_look->DefaultItemSpacing()
                + be_plain_font->Size()
                + fSuperItem->GetIconSize(true) + fLabelOffset;
        // Name and repo
        owner->SetFont(be_plain_font);
        float stringWidth = owner->StringWidth(fName.String());
        owner->SetFont(&fSmallFont);
        stringWidth += fLabelOffset + owner->StringWidth(fRepository.String());
        // Summary
        float summaryWidth = owner->StringWidth(fSummary.String());
        if (summaryWidth > stringWidth)
                stringWidth = summaryWidth;
        // Version
        float versionWidth = owner->StringWidth(fDetailedVersion.String());
        if (versionWidth > stringWidth)
                stringWidth = versionWidth;
        fMoreDetailsWidth = offsetWidth + stringWidth;

        // Less details
        offsetWidth = 2 * be_control_look->DefaultItemSpacing()
                + be_plain_font->Size()
                + fSuperItem->GetIconSize(false) + fLabelOffset;
        // Name and version
        owner->SetFont(be_plain_font);
        stringWidth = owner->StringWidth(fName.String());
        owner->SetFont(&fSmallFont);
        stringWidth += fLabelOffset + owner->StringWidth(fSimpleVersion.String());
        // Summary
        if (summaryWidth > stringWidth)
                stringWidth = summaryWidth;
        fLessDetailsWidth = offsetWidth + stringWidth;

        owner->PopState();
}


int
PackageItem::NameCompare(PackageItem* item)
{
        // sort by package name
        return fName.ICompare(item->fName);
}


void
PackageItem::SetDownloadProgress(float percent)
{
        fDownloadProgress = percent;
}


int
SortPackageItems(const BListItem* item1, const BListItem* item2)
{
        PackageItem* first = (PackageItem*)item1;
        PackageItem* second = (PackageItem*)item2;
        return first->NameCompare(second);
}


PackageListView::PackageListView()
        :
        BOutlineListView("Package list"),
        fSuperUpdateItem(NULL),
        fSuperInstallItem(NULL),
        fSuperUninstallItem(NULL),
        fShowMoreDetails(false),
        fLastProgressItem(NULL),
        fLastProgressValue(-1)
{
        SetExplicitMinSize(BSize(B_SIZE_UNSET, 40));
        SetExplicitPreferredSize(BSize(B_SIZE_UNSET, 400));
}


void
PackageListView::FrameResized(float newWidth, float newHeight)
{
        BOutlineListView::FrameResized(newWidth, newHeight);
        Invalidate();
}


void
PackageListView::ExpandOrCollapse(BListItem *superItem, bool expand)
{
        BOutlineListView::ExpandOrCollapse(superItem, expand);
        Window()->PostMessage(kMsgSetZoomLimits);
}


void
PackageListView::AddPackage(uint32 install_type, const char* name,
        const char* cur_ver, const char* new_ver, const char* summary,
        const char* repository, const char* file_name)
{
        SuperItem* super;
        BString simpleVersion;
        BString detailedVersion("");
        BString repositoryText(B_TRANSLATE_COMMENT("from repository",
                "List item text"));
        repositoryText.Append(" ").Append(repository);

        switch (install_type) {
                case PACKAGE_UPDATE:
                {
                        if (fSuperUpdateItem == NULL) {
                                fSuperUpdateItem = new SuperItem(B_TRANSLATE_COMMENT(
                                        "Packages to be updated", "List super item label"));
                                AddItem(fSuperUpdateItem);
                        }
                        super = fSuperUpdateItem;

                        simpleVersion.SetTo(new_ver);
                        detailedVersion.Append(B_TRANSLATE_COMMENT("Updating version",
                                        "List item text"))
                                .Append(" ").Append(cur_ver)
                                .Append(" ").Append(B_TRANSLATE_COMMENT("to",
                                        "List item text"))
                                .Append(" ").Append(new_ver);
                        break;
                }

                case PACKAGE_INSTALL:
                {
                        if (fSuperInstallItem == NULL) {
                                fSuperInstallItem = new SuperItem(B_TRANSLATE_COMMENT(
                                        "New packages to be installed", "List super item label"));
                                AddItem(fSuperInstallItem);
                        }
                        super = fSuperInstallItem;

                        simpleVersion.SetTo(new_ver);
                        detailedVersion.Append(B_TRANSLATE_COMMENT("Installing version",
                                        "List item text"))
                                .Append(" ").Append(new_ver);
                        break;
                }

                case PACKAGE_UNINSTALL:
                {
                        if (fSuperUninstallItem == NULL) {
                                fSuperUninstallItem = new SuperItem(B_TRANSLATE_COMMENT(
                                        "Packages to be uninstalled", "List super item label"));
                                AddItem(fSuperUninstallItem);
                        }
                        super = fSuperUninstallItem;

                        simpleVersion.SetTo("");
                        detailedVersion.Append(B_TRANSLATE_COMMENT("Uninstalling version",
                                        "List item text"))
                                .Append(" ").Append(cur_ver);
                        break;
                }

                default:
                        return;

        }
        PackageItem* item = new PackageItem(name, simpleVersion.String(),
                detailedVersion.String(), repositoryText.String(), summary, file_name,
                super);
        AddUnder(item, super);
        super->SetItemCount(CountItemsUnder(super, true));
        item->CalculateZoomWidths(this);
}


void
PackageListView::UpdatePackageProgress(const char* packageName, float percent)
{
        // Update only every 1 percent change
        int16 wholePercent = int16(percent);
        if (wholePercent == fLastProgressValue)
                return;
        fLastProgressValue = wholePercent;

        // A new package started downloading, find the PackageItem by name
        if (percent == 0) {
                fLastProgressItem = NULL;
                int32 count = FullListCountItems();
                for (int32 i = 0; i < count; i++) {
                        PackageItem* item = dynamic_cast<PackageItem*>(FullListItemAt(i));
                        if (item != NULL && strcmp(item->FileName(), packageName) == 0) {
                                fLastProgressItem = item;
                                fLastProgressItem->ShowProgressBar();
                                break;
                        }
                }
        }

        if (fLastProgressItem != NULL) {
                fLastProgressItem->SetDownloadProgress(percent);
                Invalidate();
        }
}


void
PackageListView::SortItems()
{
        if (fSuperUpdateItem != NULL)
                SortItemsUnder(fSuperUpdateItem, true, SortPackageItems);
        if (fSuperInstallItem != NULL)
                SortItemsUnder(fSuperInstallItem, true, SortPackageItems);
        if (fSuperUninstallItem != NULL)
                SortItemsUnder(fSuperUninstallItem, true, SortPackageItems);
}


float
PackageListView::ItemHeight()
{
        if (fSuperUpdateItem != NULL)
                return fSuperUpdateItem->GetPackageItemHeight();
        if (fSuperInstallItem != NULL)
                return fSuperInstallItem->GetPackageItemHeight();
        if (fSuperUninstallItem != NULL)
                return fSuperUninstallItem->GetPackageItemHeight();
        return 0;
}


void
PackageListView::SetMoreDetails(bool showMore)
{
        if (showMore == fShowMoreDetails)
                return;
        fShowMoreDetails = showMore;
        _SetItemHeights();
        InvalidateLayout();
        ResizeToPreferred();
}


BPoint
PackageListView::ZoomPoint()
{
        BPoint zoomPoint(0, 0);
        int32 count = CountItems();
        for (int32 i = 0; i < count; i++)
        {
                BListItem* item = ItemAt(i);
                float itemWidth = 0;
                if (item->OutlineLevel() == 0) {
                        SuperItem* sItem = dynamic_cast<SuperItem*>(item);
                        itemWidth = sItem->ZoomWidth(this);
                } else {
                        PackageItem* pItem = dynamic_cast<PackageItem*>(item);
                        itemWidth = fShowMoreDetails ? pItem->MoreDetailsWidth()
                                : pItem->LessDetailsWidth();
                }
                if (itemWidth > zoomPoint.x)
                        zoomPoint.x = itemWidth;
        }
        if (count > 0)
                zoomPoint.y = ItemFrame(count - 1).bottom;

        return zoomPoint;
}


void
PackageListView::_SetItemHeights()
{
        int32 itemCount = 0;
        float itemHeight = 0;
        BListItem* item = NULL;
        if (fSuperUpdateItem != NULL) {
                fSuperUpdateItem->SetDetailLevel(fShowMoreDetails);
                itemHeight = fSuperUpdateItem->GetPackageItemHeight();
                itemCount = CountItemsUnder(fSuperUpdateItem, true);
                for (int32 i = 0; i < itemCount; i++) {
                        item = ItemUnderAt(fSuperUpdateItem, true, i);
                        item->SetHeight(itemHeight);
                }
        }
        if (fSuperInstallItem != NULL) {
                fSuperInstallItem->SetDetailLevel(fShowMoreDetails);
                itemHeight = fSuperInstallItem->GetPackageItemHeight();
                itemCount = CountItemsUnder(fSuperInstallItem, true);
                for (int32 i = 0; i < itemCount; i++) {
                        item = ItemUnderAt(fSuperInstallItem, true, i);
                        item->SetHeight(itemHeight);
                }

        }
        if (fSuperUninstallItem != NULL) {
                fSuperUninstallItem->SetDetailLevel(fShowMoreDetails);
                itemHeight = fSuperUninstallItem->GetPackageItemHeight();
                itemCount = CountItemsUnder(fSuperUninstallItem, true);
                for (int32 i = 0; i < itemCount; i++) {
                        item = ItemUnderAt(fSuperUninstallItem, true, i);
                        item->SetHeight(itemHeight);
                }

        }
}