#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),
      adbTracker(nullptr), m_metaSeen(false), m_syncPending(false), m_adbForwarded(false),
      m_autoMerge(ConfigManager::loadNote().autoMerge), m_peerAutoMerge(false),
      m_peerLastModified(0) {
    dialTimer = new QTimer(this);
    dialTimer->setSingleShot(true);
    dialTimer->setInterval(5000);
    connect(dialTimer, &QTimer::timeout, this, &NetworkManager::handleDialTimeout);

    idleTimer = new QTimer(this);
    idleTimer->setSingleShot(true);
    idleTimer->setInterval(3000);
    connect(idleTimer, &QTimer::timeout, this, &NetworkManager::handleIdleTimeout);
}

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

void NetworkManager::startListener() {
    if (server) return;
    server = new QTcpServer(this);
    connect(server, &QTcpServer::newConnection, this, &NetworkManager::handleNewConnection);
    server->listen(QHostAddress::Any, PORT_HOST);
    startAdbTracker();
}

// adb tunnel on connect
void NetworkManager::startAdbTracker() {
    adbTracker = new QProcess(this);
    connect(adbTracker, &QProcess::readyReadStandardOutput,
            this, &NetworkManager::handleAdbTrackerOutput);
    connect(adbTracker, &QProcess::finished, this, [this]() {
        QTimer::singleShot(2000, this, [this]() {
            adbTracker->start("adb", QStringList() << "track-devices");
        });
    });
    adbTracker->start("adb", QStringList() << "track-devices");
}

void NetworkManager::handleAdbTrackerOutput() {
    const QString chunk = QString::fromUtf8(adbTracker->readAllStandardOutput());
    const bool devicePresent = chunk.contains("\tdevice");
    if (devicePresent && !m_adbForwarded) {
        runAdbTunnels();
        emit statusChanged("Idle", false);
        if (m_autoMerge && !m_connected &&
            ConfigManager::loadNote().networkRoute == 0) { dial(Route::USB); }
    } else if (!devicePresent) {
        m_adbForwarded = false;
    }
}

void NetworkManager::requestSync(Route route) {
    if (m_metaSeen && socket && socket->state() == QAbstractSocket::ConnectedState) {
        emit linkReady();
        return;
    }
    m_syncPending = true;
    if (route == Route::USB && !m_adbForwarded) { runAdbTunnels(); }
    dial(route);
}

void NetworkManager::runAdbTunnels() {
    emit statusChanged("ADB Tunnel", false);
    QString phonePort = QString("tcp:%1").arg(PORT_PHONE);
    QString hostPort = QString("tcp:%1").arg(PORT_HOST);
    QProcess::execute("adb", QStringList() << "forward" << phonePort << phonePort);
    QProcess::execute("adb", QStringList() << "reverse" << hostPort << hostPort);
    m_adbForwarded = true;
}

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

void NetworkManager::dial(Route route) {
    if (socket) {
        socket->disconnect(this);
        socket->abort();
        socket->deleteLater();
        socket = nullptr;
    }
    m_metaSeen = false;

    socket = new QTcpSocket(this);
    attachSocket(socket);

    emit statusChanged("Connecting", false);

    dialTimer->start();
    
    QString targetHost = (route == Route::USB) ? "127.0.0.1" : ConfigManager::loadNote().ipAddress;
    socket->connectToHost(targetHost, PORT_PHONE);
}

void NetworkManager::attachSocket(QTcpSocket *s) {
    connect(s, &QTcpSocket::connected, this, &NetworkManager::handleConnected);
    connect(s, &QTcpSocket::disconnected, this, &NetworkManager::handleDisconnected);
    connect(s, &QTcpSocket::readyRead, this, &NetworkManager::handleReadyRead);
    connect(s, &QTcpSocket::errorOccurred, this, &NetworkManager::handleSocketError);
}

void NetworkManager::handleNewConnection() {
    if (!server) return;
    
    QTcpSocket *incoming = server->nextPendingConnection();
    if (socket) { incoming->abort(); incoming->deleteLater(); return; }

    socket = incoming;
    m_metaSeen = false;
    attachSocket(socket);

    handleConnected();
}

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

void NetworkManager::handleDisconnected() {
    m_connected = false;
    m_metaSeen = false;
    m_syncPending = false;
    m_peerAutoMerge = false;
    dialTimer->stop();
    idleTimer->stop();
    emit statusChanged("Idle", false);
    
    if (socket) {
        socket->disconnect();
        socket->deleteLater();
        socket = nullptr;
    }
}

void NetworkManager::handleDialTimeout() {
    if (m_metaSeen) return;
    if (socket && socket->state() != QAbstractSocket::UnconnectedState) {
        socket->abort();
    }
    handleDisconnected();
    emit statusChanged("No Peer", false);
}

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);
                    socket->abort();
                    return;
                }

                const QString type = json.contains("type") ? json["type"].toString() : "data";
                if (type == "meta") {
                    m_peerLastModified = json["date"].toVariant().toLongLong();
                    m_peerAutoMerge = json["auto"].toBool();
                    emit statusChanged("Connected", true);
                    m_metaSeen = true;
                    dialTimer->stop();
                    if (m_syncPending) { m_syncPending = false; emit linkReady(); }
                    if (autoMergeReady()) emit autoSyncDue();
                } else {
                    m_peerLastModified = json["date"].toVariant().toLongLong();
                    m_peerAutoMerge = json["auto"].toBool();
                    QString cleanMessage = json["data"].toString();
                    emit contentReceived(cleanMessage);
                    emit statusChanged("Received", true);
                    m_metaSeen = true;
                    dialTimer->stop();
                    if (m_syncPending) { m_syncPending = false; emit linkReady(); }
                    noteActivity();
                }
            }
        }
    }
}

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["auto"] = m_autoMerge;
    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;
    json["auto"] = m_autoMerge;
    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();
    }
}

bool NetworkManager::autoMergeReady() const {
    return m_connected && m_autoMerge && m_peerAutoMerge;
}

void NetworkManager::setAutoMerge(bool on) {
    if (m_autoMerge == on) return;
    m_autoMerge = on;
    if (m_connected) sendMeta();
    if (autoMergeReady()) emit autoSyncDue();
    else idleTimer->stop();
}

void NetworkManager::noteActivity() {
    if (!autoMergeReady()) { idleTimer->stop(); return; }
    idleTimer->start();
}

void NetworkManager::handleIdleTimeout() {
    if (autoMergeReady()) emit autoSyncDue();
}