#include "WedgeNetwork.h"
#include <QByteArray>
#include <QDebug>
#include <QJsonDocument>
#include <QJsonObject>
#include "WedgeConfig.h"

NetworkManager::NetworkManager(QObject *parent)
    : QObject(parent), socket(nullptr), server(nullptr), m_connected(false),
      currentRole(Role::Client), m_adbForwarded(false), m_peerLastModified(0) {}

NetworkManager::~NetworkManager() {
    disconnectFromPeer();
}

void NetworkManager::startConnection(Route route, Role role) {
    if (socket) {
        socket->disconnect(this);
        socket->abort();
        socket->deleteLater();
        socket = nullptr;
    }

    currentRole = role;

    if (currentRole == Role::Client) {
        if (route == Route::USB) { runAdbForward(); }
        setupClient(route);
    } else {
        setupServer();
    }
}

void NetworkManager::runAdbForward() {
    emit statusChanged("ADB Tunnel", false);
    QString portStr = QString("tcp:%1").arg(PORT); 
    QProcess::execute("adb", QStringList() << "forward" << portStr << portStr);
    m_adbForwarded = true;
}

void NetworkManager::teardownAdb() {
    if (!m_adbForwarded) return;
    m_adbForwarded = false;
    QProcess::execute("adb", QStringList() << "forward" << "--remove-all");
    QProcess::execute("adb", QStringList() << "kill-server");
}

void NetworkManager::setupClient(Route route) {
    socket = new QTcpSocket(this);

    connect(socket, &QTcpSocket::connected, this, &NetworkManager::handleConnected);
    connect(socket, &QTcpSocket::disconnected, this, &NetworkManager::handleDisconnected);
    connect(socket, &QTcpSocket::readyRead, this, &NetworkManager::handleReadyRead);
    
    connect(socket, &QTcpSocket::errorOccurred,
            this, &NetworkManager::handleSocketError);

    emit statusChanged("Connecting", false);
    
    QString targetHost = (route == Route::USB) ? "127.0.0.1" : ConfigManager::loadNote().ipAddress;
    socket->connectToHost(targetHost, PORT);
}

void NetworkManager::setupServer() {
    server = new QTcpServer(this);
    connect(server, &QTcpServer::newConnection, this, &NetworkManager::handleNewConnection);

    if (!server->listen(QHostAddress::Any, PORT)) {
        emit statusChanged("Failed", false);
    } else {
        emit statusChanged("Listening", false);
    }
}

void NetworkManager::handleNewConnection() {
    if (!server) return;
    
    socket = server->nextPendingConnection();
    server->close(); 

    connect(socket, &QTcpSocket::disconnected, this, &NetworkManager::handleDisconnected);
    connect(socket, &QTcpSocket::readyRead, this, &NetworkManager::handleReadyRead);

    handleConnected();
}

void NetworkManager::handleConnected() {
    m_connected = true;
    emit statusChanged("Connected", true);
    sendMeta();
}

void NetworkManager::handleDisconnected() {
    m_connected = false;
    emit statusChanged("Disconnected", false);
    
    if (socket) {
        socket->disconnect();
        socket->deleteLater();
        socket = nullptr;
    }
    if (server) {
        server->close();
        server->deleteLater();
        server = nullptr;
    }
    teardownAdb();
}

void NetworkManager::handleSocketError(QAbstractSocket::SocketError) {
    if (socket) {
        emit statusChanged(socket->errorString(), false);
        handleDisconnected();
    }
}

void NetworkManager::handleReadyRead() {
    if (!socket) return;

    while (socket->canReadLine()) {
        QByteArray line = socket->readLine().trimmed();
        if (!line.isEmpty()) {
            QByteArray decodedBytes = QByteArray::fromBase64(line);
            QJsonDocument doc = QJsonDocument::fromJson(decodedBytes);
            
            if (doc.isObject()) {
                QJsonObject json = doc.object();
                QString receivedKey = json["key"].toString();

                QString localKey = ConfigManager::loadNote().passKey;
                if (receivedKey != localKey) {
                    qDebug() << "Key Fail";
                    emit statusChanged("Pass Key Incorrect", false);
                    return;
                }

                const QString type = json.contains("type") ? json["type"].toString() : "data";
                if (type == "meta") {
                    m_peerLastModified = json["date"].toVariant().toLongLong();
                    emit statusChanged("Connected", true);
                } else {
                    m_peerLastModified = json["date"].toVariant().toLongLong();
                    QString cleanMessage = json["data"].toString();
                    emit contentReceived(cleanMessage);
                    emit statusChanged("Received", true);
                }
            }
        }
    }
}

void NetworkManager::sendNoteContent(const QString &content, const QString &passKey, qint64 lastModified) {
    if (!m_connected || !socket) return;

    QJsonObject json;
    json["type"] = "data";
    json["key"] = passKey;
    json["date"] = lastModified;
    json["data"] = content;

    QByteArray encodedPayload = QJsonDocument(json).toJson(QJsonDocument::Compact).toBase64();
    encodedPayload.append('\n');
    if (socket->write(encodedPayload) != -1) {
        socket->flush();
        m_peerLastModified = lastModified;
        emit statusChanged("Sent", true);
    }
}

bool NetworkManager::isConnected() const {
    return m_connected;
}

qint64 NetworkManager::peerLastModified() const {
    return m_peerLastModified;
}

void NetworkManager::sendMeta() {
    if (!socket) return;
    NoteData local = ConfigManager::loadNote();
    QJsonObject json;
    json["type"] = "meta";
    json["key"] = local.passKey;
    json["date"] = local.lastModified;
    QByteArray payload = QJsonDocument(json).toJson(QJsonDocument::Compact).toBase64();
    payload.append('\n');
    if (socket->write(payload) != -1) {
        socket->flush();
    }
}

void NetworkManager::disconnectFromPeer() {
    if (socket && socket->state() != QAbstractSocket::UnconnectedState) {
        socket->abort(); 
    } else {
        handleDisconnected();
    }
    teardownAdb();
}