#include "playground.h"

#include <QDebug>
#include <QDomDocument>
#include <QLocale>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QTimer>
#include <QXmlStreamReader>

#include "atomchannel.h"
#include "macros.h"

Playground::Playground()
    : m_networkManager{new QNetworkAccessManager}
{
    connect(m_networkManager, &QNetworkAccessManager::finished, this, &Playground::onReplyFinished);
}

void Playground::fetchUrl(const QUrl &url)
{
    m_networkManager->get(QNetworkRequest{url});
}

void Playground::onReplyFinished(QNetworkReply *reply)
{
    // TODO: check for nullptr

    reply->deleteLater();

    qDebug() << "reply size:" << reply->size();

    parseFeed(reply);
}

std::shared_ptr<AtomChannel> Playground::parseFeed(QIODevice *ioDevice)
{
    if (!ioDevice) {
        qCritical() << "ioDevice is nullptr";
        return {};
    }

    QDomDocument doc;

    if (!doc.setContent(ioDevice)) {
        qCritical() << "cannot set io device to dom doc";

        return {};
    }

    const auto rssTag = QStringLiteral("rss");
    const auto channelTag = QStringLiteral("channel");
    const auto titleTag = QStringLiteral("title");
    const auto linkTag = QStringLiteral("link");
    const auto itemTag = QStringLiteral("item");

    const auto documentElement = doc.documentElement();

    // const auto channelNode = documentElement.elementsByTagName(rssTag).at(0);
    const auto channelNode = documentElement.firstChildElement();
    VERIFY_CRIT_RETURN_VAL(!channelNode.isNull(), {});

    Feed tmpChannel{channelNode};
    qDebug() << tmpChannel;

    tmpChannel.syncWithDb();
    qDebug() << tmpChannel;
    return {};

    const auto itemNodes = channelNode.elementsByTagName(itemTag);

    for (const auto &itemNode : itemNodes) {
        const Item item{itemNode};
        qDebug() << item;
        break;
    }

    return {};

    // const auto channelNode = rssNode.toElement().elementsByTagName(channelTag).at(0);
    // VERIFY_CRIT_RETURN_VAL(!channelNode.isNull(), {});

    const auto childNode = [](const QDomNode &parent, const QString &tag) {
        return parent.toElement().elementsByTagName(tag).at(0);
    };

    const auto childNodeText = [childNode](const QDomNode &parent, const QString &tag) {
        const auto node = childNode(parent, tag);
        VERIFY_RETURN_VAL(!node.isNull(), QString{});
        return node.toElement().text();
    };

    qDebug() << "AZAZA: title:" << childNodeText(channelNode, titleTag);
    qDebug() << "AZAZA: link:" << childNodeText(channelNode, linkTag);

    QDomNode node{channelNode.firstChildElement()};

    while (!node.isNull()) {
        const auto element = node.toElement();

        if (element.isNull()) {
            node = node.nextSibling();

            continue;
        }

        // const auto title = childNodeText(element, titleTag);
        node = node.nextSibling();
        // qDebug() << "AZAZA: title:" << title;
    }

    return {};

    // TODO: check for nullptr
    // TODO: try `QNetworkReply::readyRead` instead of `QNetworkAccessManager::finished`
    std::shared_ptr<AtomChannel> channel{};
    QXmlStreamReader xmlReader{ioDevice};

    while (!xmlReader.atEnd() && !xmlReader.hasError()) {
        const auto next = xmlReader.readNext();

        // qDebug() << "\tnext:" << next;

        switch (next) {
        case QXmlStreamReader::TokenType::NoToken:
            qDebug() << "NoToken";
            break;
        case QXmlStreamReader::TokenType::Invalid:
            qDebug() << "Invalid";
            break;
        case QXmlStreamReader::TokenType::StartDocument:
            // qDebug() << "StartDocument";
            break;
        case QXmlStreamReader::TokenType::EndDocument:
            // qDebug() << "EndDocument";
            break;
        case QXmlStreamReader::TokenType::StartElement: {
            const auto startElementName = xmlReader.name();
            // qDebug() << "StartElement: " << startElementName;

            if (startElementName == AtomChannel::xmlTag) {
                channel = std::make_shared<AtomChannel>(&xmlReader);
                // qDebug() << *channel;
            } /* else if (startElementName == itemTag) {
                const AtomItem item{&xmlReader};
                qDebug() << item;
            }*/

            break;
        }
        case QXmlStreamReader::TokenType::EndElement:
            // qDebug() << "EndElement: " << xmlReader.name();
            break;
        case QXmlStreamReader::TokenType::Characters: {
            const auto characters = xmlReader.text().toString().simplified();

            if (characters.isEmpty())
                break;

            qDebug() << "Characters";
            break;
        }
        case QXmlStreamReader::TokenType::Comment:
            qDebug() << "Comment";
            break;
        case QXmlStreamReader::TokenType::DTD:
            qDebug() << "DTD";
            break;
        case QXmlStreamReader::TokenType::EntityReference:
            qDebug() << "EntityReference";
            break;
        case QXmlStreamReader::TokenType::ProcessingInstruction:
            qDebug() << "ProcessingInstruction";
            break;
        }

        if (xmlReader.hasError()) {
            qWarning() << "xml parsing error:" << xmlReader.errorString();

            return {};
        }
    }

    return channel;
}