/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 *           (C) 2001 Dirk Mueller (mueller@kde.org)

 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

 *           (C) 2006 Alexey Proskuryakov (ap@nypop.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 "HTMLFormElement.h"

#include "CSSHelper.h"

#include "ChromeClient.h"

#include "Document.h"

#include "Event.h"

#include "EventNames.h"

#include "FileList.h"

#include "FileSystem.h"

#include "FormData.h"

#include "FormDataList.h"

#include "FormState.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "HTMLDocument.h"

#include "HTMLFormCollection.h"

#include "HTMLImageElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "ScriptEventListener.h"

#include "MIMETypeRegistry.h"

#include "MappedAttribute.h"

#include "Page.h"

#include "RenderTextControl.h"

#include "ValidityState.h"

#include <limits>

#include <wtf/CurrentTime.h>

#include <wtf/RandomNumber.h>

#if PLATFORM(WX)

#include <wx/defs.h>

#include <wx/filename.h>

#endif

using namespace std;

namespace WebCore {

using namespace HTMLNames;

static int64_t generateFormDataIdentifier()

{

    // Initialize to the current time to reduce the likelihood of generating

    // identifiers that overlap with those from past/future browser sessions.

    static int64_t nextIdentifier = static_cast<int64_t>(currentTime() * 1000000.0);

    return ++nextIdentifier;

}

HTMLFormElement::HTMLFormElement(const QualifiedName& tagName, Document* doc)

    : HTMLElement(tagName, doc)

    , m_elementAliases(0)

    , collectionInfo(0)

    , m_autocomplete(true)

    , m_insubmit(false)

    , m_doingsubmit(false)

    , m_inreset(false)

    , m_malformed(false)

    , m_demoted(false)

{

    ASSERT(hasTagName(formTag));

}

HTMLFormElement::~HTMLFormElement()

{

    if (!m_autocomplete)

        document()->unregisterForDocumentActivationCallbacks(this);

    delete m_elementAliases;

    delete collectionInfo;

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

        formElements[i]->formDestroyed();

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

        imgElements[i]->m_form = 0;

}

bool HTMLFormElement::formWouldHaveSecureSubmission(const String& url)

{

    return document()->completeURL(url).protocolIs("https");

}

void HTMLFormElement::attach()

{

    HTMLElement::attach();

}

bool HTMLFormElement::rendererIsNeeded(RenderStyle* style)

{

    if (!isDemoted())

        return HTMLElement::rendererIsNeeded(style);

    Node* node = parentNode();

    RenderObject* parentRenderer = node->renderer();

    bool parentIsTableElementPart = (parentRenderer->isTable() && node->hasTagName(tableTag))

        || (parentRenderer->isTableRow() && node->hasTagName(trTag))

        || (parentRenderer->isTableSection() && node->hasTagName(tbodyTag))

        || (parentRenderer->isTableCol() && node->hasTagName(colTag)) 

        || (parentRenderer->isTableCell() && node->hasTagName(trTag));

    if (!parentIsTableElementPart)

        return true;

    EDisplay display = style->display();

    bool formIsTablePart = display == TABLE || display == INLINE_TABLE || display == TABLE_ROW_GROUP

        || display == TABLE_HEADER_GROUP || display == TABLE_FOOTER_GROUP || display == TABLE_ROW

        || display == TABLE_COLUMN_GROUP || display == TABLE_COLUMN || display == TABLE_CELL

        || display == TABLE_CAPTION;

    return formIsTablePart;

}

void HTMLFormElement::insertedIntoDocument()

{

    if (document()->isHTMLDocument())

        static_cast<HTMLDocument*>(document())->addNamedItem(m_name);

    HTMLElement::insertedIntoDocument();

}

void HTMLFormElement::removedFromDocument()

{

    if (document()->isHTMLDocument())

        static_cast<HTMLDocument*>(document())->removeNamedItem(m_name);

    HTMLElement::removedFromDocument();

}

void HTMLFormElement::handleLocalEvents(Event* event)

{

    Node* targetNode = event->target()->toNode();

    if (event->eventPhase() != Event::CAPTURING_PHASE && targetNode && targetNode != this && (event->type() == eventNames().submitEvent || event->type() == eventNames().resetEvent)) {

        event->stopPropagation();

        return;

    }

    HTMLElement::handleLocalEvents(event);

}

unsigned HTMLFormElement::length() const

{

    int len = 0;

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

        if (formElements[i]->isEnumeratable())

            ++len;

    return len;

}

Node* HTMLFormElement::item(unsigned index)

{

    return elements()->item(index);

}

void HTMLFormElement::submitClick(Event* event)

{

    bool submitFound = false;

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

        if (formElements[i]->hasLocalName(inputTag)) {

            HTMLInputElement* element = static_cast<HTMLInputElement*>(formElements[i]);

            if (element->isSuccessfulSubmitButton() && element->renderer()) {

                submitFound = true;

                element->dispatchSimulatedClick(event);

                break;

            }

        }

    }

    if (!submitFound) // submit the form without a submit or image input

        prepareSubmit(event);

}

TextEncoding HTMLFormElement::dataEncoding() const

{

    if (isMailtoForm())

        return UTF8Encoding();

    return m_formDataBuilder.dataEncoding(document());

}

PassRefPtr<FormData> HTMLFormElement::createFormData(const CString& boundary)

{

    Vector<char> encodedData;

    TextEncoding encoding = dataEncoding().encodingForFormSubmission();

    RefPtr<FormData> result = FormData::create();

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

        HTMLFormControlElement* control = formElements[i];

        FormDataList list(encoding);

        if (!control->disabled() && control->appendFormData(list, m_formDataBuilder.isMultiPartForm())) {

            size_t formDataListSize = list.list().size();

            ASSERT(formDataListSize % 2 == 0);

            for (size_t j = 0; j < formDataListSize; j += 2) {

                const FormDataList::Item& key = list.list()[j];

                const FormDataList::Item& value = list.list()[j + 1];

                if (!m_formDataBuilder.isMultiPartForm()) {

                    // Omit the name "isindex" if it's the first form data element.

                    // FIXME: Why is this a good rule? Is this obsolete now?

                    if (encodedData.isEmpty() && key.data() == "isindex")

                        FormDataBuilder::encodeStringAsFormData(encodedData, value.data());

                    else

                        m_formDataBuilder.addKeyValuePairAsFormData(encodedData, key.data(), value.data());

                } else {

                    Vector<char> header;

                    m_formDataBuilder.beginMultiPartHeader(header, boundary, key.data());

                    bool shouldGenerateFile = false;

                    // if the current type is FILE, then we also need to include the filename

                    if (value.file()) {

                        const String& path = value.file()->path();

                        String fileName = value.file()->fileName();

                        // Let the application specify a filename if it's going to generate a replacement file for the upload.

                        if (!path.isEmpty()) {

                            if (Page* page = document()->page()) {

                                String generatedFileName;

                                shouldGenerateFile = page->chrome()->client()->shouldReplaceWithGeneratedFileForUpload(path, generatedFileName);

                                if (shouldGenerateFile)

                                    fileName = generatedFileName;

                            }

                        }

                        // We have to include the filename=".." part in the header, even if the filename is empty

                        m_formDataBuilder.addFilenameToMultiPartHeader(header, encoding, fileName);

                        if (!fileName.isEmpty()) {

                            // FIXME: The MIMETypeRegistry function's name makes it sound like it takes a path,

                            // not just a basename. But filename is not the path. But note that it's not safe to

                            // just use path instead since in the generated-file case it will not reflect the

                            // MIME type of the generated file.

                            String mimeType = MIMETypeRegistry::getMIMETypeForPath(fileName);

                            if (!mimeType.isEmpty())

                                m_formDataBuilder.addContentTypeToMultiPartHeader(header, mimeType.latin1());

                        }

                    }

                    m_formDataBuilder.finishMultiPartHeader(header);

                    // Append body

                    result->appendData(header.data(), header.size());

                    if (size_t dataSize = value.data().length())

                        result->appendData(value.data().data(), dataSize);

                    else if (value.file() && !value.file()->path().isEmpty())

                        result->appendFile(value.file()->path(), shouldGenerateFile);

                    result->appendData("\r\n", 2);

                }

            }

        }

    }

    if (m_formDataBuilder.isMultiPartForm())

        m_formDataBuilder.addBoundaryToMultiPartHeader(encodedData, boundary, true);

    result->appendData(encodedData.data(), encodedData.size());

    result->setIdentifier(generateFormDataIdentifier());

    return result;

}

bool HTMLFormElement::isMailtoForm() const

{

    return protocolIs(m_url, "mailto");

}

bool HTMLFormElement::prepareSubmit(Event* event)

{

    Frame* frame = document()->frame();

    if (m_insubmit || !frame)

        return m_insubmit;

    m_insubmit = true;

    m_doingsubmit = false;

    if (dispatchEvent(Event::create(eventNames().submitEvent, true, true)) && !m_doingsubmit)

        m_doingsubmit = true;

    m_insubmit = false;

    if (m_doingsubmit)

        submit(event, true);

    return m_doingsubmit;

}

static void transferMailtoPostFormDataToURL(RefPtr<FormData>& data, KURL& url, const String& encodingType)

{

    String body = data->flattenToString();

    data = FormData::create();

    if (equalIgnoringCase(encodingType, "text/plain")) {

        // Convention seems to be to decode, and s/&/\r\n/. Also, spaces are encoded as %20.

        body = decodeURLEscapeSequences(body.replace('&', "\r\n").replace('+', ' ') + "\r\n");

    }

    Vector<char> bodyData;

    bodyData.append("body=", 5);

    FormDataBuilder::encodeStringAsFormData(bodyData, body.utf8());

    body = String(bodyData.data(), bodyData.size()).replace('+', "%20");

    String query = url.query();

    if (!query.isEmpty())

        query.append('&');

    query.append(body);

    url.setQuery(query);

}

void HTMLFormElement::submit(Event* event, bool activateSubmitButton, bool lockHistory)

{

    FrameView* view = document()->view();

    Frame* frame = document()->frame();

    if (!view || !frame)

        return;

    if (m_insubmit) {

        m_doingsubmit = true;

        return;

    }

    m_insubmit = true;

    HTMLFormControlElement* firstSuccessfulSubmitButton = 0;

    bool needButtonActivation = activateSubmitButton; // do we need to activate a submit button?

    Vector<pair<String, String> > formValues;

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

        HTMLFormControlElement* control = formElements[i];

        if (control->hasLocalName(inputTag)) {

            HTMLInputElement* input = static_cast<HTMLInputElement*>(control);

            if (input->isTextField()) {

                formValues.append(pair<String, String>(input->name(), input->value()));

                if (input->isSearchField())

                    input->addSearchResult();

            }

        }

        if (needButtonActivation) {

            if (control->isActivatedSubmit())

                needButtonActivation = false;

            else if (firstSuccessfulSubmitButton == 0 && control->isSuccessfulSubmitButton())

                firstSuccessfulSubmitButton = control;

        }

    }

    RefPtr<FormState> formState = FormState::create(this, formValues, frame);

    if (needButtonActivation && firstSuccessfulSubmitButton)

        firstSuccessfulSubmitButton->setActivatedSubmit(true);

    if (m_url.isEmpty())

        m_url = document()->url().string();

    if (m_formDataBuilder.isPostMethod()) {

        if (m_formDataBuilder.isMultiPartForm() && isMailtoForm()) {

            setEnctype("application/x-www-form-urlencoded");

            ASSERT(!m_formDataBuilder.isMultiPartForm());

        }

        if (!m_formDataBuilder.isMultiPartForm()) {

            RefPtr<FormData> data = createFormData(CString());

            if (isMailtoForm()) {

                // Convert the form data into a string that we put into the URL.

                KURL url = document()->completeURL(m_url);

                transferMailtoPostFormDataToURL(data, url, m_formDataBuilder.encodingType());

                m_url = url.string();

            }

            frame->loader()->submitForm("POST", m_url, data.release(), m_target, m_formDataBuilder.encodingType(), String(), lockHistory, event, formState.release());

        } else {

            Vector<char> boundary = m_formDataBuilder.generateUniqueBoundaryString();

            frame->loader()->submitForm("POST", m_url, createFormData(boundary.data()), m_target, m_formDataBuilder.encodingType(), boundary.data(), lockHistory, event, formState.release());

        }

    } else {

        m_formDataBuilder.setIsMultiPartForm(false);

        frame->loader()->submitForm("GET", m_url, createFormData(CString()), m_target, String(), String(), lockHistory, event, formState.release());

    }

    if (needButtonActivation && firstSuccessfulSubmitButton)

        firstSuccessfulSubmitButton->setActivatedSubmit(false);

    m_doingsubmit = m_insubmit = false;

}

void HTMLFormElement::reset()

{

    Frame* frame = document()->frame();

    if (m_inreset || !frame)

        return;

    m_inreset = true;

    // ### DOM2 labels this event as not cancelable, however

    // common browsers( sick! ) allow it be cancelled.

    if (!dispatchEvent(Event::create(eventNames().resetEvent, true, true))) {

        m_inreset = false;

        return;

    }

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

        formElements[i]->reset();

    m_inreset = false;

}

void HTMLFormElement::parseMappedAttribute(MappedAttribute* attr)

{

    if (attr->name() == actionAttr)

        m_url = deprecatedParseURL(attr->value());

    else if (attr->name() == targetAttr)

        m_target = attr->value();

    else if (attr->name() == methodAttr)

        m_formDataBuilder.parseMethodType(attr->value());

    else if (attr->name() == enctypeAttr)

        m_formDataBuilder.parseEncodingType(attr->value());

    else if (attr->name() == accept_charsetAttr)

        // space separated list of charsets the server

        // accepts - see rfc2045

        m_formDataBuilder.setAcceptCharset(attr->value());

    else if (attr->name() == acceptAttr) {

        // ignore this one for the moment...

    } else if (attr->name() == autocompleteAttr) {

        m_autocomplete = !equalIgnoringCase(attr->value(), "off");

        if (!m_autocomplete)

            document()->registerForDocumentActivationCallbacks(this);    

        else

            document()->unregisterForDocumentActivationCallbacks(this);

    } else if (attr->name() == onsubmitAttr)

        setAttributeEventListener(eventNames().submitEvent, createAttributeEventListener(this, attr));

    else if (attr->name() == onresetAttr)

        setAttributeEventListener(eventNames().resetEvent, createAttributeEventListener(this, attr));

    else if (attr->name() == nameAttr) {

        const AtomicString& newName = attr->value();

        if (inDocument() && document()->isHTMLDocument()) {

            HTMLDocument* document = static_cast<HTMLDocument*>(this->document());

            document->removeNamedItem(m_name);

            document->addNamedItem(newName);

        }

        m_name = newName;

    } else

        HTMLElement::parseMappedAttribute(attr);

}

template<class T, size_t n> static void removeFromVector(Vector<T*, n> & vec, T* item)

{

    size_t size = vec.size();

    for (size_t i = 0; i != size; ++i)

        if (vec[i] == item) {

            vec.remove(i);

            break;

        }

}

unsigned HTMLFormElement::formElementIndex(HTMLFormControlElement* e)

{

    // Check for the special case where this element is the very last thing in

    // the form's tree of children; we don't want to walk the entire tree in that

    // common case that occurs during parsing; instead we'll just return a value

    // that says "add this form element to the end of the array".

    if (e->traverseNextNode(this)) {

        unsigned i = 0;

        for (Node* node = this; node; node = node->traverseNextNode(this)) {

            if (node == e)

                return i;

            if (node->isHTMLElement()

                    && static_cast<Element*>(node)->isFormControlElement()

                    && static_cast<HTMLFormControlElement*>(node)->form() == this)

                ++i;

        }

    }

    return formElements.size();

}

void HTMLFormElement::registerFormElement(HTMLFormControlElement* e)

{

    document()->checkedRadioButtons().removeButton(e);

    m_checkedRadioButtons.addButton(e);

    formElements.insert(formElementIndex(e), e);

}

void HTMLFormElement::removeFormElement(HTMLFormControlElement* e)

{

    m_checkedRadioButtons.removeButton(e);

    removeFromVector(formElements, e);

}

bool HTMLFormElement::isURLAttribute(Attribute* attr) const

{

    return attr->name() == actionAttr;

}

void HTMLFormElement::registerImgElement(HTMLImageElement* e)

{

    imgElements.append(e);

}

void HTMLFormElement::removeImgElement(HTMLImageElement* e)

{

    removeFromVector(imgElements, e);

}

PassRefPtr<HTMLCollection> HTMLFormElement::elements()