/*
 * Copyright 2008 Ralf Schülke, ralf.schuelke@googlemail.com.
 * Copyright 2010 Adam Smith <adamd.smith@utoronto.ca>
 * Copyright 2014 Haiku, Inc. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ralf Schülke, ralf.schuelke@googlemail.com
 *              John Scipione, jscipione@gmail.com
 *              Adam Smith, adamd.smith@utoronto.ca
 */


#include "PairsWindow.h"

#include <Application.h>
#include <Alert.h>
#include <Button.h>
#include <Catalog.h>
#include <ObjectList.h>
#include <Menu.h>
#include <MenuBar.h>
#include <MenuItem.h>
#include <MessageRunner.h>
#include <String.h>
#include <StringFormat.h>
#include <TextView.h>

#include "Pairs.h"
#include "PairsButton.h"
#include "PairsView.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PairsWindow"


const uint32 MENU_NEW                                   = 'MGnw';
const uint32 MENU_DIFFICULTY                    = 'MGdf';
const uint32 MENU_QUIT                                  = 'MGqu';
const uint32 MENU_ICON_SIZE                             = 'MSIs';

const uint32 kMsgPairComparing                  = 'pcom';


//      #pragma mark - PairsWindow


PairsWindow::PairsWindow()
        :
        BWindow(BRect(0, 0, 0, 0), B_TRANSLATE_SYSTEM_NAME("Pairs"),
                B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE
                        | B_NOT_RESIZABLE | B_NOT_ZOOMABLE),
        fPairComparing(NULL),
        fIsFirstClick(true),
        fIsPairsActive(true),
        fPairCardPosition(0),
        fPairCardTmpPosition(0),
        fButtonTmpPosition(0),
        fButtonPosition(0),
        fButtonClicks(0),
        fFinishPairs(0),
        fIconSizeMenu(NULL)
{
        _MakeMenuBar();
        _MakeGameView(4, 4);

        CenterOnScreen();
}


PairsWindow::~PairsWindow()
{
        delete fPairComparing;
}


void
PairsWindow::_MakeMenuBar()
{
        fMenuBar = new BMenuBar(BRect(0, 0, 0, 0), "menubar");
        AddChild(fMenuBar);

        BMenu* gameMenu = new BMenu(B_TRANSLATE("Game"));
        fMenuBar->AddItem(gameMenu);

        BMenuItem* menuItem;

        BMenu* newMenu = new BMenu(B_TRANSLATE("New"));
        newMenu->SetRadioMode(true);

        BMessage* difficultyMessage = new BMessage(MENU_DIFFICULTY);
        difficultyMessage->AddInt32("rows", 4);
        difficultyMessage->AddInt32("cols", 4);
        newMenu->AddItem(menuItem = new BMenuItem(B_TRANSLATE("Beginner (4x4)"),
                difficultyMessage));
        menuItem->SetMarked(true);

        difficultyMessage = new BMessage(MENU_DIFFICULTY);
        difficultyMessage->AddInt32("rows", 6);
        difficultyMessage->AddInt32("cols", 6);
        newMenu->AddItem(new BMenuItem(B_TRANSLATE("Intermediate (6x6)"),
                difficultyMessage));

        difficultyMessage = new BMessage(MENU_DIFFICULTY);
        difficultyMessage->AddInt32("rows", 8);
        difficultyMessage->AddInt32("cols", 8);
        newMenu->AddItem(new BMenuItem(B_TRANSLATE("Expert (8x8)"),
                difficultyMessage));

        menuItem = new BMenuItem(newMenu, new BMessage(MENU_NEW));
        menuItem->SetShortcut('N', B_COMMAND_KEY);
        gameMenu->AddItem(menuItem);

        gameMenu->AddSeparatorItem();

        gameMenu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
                new BMessage(MENU_QUIT), 'Q'));

        fIconSizeMenu = new BMenu(B_TRANSLATE("Size"));
        fIconSizeMenu->SetRadioMode(true);
        fMenuBar->AddItem(fIconSizeMenu);

        BMessage* iconSizeMessage = new BMessage(MENU_ICON_SIZE);
        iconSizeMessage->AddInt32("size", kSmallIconSize);
        fIconSizeMenu->AddItem(new BMenuItem(
                B_TRANSLATE("Small"), iconSizeMessage), 0);

        iconSizeMessage = new BMessage(MENU_ICON_SIZE);
        iconSizeMessage->AddInt32("size", kMediumIconSize);
        fIconSizeMenu->AddItem(menuItem = new BMenuItem(
                B_TRANSLATE("Medium"), iconSizeMessage), 1);
        menuItem->SetMarked(true);

        iconSizeMessage = new BMessage(MENU_ICON_SIZE);
        iconSizeMessage->AddInt32("size", kLargeIconSize);
        fIconSizeMenu->AddItem(new BMenuItem(
                B_TRANSLATE("Large"), iconSizeMessage), 2);
}


void
PairsWindow::_MakeGameView(uint8 rows, uint8 cols)
{
        BRect viewBounds = Bounds();
        viewBounds.top = fMenuBar->Bounds().Height() + 1;

        uint8 iconSize;
        BMenuItem* marked = fIconSizeMenu->FindMarked();
        if (marked != NULL) {
                switch (fIconSizeMenu->IndexOf(marked)) {
                        case 0:
                                iconSize = kSmallIconSize;
                                break;

                        case 2:
                                iconSize = kLargeIconSize;
                                break;

                        case 1:
                        default:
                                iconSize = kMediumIconSize;
                }
        } else {
                iconSize = kMediumIconSize;
                fIconSizeMenu->ItemAt(1)->SetMarked(true);
        }

        fPairsView = new PairsView(viewBounds, "PairsView", rows, cols, iconSize);
        AddChild(fPairsView);
        _ResizeWindow(rows, cols);
}


void
PairsWindow::NewGame()
{
        fButtonClicks = 0;
        fFinishPairs = 0;
        fIsFirstClick = true;
        fPairsView->CreateGameBoard();
}


void
PairsWindow::SetGameSize(uint8 rows, uint8 cols)
{
        RemoveChild(fPairsView);
        delete fPairsView;

        _MakeGameView(rows, cols);
        NewGame();
}


void
PairsWindow::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MENU_NEW:
                        NewGame();
                        break;

                case MENU_DIFFICULTY:
                {
                        int32 rows;
                        int32 cols;
                        if (message->FindInt32("rows", &rows) == B_OK
                                && message->FindInt32("cols", &cols) == B_OK) {
                                SetGameSize(rows, cols);
                        }
                        break;
                }

                case MENU_ICON_SIZE:
                {
                        int32 size;
                        if (message->FindInt32("size", &size) == B_OK) {
                                fPairsView->SetIconSize(size);
                                _ResizeWindow(fPairsView->Rows(), fPairsView->Cols());
                        }

                        break;
                }

                case MENU_QUIT:
                        be_app->PostMessage(B_QUIT_REQUESTED);
                        break;

                case kMsgCardButton:
                {
                        if (!fIsPairsActive)
                                break;

                        int32 buttonNumber;
                        if (message->FindInt32("button number", &buttonNumber) != B_OK)
                                break;

                        BObjectList<PairsButton>* pairsButtonList
                                = fPairsView->PairsButtonList();
                        if (pairsButtonList == NULL)
                                break;

                        // look at what icon is behind a button
                        int32 buttonCount = pairsButtonList->CountItems();
                        for (int32 i = 0; i < buttonCount; i++) {
                                int32 iconPosition = fPairsView->GetIconPosition(i);
                                if (iconPosition == buttonNumber) {
                                        fPairCardPosition = i % (buttonCount / 2);
                                        fButtonPosition = iconPosition;
                                        break;
                                }
                        }

                        // gameplay
                        fButtonClicks++;
                        pairsButtonList->ItemAt(fButtonPosition)->Hide();

                        if (fIsFirstClick) {
                                fPairCardTmpPosition = fPairCardPosition;
                                fButtonTmpPosition = fButtonPosition;
                        } else {
                                delete fPairComparing;
                                        // message of message runner might not have arrived
                                        // yet, so it is deleted here to prevent any leaking
                                        // just in case
                                BMessage message(kMsgPairComparing);
                                fPairComparing = new BMessageRunner(BMessenger(this),
                                        &message,  5 * 100000L, 1);
                                fIsPairsActive = false;
                        }

                        fIsFirstClick = !fIsFirstClick;
                        break;
                }

                case kMsgPairComparing:
                {
                        BObjectList<PairsButton>* pairsButtonList
                                = fPairsView->PairsButtonList();
                        if (pairsButtonList == NULL)
                                break;

                        delete fPairComparing;
                        fPairComparing = NULL;

                        fIsPairsActive = true;

                        if (fPairCardPosition == fPairCardTmpPosition)
                                fFinishPairs++;
                        else {
                                pairsButtonList->ItemAt(fButtonPosition)->Show();
                                pairsButtonList->ItemAt(fButtonTmpPosition)->Show();
                        }

                        // game end and results
                        if (fFinishPairs == pairsButtonList->CountItems() / 2) {
                                BString strAbout = B_TRANSLATE("%app%\n"
                                        "\twritten by Ralf Schülke\n"
                                        "\tCopyright 2008-2010, Haiku Inc.\n"
                                        "\n");

                                strAbout.ReplaceFirst("%app%",
                                        B_TRANSLATE_SYSTEM_NAME("Pairs"));

                                // Note: in english the singular form is never used, but other
                                // languages behave differently.
                                static BStringFormat format(B_TRANSLATE(
                                        "You completed the game in "
                                        "{0, plural, one{# click} other{# clicks}}.\n"));
                                format.Format(strAbout, fButtonClicks);

                                BAlert* alert = new BAlert("about",
                                        strAbout.String(),
                                        B_TRANSLATE("New game"),
                                        B_TRANSLATE("Quit game"));

                                BTextView* view = alert->TextView();
                                BFont font;

                                view->SetStylable(true);

                                view->GetFont(&font);
                                font.SetSize(18);
                                font.SetFace(B_BOLD_FACE);
                                view->SetFontAndColor(0,
                                        strlen(B_TRANSLATE_SYSTEM_NAME("Pairs")), &font);
                                view->ResizeToPreferred();
                                alert->SetShortcut(0, B_ESCAPE);

                                if (alert->Go() == 0)
                                        NewGame();
                                else
                                        be_app->PostMessage(B_QUIT_REQUESTED);
                        }
                        break;
                }

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


//      #pragma mark - PairsWindow private methods


void
PairsWindow::_ResizeWindow(uint8 rows, uint8 cols)
{
        int32 iconSize = fPairsView->IconSize();
        int32 spacing = fPairsView->Spacing();

        ResizeTo((iconSize + spacing) * rows + spacing,
                (iconSize + spacing) * cols + spacing + fMenuBar->Bounds().Height());
}