/*
*  This file is part of openauto project.
*  Copyright (C) 2018 f1x.studio (Michal Szwaj)
*
*  openauto is free software: you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 3 of the License, or
*  (at your option) any later version.

*  openauto 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with openauto. If not, see <http://www.gnu.org/licenses/>.
*/

#include <QApplication>
#include <QtWebSockets/QWebSocket>
#include <QDBusInterface>
#include <QDBusConnection>
#include <QDBusReply>
#include <QDBusMessage>
#include <QDebug>

#include "autoapp/UI/MainWindow.hpp"
#include "ui_mainwindow.h"

namespace autoapp
{
    namespace ui
    {
        MainWindow::MainWindow(QWidget *parent)
            : QMainWindow(parent), ui_(new Ui::MainWindow), webSocket(new QWebSocket),
              reconnectTimer(new QTimer(this)),
              metadataTimer(new QTimer(this)),
              shuttingDown(false)
        {
            ui_->setupUi(this);
            connect(ui_->pushButtonSettings, &QPushButton::clicked, this, &MainWindow::openSettings);
            connect(ui_->pushButtonExit, &QPushButton::clicked, this, &MainWindow::exit);
            connect(ui_->pushButtonToggleCursor, &QPushButton::clicked, this, &MainWindow::toggleCursor);
            connect(ui_->pushButtonWirelessConnection, &QPushButton::clicked, this, &MainWindow::openConnectDialog);

            // BT NOW PLAYING UPDATE
            connect(metadataTimer, &QTimer::timeout, this, &MainWindow::updateNowPlaying);
            metadataTimer->start(1000); // refresh every 5 seconds

            // RADIO WEBSOCKET STUFF
            reconnectTimer->setSingleShot(true);
            reconnectTimer->setInterval(3000);

            connect(reconnectTimer, &QTimer::timeout, this, &MainWindow::connectWebSocket);

            connect(webSocket, &QWebSocket::connected, this, [this]()
                    {
                            qDebug() << "WebSocket connected";
                            webSocket->sendTextMessage(QStringLiteral("Hello from MainWindow WebSocket!")); });

            connect(webSocket, &QWebSocket::textMessageReceived, this, [this](const QString &message)
                    {
                            qDebug() << "Message received:" << message;
                            handleIncomingMessage(message); });

            connect(webSocket, &QWebSocket::disconnected, this, [this]()
                    {
                            qDebug() << "WebSocket disconnected";
                            if (!shuttingDown) {
                                qDebug() << "Attempting to reconnect in 3 seconds...";
                                reconnectTimer->start();
                            } });

            connect(webSocket, QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error),
                    this, [this](QAbstractSocket::SocketError)
                    { qDebug() << "WebSocket error:" << webSocket->errorString(); });

            connectWebSocket();
        }

        MainWindow::~MainWindow()
        {
            shuttingDown = true;
            webSocket->abort();
            webSocket->deleteLater();
            delete ui_;
        }

    }
}

void autoapp::UI::MainWindow::updateBtNowPlaying()
{
    QDBusInterface manager(
        "org.bluez",
        "/",
        "org.freedesktop.DBus.ObjectManager",
        QDBusConnection::systemBus());

    if (!manager.isValid())
    {
        qDebug() << "Failed to connect to BlueZ D-Bus";
        return;
    }

    QDBusReply<QVariantMap> reply = manager.call("GetManagedObjects");

    if (!reply.isValid())
    {
        qDebug() << "D-Bus call failed:" << reply.error().message();
        return;
    }

    QVariantMap allObjects = reply.value();

    for (auto it = allObjects.begin(); it != allObjects.end(); ++it)
    {
        QString path = it.key();
        QVariantMap interfaces = it.value().toMap();

        if (interfaces.contains("org.bluez.MediaPlayer1"))
        {
            qDebug() << "Found MediaPlayer at:" << path;

            QDBusInterface mediaPlayer(
                "org.bluez",
                path,
                "org.freedesktop.DBus.Properties",
                QDBusConnection::systemBus());

            QDBusReply<QVariant> trackReply = mediaPlayer.call("Get", "org.bluez.MediaPlayer1", "Track");
            if (trackReply.isValid())
            {
                QVariantMap track = trackReply.value().toMap();
                QString artist = track["Artist"].toString();
                QString title = track["Title"].toString();
                QString album = track["Album"].toString();

                QString status = statusReply.value().toString();

                qDebug() << "Now playing:" << artist << "-" << title << "from" << album;
                qDebug() << "Status:" << status;

                if (status == "Playing")
                {
                    //ui_->stackedWidget->setCurrentIndex(0);
                    //ui_->btSongName->setText(title);
                    //ui_->btArtistName->setText(artist);
                    //ui_->btAlbumName->setText(album);
                }
                else
                {
                    //ui_->stackedWidget->setCurrentIndex(1);
                }
            }
            break;
        }
    }
}

void autoapp::UI::MainWindow::connectWebSocket()
{
    QUrl url(QStringLiteral("ws://127.0.0.1:5000")); // Change to your real server
    qDebug() << "Connecting to WebSocket:" << url;
    webSocket->open(url);
}

void autoapp::UI::MainWindow::handleIncomingMessage(const QString &message)
{
    // Your custom message processing logic here
    qDebug() << "[Handler] Processing message:" << message;
}