/*

 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 *

 */

#include "config.h"

#include "SelectElement.h"

#include "Attribute.h"

#include "CharacterNames.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "Element.h"

#include "EventHandler.h"

#include "EventNames.h"

#include "FormDataList.h"

#include "Frame.h"

#include "HTMLFormElement.h"

#include "HTMLKeygenElement.h"

#include "HTMLNames.h"

#include "HTMLSelectElement.h"

#include "KeyboardEvent.h"

#include "MouseEvent.h"

#include "OptionElement.h"

#include "OptionGroupElement.h"

#include "Page.h"

#include "RenderListBox.h"

#include "RenderMenuList.h"

#include <wtf/Assertions.h>

#if ENABLE(WML)

#include "WMLNames.h"

#include "WMLSelectElement.h"

#endif

// Configure platform-specific behavior when focused pop-up receives arrow/space/return keystroke.

// (PLATFORM(MAC) and PLATFORM(GTK) are always false in Chromium, hence the extra tests.)

#if PLATFORM(MAC) || (PLATFORM(CHROMIUM) && OS(DARWIN))

#define ARROW_KEYS_POP_MENU 1

#define SPACE_OR_RETURN_POP_MENU 0

#elif PLATFORM(GTK) || (PLATFORM(CHROMIUM) && OS(LINUX))

#define ARROW_KEYS_POP_MENU 0

#define SPACE_OR_RETURN_POP_MENU 1

#else

#define ARROW_KEYS_POP_MENU 0

#define SPACE_OR_RETURN_POP_MENU 0

#endif

using std::min;

using std::max;

using namespace WTF;

using namespace Unicode;

namespace WebCore {

static const DOMTimeStamp typeAheadTimeout = 1000;

void SelectElement::selectAll(SelectElementData& data, Element* element)

{

    ASSERT(!data.usesMenuList());

    if (!element->renderer() || !data.multiple())

        return;

    // Save the selection so it can be compared to the new selectAll selection when dispatching change events

    saveLastSelection(data, element);

    data.setActiveSelectionState(true);

    setActiveSelectionAnchorIndex(data, element, nextSelectableListIndex(data, element, -1));

    setActiveSelectionEndIndex(data, previousSelectableListIndex(data, element, -1));

    updateListBoxSelection(data, element, false);

    listBoxOnChange(data, element);

}

void SelectElement::saveLastSelection(SelectElementData& data, Element* element)

{

    if (data.usesMenuList()) {

        data.setLastOnChangeIndex(selectedIndex(data, element));

        return;

    }

    Vector<bool>& lastOnChangeSelection = data.lastOnChangeSelection(); 

    lastOnChangeSelection.clear();

    const Vector<Element*>& items = data.listItems(element);

    for (unsigned i = 0; i < items.size(); ++i) {

        OptionElement* optionElement = toOptionElement(items[i]);

        lastOnChangeSelection.append(optionElement && optionElement->selected());

    }

}

int SelectElement::nextSelectableListIndex(SelectElementData& data, Element* element, int startIndex)

{

    const Vector<Element*>& items = data.listItems(element);

    int index = startIndex + 1;

    while (index >= 0 && (unsigned) index < items.size() && (!isOptionElement(items[index]) || items[index]->disabled()))

        ++index;

    if ((unsigned) index == items.size())

        return startIndex;

    return index;

}

int SelectElement::previousSelectableListIndex(SelectElementData& data, Element* element, int startIndex)

{

    const Vector<Element*>& items = data.listItems(element);

    if (startIndex == -1)

        startIndex = items.size();

    int index = startIndex - 1;

    while (index >= 0 && (unsigned) index < items.size() && (!isOptionElement(items[index]) || items[index]->disabled()))

        --index;

    if (index == -1)

        return startIndex;

    return index;

}

void SelectElement::setActiveSelectionAnchorIndex(SelectElementData& data, Element* element, int index)

{

    data.setActiveSelectionAnchorIndex(index);

    // Cache the selection state so we can restore the old selection as the new selection pivots around this anchor index

    Vector<bool>& cachedStateForActiveSelection = data.cachedStateForActiveSelection(); 

    cachedStateForActiveSelection.clear();

    const Vector<Element*>& items = data.listItems(element);

    for (unsigned i = 0; i < items.size(); ++i) {

        OptionElement* optionElement = toOptionElement(items[i]);

        cachedStateForActiveSelection.append(optionElement && optionElement->selected());

    }

}

void SelectElement::setActiveSelectionEndIndex(SelectElementData& data, int index)

{

    data.setActiveSelectionEndIndex(index);

}

void SelectElement::updateListBoxSelection(SelectElementData& data, Element* element, bool deselectOtherOptions)

{

    ASSERT(element->renderer() && (element->renderer()->isListBox() || data.multiple()));

    ASSERT(data.activeSelectionAnchorIndex() >= 0);

    unsigned start = min(data.activeSelectionAnchorIndex(), data.activeSelectionEndIndex());

    unsigned end = max(data.activeSelectionAnchorIndex(), data.activeSelectionEndIndex());

    Vector<bool>& cachedStateForActiveSelection = data.cachedStateForActiveSelection();

    const Vector<Element*>& items = data.listItems(element);

    for (unsigned i = 0; i < items.size(); ++i) {

        OptionElement* optionElement = toOptionElement(items[i]);

        if (!optionElement || items[i]->disabled())

            continue;

        if (i >= start && i <= end)

            optionElement->setSelectedState(data.activeSelectionState());

        else if (deselectOtherOptions || i >= cachedStateForActiveSelection.size())

            optionElement->setSelectedState(false);

        else

            optionElement->setSelectedState(cachedStateForActiveSelection[i]);

    }

    scrollToSelection(data, element);

}

void SelectElement::listBoxOnChange(SelectElementData& data, Element* element)

{

    ASSERT(!data.usesMenuList() || data.multiple());

    Vector<bool>& lastOnChangeSelection = data.lastOnChangeSelection(); 

    const Vector<Element*>& items = data.listItems(element);

    // If the cached selection list is empty, or the size has changed, then fire dispatchFormControlChangeEvent, and return early.

    if (lastOnChangeSelection.isEmpty() || lastOnChangeSelection.size() != items.size()) {

        element->dispatchFormControlChangeEvent();

        return;

    }

    // Update lastOnChangeSelection and fire dispatchFormControlChangeEvent

    bool fireOnChange = false;

    for (unsigned i = 0; i < items.size(); ++i) {

        OptionElement* optionElement = toOptionElement(items[i]);

        bool selected = optionElement &&  optionElement->selected();

        if (selected != lastOnChangeSelection[i])

            fireOnChange = true;

        lastOnChangeSelection[i] = selected;

    }

    if (fireOnChange)

        element->dispatchFormControlChangeEvent();

}

void SelectElement::menuListOnChange(SelectElementData& data, Element* element)

{

    ASSERT(data.usesMenuList());

    int selected = selectedIndex(data, element);

    if (data.lastOnChangeIndex() != selected && data.userDrivenChange()) {

        data.setLastOnChangeIndex(selected);

        data.setUserDrivenChange(false);

        element->dispatchFormControlChangeEvent();

    }

}

void SelectElement::scrollToSelection(SelectElementData& data, Element* element)

{

    if (data.usesMenuList())

        return;

    if (RenderObject* renderer = element->renderer())

        toRenderListBox(renderer)->selectionChanged();

}

void SelectElement::setOptionsChangedOnRenderer(SelectElementData& data, Element* element)

{

    if (RenderObject* renderer = element->renderer()) {

        if (data.usesMenuList())

            toRenderMenuList(renderer)->setOptionsChanged(true);

        else

            toRenderListBox(renderer)->setOptionsChanged(true);

    }

}

void SelectElement::setRecalcListItems(SelectElementData& data, Element* element)

{

    data.setShouldRecalcListItems(true);

    data.setActiveSelectionAnchorIndex(-1); // Manual selection anchor is reset when manipulating the select programmatically.

    setOptionsChangedOnRenderer(data, element);

    element->setNeedsStyleRecalc();

}

void SelectElement::recalcListItems(SelectElementData& data, const Element* element, bool updateSelectedStates)

{

    Vector<Element*>& listItems = data.rawListItems();

    listItems.clear();

    data.setShouldRecalcListItems(false);

    OptionElement* foundSelected = 0;

    for (Node* currentNode = element->firstChild(); currentNode;) {

        if (!currentNode->isElementNode()) {

            currentNode = currentNode->traverseNextSibling(element);

            continue;

        }

        Element* current = static_cast<Element*>(currentNode);

        // optgroup tags may not nest. However, both FireFox and IE will

        // flatten the tree automatically, so we follow suit.

        // (http://www.w3.org/TR/html401/interact/forms.html#h-17.6)

        if (isOptionGroupElement(current)) {

            listItems.append(current);

            if (current->firstChild()) {

                currentNode = current->firstChild();

                continue;

            }

        }

        if (OptionElement* optionElement = toOptionElement(current)) {

            listItems.append(current);

            if (updateSelectedStates && !data.multiple()) {

                if (!foundSelected && (data.size() <= 1 || optionElement->selected())) {

                    foundSelected = optionElement;

                    foundSelected->setSelectedState(true);

                } else if (foundSelected && optionElement->selected()) {

                    foundSelected->setSelectedState(false);

                    foundSelected = optionElement;

                }

            }

        }

        if (current->hasTagName(HTMLNames::hrTag))

            listItems.append(current);

        // In conforming HTML code, only <optgroup> and <option> will be found

        // within a <select>. We call traverseNextSibling so that we only step

        // into those tags that we choose to. For web-compat, we should cope

        // with the case where odd tags like a <div> have been added but we

        // handle this because such tags have already been removed from the

        // <select>'s subtree at this point.

        currentNode = currentNode->traverseNextSibling(element);

    }

}

int SelectElement::selectedIndex(const SelectElementData& data, const Element* element)

{

    unsigned index = 0;

    // return the number of the first option selected

    const Vector<Element*>& items = data.listItems(element);

    for (size_t i = 0; i < items.size(); ++i) {

        if (OptionElement* optionElement = toOptionElement(items[i])) {

            if (optionElement->selected())

                return index;

            ++index;

        }

    }

    return -1;

}

void SelectElement::setSelectedIndex(SelectElementData& data, Element* element, int optionIndex, bool deselect, bool fireOnChangeNow, bool userDrivenChange)

{

    const Vector<Element*>& items = data.listItems(element);

    int listIndex = optionToListIndex(data, element, optionIndex);

    if (!data.multiple())

        deselect = true;

    Element* excludeElement = 0;

    if (OptionElement* optionElement = (listIndex >= 0 ? toOptionElement(items[listIndex]) : 0)) {

        excludeElement = items[listIndex];

        if (data.activeSelectionAnchorIndex() < 0 || deselect)

            setActiveSelectionAnchorIndex(data, element, listIndex);

        if (data.activeSelectionEndIndex() < 0 || deselect)

            setActiveSelectionEndIndex(data, listIndex);

        optionElement->setSelectedState(true);

    }

    if (deselect)

        deselectItems(data, element, excludeElement);

    // For the menu list case, this is what makes the selected element appear.

    if (RenderObject* renderer = element->renderer())

        renderer->updateFromElement();

    scrollToSelection(data, element);

    // This only gets called with fireOnChangeNow for menu lists. 

    if (data.usesMenuList()) {

        data.setUserDrivenChange(userDrivenChange);

        if (fireOnChangeNow)

            menuListOnChange(data, element);

        RenderObject* renderer = element->renderer();

        if (renderer) {

            if (data.usesMenuList())

                toRenderMenuList(renderer)->didSetSelectedIndex();

            else if (renderer->isListBox())

                toRenderListBox(renderer)->selectionChanged();

        }

    }

    if (Frame* frame = element->document()->frame())

        frame->page()->chrome()->client()->formStateDidChange(element);

}

int SelectElement::optionToListIndex(const SelectElementData& data, const Element* element, int optionIndex)

{

    const Vector<Element*>& items = data.listItems(element);

    int listSize = (int) items.size();

    if (optionIndex < 0 || optionIndex >= listSize)

        return -1;

    int optionIndex2 = -1;

    for (int listIndex = 0; listIndex < listSize; ++listIndex) {

        if (isOptionElement(items[listIndex])) {

            ++optionIndex2;

            if (optionIndex2 == optionIndex)

                return listIndex;

        }

    }

    return -1;

}

int SelectElement::listToOptionIndex(const SelectElementData& data, const Element* element, int listIndex)

{

    const Vector<Element*>& items = data.listItems(element);

    if (listIndex < 0 || listIndex >= int(items.size()) ||

        !isOptionElement(items[listIndex]))

        return -1;

    int optionIndex = 0; // actual index of option not counting OPTGROUP entries that may be in list

    for (int i = 0; i < listIndex; ++i)

        if (isOptionElement(items[i]))

            ++optionIndex;

    return optionIndex;

}

void SelectElement::dispatchFocusEvent(SelectElementData& data, Element* element)

{

    // Save the selection so it can be compared to the new selection when dispatching change events during blur event dispatchal

    if (data.usesMenuList())

        saveLastSelection(data, element);

}

void SelectElement::dispatchBlurEvent(SelectElementData& data, Element* element)

{

    // We only need to fire change events here for menu lists, because we fire change events for list boxes whenever the selection change is actually made.

    // This matches other browsers' behavior.

    if (data.usesMenuList())

        menuListOnChange(data, element);

}

void SelectElement::deselectItems(SelectElementData& data, Element* element, Element* excludeElement)

{

    const Vector<Element*>& items = data.listItems(element);

    for (unsigned i = 0; i < items.size(); ++i) {

        if (items[i] == excludeElement)

            continue;

        if (OptionElement* optionElement = toOptionElement(items[i]))

            optionElement->setSelectedState(false);

    }

}

bool SelectElement::saveFormControlState(const SelectElementData& data, const Element* element, String& value)

{

    const Vector<Element*>& items = data.listItems(element);

    int length = items.size();

    // FIXME: Change this code to use the new StringImpl::createUninitialized code path.

    Vector<char, 1024> characters(length);

    for (int i = 0; i < length; ++i) {

        OptionElement* optionElement = toOptionElement(items[i]);

        bool selected = optionElement && optionElement->selected();

        characters[i] = selected ? 'X' : '.';

    }

    value = String(characters.data(), length);

    return true;

}

void SelectElement::restoreFormControlState(SelectElementData& data, Element* element, const String& state)

{

    recalcListItems(data, element);

    const Vector<Element*>& items = data.listItems(element);

    int length = items.size();

    for (int i = 0; i < length; ++i) {

        if (OptionElement* optionElement = toOptionElement(items[i]))

            optionElement->setSelectedState(state[i] == 'X');

    }

    setOptionsChangedOnRenderer(data, element);

}

void SelectElement::parseMultipleAttribute(SelectElementData& data, Element* element, Attribute* attribute)

{

    bool oldUsesMenuList = data.usesMenuList();

    data.setMultiple(!attribute->isNull());

    if (oldUsesMenuList != data.usesMenuList() && element->attached()) {

        element->detach();

        element->attach();

    }

}

bool SelectElement::appendFormData(SelectElementData& data, Element* element, FormDataList& list)

{

    const AtomicString& name = element->formControlName();

    if (name.isEmpty())

        return false;

    bool successful = false;

    const Vector<Element*>& items = data.listItems(element);

    for (unsigned i = 0; i < items.size(); ++i) {

        OptionElement* optionElement = toOptionElement(items[i]);

        if (optionElement && optionElement->selected() && !optionElement->disabled()) {

            list.appendData(name, optionElement->value());

            successful = true;

        }

    }

    // It's possible that this is a menulist with multiple options and nothing

    // will be submitted (!successful). We won't send a unselected non-disabled

    // option as fallback. This behavior matches to other browsers.

    return successful;

} 

void SelectElement::reset(SelectElementData& data, Element* element)

{

    OptionElement* firstOption = 0;

    OptionElement* selectedOption = 0;

    const Vector<Element*>& items = data.listItems(element);

    for (unsigned i = 0; i < items.size(); ++i) {

        OptionElement* optionElement = toOptionElement(items[i]);

        if (!optionElement)

            continue;

        if (!items[i]->getAttribute(HTMLNames::selectedAttr).isNull()) {

            if (selectedOption && !data.multiple())

                selectedOption->setSelectedState(false);

            optionElement->setSelectedState(true);

            selectedOption = optionElement;

        } else

            optionElement->setSelectedState(false);

        if (!firstOption)

            firstOption = optionElement;

    }

    if (!selectedOption && firstOption && !data.multiple() && data.size() <= 1)

        firstOption->setSelectedState(true);

    setOptionsChangedOnRenderer(data, element);

    element->setNeedsStyleRecalc();

}

#if !ARROW_KEYS_POP_MENU

enum SkipDirection {

    SkipBackwards = -1,

    SkipForwards = 1

};

// Returns the index of the next valid list item |skip| items past |listIndex| in direction |direction|.

static int nextValidIndex(const Vector<Element*>& listItems, int listIndex, SkipDirection direction, int skip)

{

    int lastGoodIndex = listIndex;

    int size = listItems.size();

    for (listIndex += direction; listIndex >= 0 && listIndex < size; listIndex += direction) {

        --skip;

        if (!listItems[listIndex]->disabled() && isOptionElement(listItems[listIndex])) {

            lastGoodIndex = listIndex;