#pragma once
#include <QObject>
#include <QThread>
#include <QSerialPort>
#include <QFile>
#include <QTextStream>
#include <QString>
#include <QTimer>

// SerialWorker lives in its own QThread and owns the QSerialPort.
// It emits newLine() for every complete line received,
// tagDetected() when a line contains a recognised tag like [WDG],
// and clearScreen() when the ANSI clear-screen sequence \033[2J is received.
// Auto-reconnect: if the port drops unexpectedly (e.g. USB cable pulled),
// the worker retries every reconnectIntervalMs until success or closePort().
class SerialWorker : public QObject
{
    Q_OBJECT

public:
    explicit SerialWorker(QObject *parent = nullptr);
    ~SerialWorker();

    // Auto-reconnect configuration (call before openPort, or any time)
    void setAutoReconnect(bool enabled)       { m_autoReconnect = enabled; }
    void setReconnectInterval(int ms)         { m_reconnectIntervalMs = ms; }

public slots:
    void openPort(const QString &portName, qint32 baudRate,
                  QSerialPort::DataBits dataBits,
                  QSerialPort::Parity parity,
                  QSerialPort::StopBits stopBits,
                  QSerialPort::FlowControl flowControl);
    void closePort();          // explicit user disconnect – stops reconnect
    void setLogFile(const QString &path);
    void stopLogging();

signals:
    void newLine(const QString &line);
    void tagDetected(const QString &tag, const QString &value);
    void clearScreen();        // emitted when \033[2J\033[H (or \033[2J alone) is received
    void portOpened();
    void portClosed();
    void reconnecting(int attempt);          // fired each retry attempt
    void errorOccurred(const QString &message);

private slots:
    void onReadyRead();
    void onPortError(QSerialPort::SerialPortError err);
    void tryReconnect();

private:
    void processRawData(const QByteArray &data);
    void processLine(const QString &line);
    void scheduleReconnect();

    QSerialPort  *m_port    = nullptr;
    QFile        *m_logFile = nullptr;
    QTextStream  *m_logStream = nullptr;
    QString       m_buffer;

    // Reconnect state
    QTimer       *m_reconnectTimer      = nullptr;
    bool          m_autoReconnect       = true;
    bool          m_userDisconnected    = false;   // true only after explicit closePort()
    int           m_reconnectIntervalMs = 2000;
    int           m_reconnectAttempt    = 0;

    // Saved config for reconnect
    QString                  m_portName;
    qint32                   m_baudRate   = 115200;
    QSerialPort::DataBits    m_dataBits   = QSerialPort::Data8;
    QSerialPort::Parity      m_parity     = QSerialPort::NoParity;
    QSerialPort::StopBits    m_stopBits   = QSerialPort::OneStop;
    QSerialPort::FlowControl m_flowControl= QSerialPort::NoFlowControl;
};