/*
 * Copyright 2002-2006, project beam (http://sourceforge.net/projects/beam).
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Oliver Tappe <beam@hirschkaefer.de>
 */

#include "AutoCompleterDefaultImpl.h"

#include <ListView.h>
#include <Screen.h>
#include <ScrollView.h>
#include <Window.h>


// #pragma mark - BDefaultPatternSelector


void
BDefaultPatternSelector::SelectPatternBounds(const BString& text,
	int32 caretPos, int32* start, int32* length)
{
	if (!start || !length)
		return;
	*start = 0;
	*length = text.Length();
}


// #pragma mark - BDefaultCompletionStyle


BDefaultCompletionStyle::BDefaultCompletionStyle(
		BAutoCompleter::EditView* editView,
		BAutoCompleter::ChoiceModel* choiceModel,
		BAutoCompleter::ChoiceView* choiceView,
		BAutoCompleter::PatternSelector* patternSelector)
	:
	CompletionStyle(editView, choiceModel, choiceView, patternSelector),
	fSelectedIndex(-1),
	fPatternStartPos(0),
	fPatternLength(0),
	fIgnoreEditViewStateChanges(false)
{
}


BDefaultCompletionStyle::~BDefaultCompletionStyle()
{
}


bool
BDefaultCompletionStyle::Select(int32 index)
{
	if (!fChoiceView || !fChoiceModel || index == fSelectedIndex
		|| index < -1 || index >= fChoiceModel->CountChoices()) {
		return false;
	}

	fSelectedIndex = index;
	fChoiceView->SelectChoiceAt(index);
	return true;
}


bool
BDefaultCompletionStyle::SelectNext(bool wrap)
{
	if (!fChoiceModel || fChoiceModel->CountChoices() == 0)
		return false;

	int32 newIndex = fSelectedIndex + 1;
	if (newIndex >= fChoiceModel->CountChoices()) {
		if (wrap)
			newIndex = 0;
		else
			newIndex = fSelectedIndex;
	}
	return Select(newIndex);
}


bool
BDefaultCompletionStyle::SelectPrevious(bool wrap)
{
	if (!fChoiceModel || fChoiceModel->CountChoices() == 0)
		return false;

	int32 newIndex = fSelectedIndex - 1;
	if (newIndex < 0) {
		if (wrap)
			newIndex = fChoiceModel->CountChoices() - 1;
		else
			newIndex = 0;
	}
	return Select(newIndex);
}


bool
BDefaultCompletionStyle::IsChoiceSelected() const
{
	return fSelectedIndex >= 0;
}


int32
BDefaultCompletionStyle::SelectedChoiceIndex() const
{
	return fSelectedIndex;
}


void
BDefaultCompletionStyle::ApplyChoice(bool hideChoices)
{
	if (!fChoiceModel || !fChoiceView || !fEditView || fSelectedIndex < 0)
		return;

	BString completedText(fFullEnteredText);
	completedText.Remove(fPatternStartPos, fPatternLength);
	const BString& choiceStr = fChoiceModel->ChoiceAt(fSelectedIndex)->Text();
	completedText.Insert(choiceStr, fPatternStartPos);

	fIgnoreEditViewStateChanges = true;

	fFullEnteredText = completedText;
	fPatternLength = choiceStr.Length();
	fEditView->SetEditViewState(completedText, 
		fPatternStartPos + choiceStr.Length());

	if (hideChoices) {
		fChoiceView->HideChoices();
		Select(-1);
	}

	fIgnoreEditViewStateChanges = false;
}


void
BDefaultCompletionStyle::CancelChoice()
{
	if (!fChoiceView || !fEditView)
		return;
	if (fChoiceView->ChoicesAreShown()) {
		fIgnoreEditViewStateChanges = true;

		fEditView->SetEditViewState(fFullEnteredText,
			fPatternStartPos + fPatternLength);
		fChoiceView->HideChoices();
		Select(-1);

		fIgnoreEditViewStateChanges = false;
	}
}

void
BDefaultCompletionStyle::EditViewStateChanged(bool updateChoices)
{
	if (fIgnoreEditViewStateChanges || !fChoiceModel || !fChoiceView
		|| !fEditView) {
		return;
	}

	BString text;
	int32 caretPos;
	fEditView->GetEditViewState(text, &caretPos);
	if (fFullEnteredText == text)
		return;

	fFullEnteredText = text;

	if (!updateChoices)
		return;

	fPatternSelector->SelectPatternBounds(text, caretPos, &fPatternStartPos, 
		&fPatternLength);
	BString pattern(text.String() + fPatternStartPos, fPatternLength);
	fChoiceModel->FetchChoicesFor(pattern);

	Select(-1);
	// show a single choice only if it doesn't match the pattern exactly:
	if (fChoiceModel->CountChoices() > 1 || (fChoiceModel->CountChoices() == 1
			&& pattern.ICompare(fChoiceModel->ChoiceAt(0)->Text())) != 0) {
		fChoiceView->ShowChoices(this);
		fChoiceView->SelectChoiceAt(fSelectedIndex);
	} else
		fChoiceView->HideChoices();
}


// #pragma mark - BDefaultChoiceView::ListView


static const int32 MSG_INVOKED = 'invk';


BDefaultChoiceView::ListView::ListView(
		BAutoCompleter::CompletionStyle* completer)
	:
	BListView(BRect(0, 0, 100, 100), "ChoiceViewList"),
	fCompleter(completer)
{
	// we need to check if user clicks outside of window-bounds:
	SetEventMask(B_POINTER_EVENTS);
}


void
BDefaultChoiceView::ListView::AttachedToWindow()
{
	SetTarget(this);
	SetInvocationMessage(new BMessage(MSG_INVOKED));
	BListView::AttachedToWindow();
}


void
BDefaultChoiceView::ListView::SelectionChanged()
{
	fCompleter->Select(CurrentSelection(0));
}


void
BDefaultChoiceView::ListView::MessageReceived(BMessage* message)
{
	switch(message->what) {
		case MSG_INVOKED:
			fCompleter->ApplyChoice();
			break;
		default:
			BListView::MessageReceived(message);
	}
}


void
BDefaultChoiceView::ListView::MouseDown(BPoint point)
{
	if (!Window()->Frame().Contains(ConvertToScreen(point)))
		// click outside of window, so we close it:
		Window()->Quit();
	else
		BListView::MouseDown(point);
}


// #pragma mark - BDefaultChoiceView::ListItem


BDefaultChoiceView::ListItem::ListItem(const BAutoCompleter::Choice* choice)
	:
	BListItem()
{
	fPreText = choice->DisplayText();
	if (choice->MatchLen() > 0) {
		fPreText.MoveInto(fMatchText, choice->MatchPos(), choice->MatchLen());
		fPreText.MoveInto(fPostText, choice->MatchPos(), fPreText.Length());
	}
}


void
BDefaultChoiceView::ListItem::DrawItem(BView* owner, BRect frame,
	bool complete)
{
	rgb_color textColor;
	rgb_color nonMatchTextColor;
	rgb_color backColor;
	rgb_color matchColor;
	if (IsSelected()) {
		textColor = ui_color(B_LIST_SELECTED_ITEM_TEXT_COLOR);
		backColor = ui_color(B_LIST_SELECTED_BACKGROUND_COLOR);
	} else {
		textColor = ui_color(B_LIST_ITEM_TEXT_COLOR);
		backColor = ui_color(B_LIST_BACKGROUND_COLOR);
	}
	matchColor = tint_color(backColor, (B_NO_TINT + B_DARKEN_1_TINT) / 2);
	if (textColor.red + textColor.green + textColor.blue > 128 * 3)
		nonMatchTextColor = tint_color(textColor, 1.2);
	else
		nonMatchTextColor = tint_color(textColor, 0.75);
	BFont font;
	font_height fontHeight;
	owner->GetFont(&font);
	font.GetHeight(&fontHeight);
	float xPos = frame.left + 1;
	float yPos = frame.top + fontHeight.ascent;
	float w;
	if (fPreText.Length()) {
		w = owner->StringWidth(fPreText.String());
		owner->SetLowColor(backColor);
		owner->FillRect(BRect(xPos, frame.top, xPos + w - 1, frame.bottom),
			B_SOLID_LOW);
		owner->SetHighColor(nonMatchTextColor);
		owner->DrawString(fPreText.String(), BPoint(xPos, yPos));
		xPos += w;
	}
	if (fMatchText.Length()) {
		w = owner->StringWidth(fMatchText.String());
		owner->SetLowColor(matchColor);
		owner->FillRect(BRect(xPos, frame.top, xPos + w - 1, frame.bottom), 
			B_SOLID_LOW);
		owner->SetHighColor(textColor);
		owner->DrawString(fMatchText.String(), BPoint(xPos, yPos));
		xPos += w;
	}
	if (fPostText.Length()) {
		w = owner->StringWidth(fPostText.String());
		owner->SetLowColor(backColor);
		owner->FillRect(BRect(xPos, frame.top, xPos + w - 1, frame.bottom), 
			B_SOLID_LOW);
		owner->SetHighColor(nonMatchTextColor);
		owner->DrawString(fPostText.String(), BPoint(xPos, yPos));
	}
}


// #pragma mark - BDefaultChoiceView


BDefaultChoiceView::BDefaultChoiceView()
	:
	fWindow(NULL),
	fListView(NULL),
	fMaxVisibleChoices(8)
{
	
}


BDefaultChoiceView::~BDefaultChoiceView()
{
	HideChoices();
}
	

void
BDefaultChoiceView::SelectChoiceAt(int32 index)
{
	if (fListView && fListView->LockLooper()) {
		if (index < 0)
			fListView->DeselectAll();
		else {
			fListView->Select(index);
			fListView->ScrollToSelection();
		}
		fListView->UnlockLooper();
	}
}


void
BDefaultChoiceView::ShowChoices(BAutoCompleter::CompletionStyle* completer)
{
	if (!completer)
		return;

	HideChoices();

	BAutoCompleter::ChoiceModel* choiceModel = completer->GetChoiceModel();
	BAutoCompleter::EditView* editView = completer->GetEditView();

	if (!editView || !choiceModel || choiceModel->CountChoices() == 0)
		return;

	fListView = new ListView(completer);
	int32 count = choiceModel->CountChoices();
	for(int32 i = 0; i<count; ++i) {
		fListView->AddItem(
			new ListItem(choiceModel->ChoiceAt(i))
		);
	}

	BScrollView *scrollView = NULL;
	if (count > fMaxVisibleChoices) {
		scrollView = new BScrollView("", fListView, B_FOLLOW_NONE, 0, false, true, B_NO_BORDER);
	}

	fWindow = new BWindow(BRect(0, 0, 100, 100), "", B_BORDERED_WINDOW_LOOK, 
		B_NORMAL_WINDOW_FEEL, B_NOT_MOVABLE | B_WILL_ACCEPT_FIRST_CLICK 
			| B_AVOID_FOCUS | B_ASYNCHRONOUS_CONTROLS);
	if (scrollView != NULL)
		fWindow->AddChild(scrollView);
	else
		fWindow->AddChild(fListView);

	int32 visibleCount = min_c(count, fMaxVisibleChoices);
	float listHeight = fListView->ItemFrame(visibleCount - 1).bottom + 1;

	BRect pvRect = editView->GetAdjustmentFrame();
	BRect listRect = pvRect;
	listRect.bottom = listRect.top + listHeight - 1;
	BRect screenRect = BScreen().Frame();
	if (listRect.bottom + 1 + listHeight <= screenRect.bottom)
		listRect.OffsetTo(pvRect.left, pvRect.bottom + 1);
	else
		listRect.OffsetTo(pvRect.left, pvRect.top - listHeight);

	if (scrollView != NULL) {
		// Moving here to cut off the scrollbar top
		scrollView->MoveTo(0, -1);
		// Adding the 1 and 2 to cut-off the scroll-bar top, right and bottom
		scrollView->ResizeTo(listRect.Width() + 1, listRect.Height() + 2);
		// Move here to compensate for the above
		fListView->MoveTo(0, 1);
		fListView->ResizeTo(listRect.Width() - B_V_SCROLL_BAR_WIDTH, listRect.Height());
	} else {
		fListView->MoveTo(0, 0);
		fListView->ResizeTo(listRect.Width(), listRect.Height());
	}
	fWindow->MoveTo(listRect.left, listRect.top);
	fWindow->ResizeTo(listRect.Width(), listRect.Height());
	fWindow->Show();
}


void
BDefaultChoiceView::HideChoices()
{
	if (fWindow && fWindow->Lock()) {
		fWindow->Quit();
		fWindow = NULL;
		fListView = NULL;
	}
}


bool
BDefaultChoiceView::ChoicesAreShown()
{
	return (fWindow != NULL);
}


int32
BDefaultChoiceView::CountVisibleChoices() const
{
	if (fListView)
		return min_c(fMaxVisibleChoices, fListView->CountItems());
	else
		return 0;
}


void
BDefaultChoiceView::SetMaxVisibleChoices(int32 choices)
{
	if (choices < 1)
		choices = 1;
	if (choices == fMaxVisibleChoices)
		return;

	fMaxVisibleChoices = choices;

	// TODO: Update live?
}


int32
BDefaultChoiceView::MaxVisibleChoices() const
{
	return fMaxVisibleChoices;
}