/*
 * Copyright (C) 2019 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "config.h"
#include "UserAgentStringParser.h"

#include "RFC7230.h"
#include "UserAgentStringData.h"
#include <optional>
#include <wtf/ASCIICType.h>
#include <wtf/StdLibExtras.h>
#include <wtf/WeakPtr.h>
#include <wtf/text/MakeString.h>
#include <wtf/text/StringCommon.h>
#include <wtf/text/StringImpl.h>
#include <wtf/text/WTFString.h>

/*
 * GRAMMAR:
 * https://www.rfc-editor.org/rfc/rfc9110#name-user-agent
 * User-Agent      = product *( RWS ( product / comment ) )
 * product         = token ["/" product-version]
 * product-version = token
 * token           = 1*tchar
 * tchar           = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA ; any VCHAR, except delimiters
 * RWS             = 1*( SP / HTAB ); required whitespace
 * comment         = "(" *( ctext / quoted-pair / comment ) ")"
 * ctext           = HTAB / SP / %x21-27 / %x2A-5B / %x5D-7E / obs-text
 * quoted-pair     = "\" ( HTAB / SP / VCHAR / obs-text )
 * obs-text        = %x80-FF
 * HTAB            = <ASCII horizontal tab %x09, aka '\t'>
 * SP              = <ASCII space, i.e. " ">
 * VCHAR           = <any visible US-ASCII character>
 *
 * REFERENCE:
 * https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#syntax
 *
 * NOTE:
 * User agent strings come in many different forms, but most browsers conform to a common pattern.
 * This class is attempting to determine attributes about the user agent by expecting common forms
 * of user agent strings. There is a link below that contains a list of of these strings grouped
 * by platform, browser, layout engine, etc. I tried to pick the most frequent ones to parse out
 * viable information.
 *
 * https://explore.whatismybrowser.com/useragents/explore/
 *
 * Some user agent strings, while valid grammatically, list their info in odd locations.
 * This parser will not be able to pick out the correct information from those.
 */

namespace WebCore {
UserAgentStringParser::UserAgentStringParser(const String& userAgentString)
    : m_userAgentString(userAgentString)
    , data(UserAgentStringData::create()) { };

Ref<UserAgentStringParser> UserAgentStringParser::create(const String& userAgentString)
{
    return adoptRef(*new UserAgentStringParser(userAgentString));
}

std::optional<Ref<UserAgentStringData>> UserAgentStringParser::parse()
{
    data = UserAgentStringData::create();

    if (atEnd())
        return { };

    consumeProduct();

    while (!atEnd()) {
        if (!isTabOrSpace(peek()))
            return { };

        consumeRWS();
        start = pos;
        if (peek() == '(')
            consumeComment();
        else
            consumeProduct();

        if (malformed)
            return { };
    }

    populateUserAgentData();
    return data;
}

void UserAgentStringParser::consumeProduct()
{
    consumeToken();
    if (malformed)
        return;

    auto product = Product { .name = getSubstring(), .version = { } };
    if (!atEnd() && peek() == '/') {
        increment();
        start = pos;
        consumeToken();
        if (malformed)
            return;
        product.version = getSubstring();
    }
    start = pos;
    segments.append(product);
}

void UserAgentStringParser::consumeRWS()
{
    while (!atEnd() && isTabOrSpace(peek()))
        increment();
}

void UserAgentStringParser::consumeComment()
{
    ASSERT(peek() == '(');
    increment(); // pass first '('
    start = pos;

    if (atEnd()) {
        malformed = true;
        return;
    }

    auto c = peek();
    while (!atEnd() && c != ')') {
        if (c == '(')
            consumeComment();
        else if (c == '\\')
            consumeQuotedPair();
        else if (RFC7230::isCommentText(c))
            increment();

        if (malformed)
            return;

        c = peek();
    }

    if (atEnd()) {
        malformed = true;
        return;
    }

    auto s = getSubstring();
    if (!s.isEmpty()) {
        auto comment = Comment { .parts = s.split(';') };
        segments.append(comment);
    }
    increment();
    start = pos;
    // malformed user agent string
}

void UserAgentStringParser::consumeToken()
{
    if (!RFC7230::isTokenCharacter(peek())) {
        malformed = true;
        return;
    }

    do {
        increment();
    } while (!atEnd() && RFC7230::isTokenCharacter(peek()));
}

void UserAgentStringParser::consumeQuotedPair()
{
    ASSERT(peek() == '\\');
    increment(); // pass '\'

    if (RFC7230::isQuotedPairSecondOctet(peek())) {
        increment();
        return;
    }

    malformed = true;
}

inline char16_t UserAgentStringParser::peek()
{
    return m_userAgentString[this->pos];
}

inline void UserAgentStringParser::increment()
{
    this->pos++;
}

inline bool UserAgentStringParser::atEnd()
{
    return this->pos >= this->m_userAgentString.length();
}

inline String UserAgentStringParser::getSubstring()
{
    return m_userAgentString.substring(start, pos - start);
}

struct BrowsersSeen {
    bool brave : 1 { false };
    bool firefox : 1 { false };
    bool chrome : 1 { false };
    bool safari : 1 { false };
    bool opera : 1 { false };
    bool edge : 1 { false };
    String braveVersion;
    String firefoxVersion;
    String chromeVersion;
    String safariVersion;
    String operaVersion;
    String edgeVersion;
};

void UserAgentStringParser::populateUserAgentData()
{
    BrowsersSeen browsersSeen;
    auto weakThis = WeakPtr { *this };
    bool linuxSeen { false };
    for (const auto& segment : segments) {
        WTF::switchOn(segment, [&browsersSeen, weakThis](const Product& p) {
            if (p.name == "Mobile") {
                weakThis->data->mobile = true;
                return;
            }
            if (p.name == "Brave") {
                browsersSeen.braveVersion = p.version;
                browsersSeen.brave = true;
                return;
            }
            if (p.name == "Firefox" || p.name == "fxiOS") {
                browsersSeen.firefoxVersion = p.version;
                browsersSeen.firefox = true;
                return;
            }
            if (p.name == "Chrome") {
                browsersSeen.chromeVersion = p.version;
                browsersSeen.chrome = true;
                return;
            }
            if (p.name == "Safari") {
                browsersSeen.firefoxVersion = p.version;
                browsersSeen.safari = true;
                return;
            }
            if (p.name == "OPR") {
                browsersSeen.operaVersion = p.version;
                browsersSeen.opera = true;
                return;
            }
            if (p.name.contains("Edg")) {
                browsersSeen.edgeVersion = p.version;
                browsersSeen.edge = true;
                return;
            } }, [weakThis, &linuxSeen](const Comment& c) {
            for (const auto& part : c.parts) {
                if (part.contains("Windows")) {
                    weakThis->data->platform = "Windows"_s;
                    return;
                }
                if (part == "Macintosh") {
                    weakThis->data->platform = "macOS"_s;
                    return;
                }
                if (part == "iPhone") {
                    weakThis->data->platform = "iOS"_s;
                    return;
                }
                if (part == "iPad") {
                    weakThis->data->platform = "iOS"_s;
                    return;
                }
                if (part.contains("Android")) {
                    weakThis->data->platform = "Android"_s;
                    return;
                }
                if (part.contains("Linux")) {
                    linuxSeen = true;
                    return;
                }
                if (part.contains("CrOS")) {
                    weakThis->data->platform = "ChromeOS"_s;
                    return;
                }
            } });
    }

    // android user agents sometimes list linux and android, but linux user agents don't list androids
    if (linuxSeen && data->platform.isEmpty())
        data->platform = "Linux"_s;

    // both chrome and firefox sometimes list safari in their user agent strings
    if (browsersSeen.safari && !browsersSeen.chrome && !browsersSeen.firefox) {
        data->browserName = "Safari"_s;
        data->browserVersion = browsersSeen.safariVersion;
        return;
    }

    // no other browser typically list firefox
    if (browsersSeen.firefox) {
        data->browserName = "Firefox"_s;
        data->browserVersion = browsersSeen.firefoxVersion;
    }

    // chrome based browsers typically list chrome
    if (browsersSeen.chrome) {
        if (browsersSeen.edge) {
            data->browserName = "Microsoft Edge"_s;
            data->browserVersion = browsersSeen.edgeVersion;
        } else if (browsersSeen.brave) {
            data->browserName = "Brave"_s;
            data->browserVersion = browsersSeen.braveVersion;
        } else if (browsersSeen.opera) {
            data->browserName = "Opera"_s;
            data->browserVersion = browsersSeen.operaVersion;
        } else {
            data->browserName = "Google Chrome"_s;
            data->browserVersion = browsersSeen.chromeVersion;
        }
    }
}
};