qi3pc.h

/* \author Hantz Vius
 *
 * \copyright Copyright (C) 2019-2025 Hantz Vius
 *
 * \license{
 * This file is part of qi3pc.
 *
 * qi3pc is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.}
*/
 
 
 
#ifndef QI3PC_H
#define QI3PC_H
 
#include "qi3pc_global.h"
#include <QtNetwork/qlocalsocket.h>
#include <QDebug>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QMutexLocker>
#include <QProcessEnvironment>
#include <QTime>
 
#include <i3/ipc.h>
 
#include <optional>
#include <string>
#include <QLoggingCategory>
 
Q_DECLARE_LOGGING_CATEGORY(Qi3pcLogger);
class QI3PCSHARED_EXPORT qi3pc : public QObject
{
  Q_OBJECT
 
public:
  static constexpr auto IpcMagicString = std::string("i3-ipc"); 
  static constexpr auto IpcMagicLength = IpcMagicString.length(); 

  enum class IpcEvent : quint32
  {
    Workspace = I3_IPC_EVENT_WORKSPACE,
    Output = I3_IPC_EVENT_OUTPUT,
    Mode = I3_IPC_EVENT_MODE,
    Window = I3_IPC_EVENT_WINDOW,
    BarUpdate = I3_IPC_EVENT_BARCONFIG_UPDATE,
    Binding = I3_IPC_EVENT_BINDING,
    Shutdown = I3_IPC_EVENT_SHUTDOWN,
    Tick = I3_IPC_EVENT_TICK
  };

  enum class IpcType : quint32
  {
    Command = I3_IPC_REPLY_TYPE_COMMAND, 
    Workspaces = I3_IPC_REPLY_TYPE_WORKSPACES, 
    Subscribe = I3_IPC_REPLY_TYPE_SUBSCRIBE, 
    Outputs = I3_IPC_REPLY_TYPE_OUTPUTS, 
    Tree = I3_IPC_REPLY_TYPE_TREE, 
    Marks = I3_IPC_REPLY_TYPE_MARKS, 
    BarConfig = I3_IPC_REPLY_TYPE_BAR_CONFIG, 
    Version = I3_IPC_REPLY_TYPE_VERSION, 
    BindingModes = I3_IPC_REPLY_TYPE_BINDING_MODES, 
    Config = I3_IPC_REPLY_TYPE_CONFIG, 
    Tick = I3_IPC_REPLY_TYPE_TICK, 
    Sync = I3_IPC_REPLY_TYPE_SYNC, 
    BindingState = I3_IPC_REPLY_TYPE_GET_BINDING_STATE 
  };

  enum class WorkspaceChange
  {
    Empty,    
    Focus,    
    Init,     
    Move,     
    Reload,   
    Rename,   
    Restored, 
    Urgent,   
    Unknown   
  };

  enum class OutputChange
  {
    Unspecified, 
    Unknown      
  };

  enum class WindowChange
  {
    New,        
    Close,      
    Focus,      
    Title,      
    Fullscreen, 
    Move,       
    Floating,   
    Urgent,     
    Mark,       
    Unknown     
  };

  enum class ShutdownChange
  {
    Restart, 
    Exit,    
    Unknown  
  };

  enum class BindingChange
  {
    Run,    
    Unknown 
  };

  using DataObject = std::optional<std::pair<QJsonObject, qint64>>;

  using DataArray = std::optional<std::pair<QJsonArray, qint64>>;

  using DataString = std::optional<std::pair<QString, qint64>>;

  struct ParseError {
    QString error;

    QString input;

    QString errorPosition;

    QString toString() const;

    bool operator==(const ParseError& other) const;

    static std::optional<ParseError> FromJSON(const QJsonObject& json);
 
  private:
    using QStringMemberPtr = QString ParseError::*;

    inline static constexpr auto _MEMBERS = std::to_array<std::pair<const char*, QStringMemberPtr>>
    ({
       {"error", &ParseError::error},
       {"input", &ParseError::input},
       {"errorposition", &ParseError::errorPosition}
     });
  };

  using Error = std::optional<ParseError>;

  using CommandResults = std::vector<std::pair<bool, Error>>;

  using Message = std::optional<std::pair<QJsonDocument, quint32>>;

  explicit qi3pc(QObject* parent = nullptr);

  explicit qi3pc(const QString& socketPath, QObject* parent = nullptr);

  virtual ~qi3pc();

  bool connect(int msecs = 1500);

  bool isConnected();

  bool disconnect(int msecs = 1500);

  void subscribe(const QStringList& events);

  static QString FindSocketPath();

  static QString FindSocketPathFromI3Binary();

  QString socketPath() const;

  template<IpcType Type>
  void sendMessage(const QByteArray& payload = QByteArray()) {
    if constexpr(Type == IpcType::Subscribe || Type == IpcType::Tick) {
      WritePayload(m_eventSocket, payload, Type);
      if constexpr(Type == IpcType::Subscribe) {
          m_eventSocket.flush();
      }
    } else {
      WritePayload(m_messageSocket, payload, Type);
    }
  }

  const DataArray& workspaces() const;

  const DataObject& tree() const;

  const DataArray& outputs() const;

  const DataArray& marks() const;

  const DataObject& barConfigs() const;

  const DataObject& version() const;

  const DataArray& bindingModes() const;

  const DataObject& config() const;

  const DataString& bindingState() const;
 
public slots:
  void fetchWorkspaces();

  void fetchTree();

  void fetchOutputs();

  void fetchMarks();

  void fetchBarConfig(const QString& id);

  void fetchBarConfigs();

  void fetchVersion();

  void fetchBindingModes();

  void fetchConfig();

  void fetchBindingState();
 
private:
  Message processMessage(QLocalSocket& socket);

  void processEvent();

  void processReply();

  void processWorkspaceEvent(const QJsonDocument& doc);

  void processOutputEvent(const QJsonDocument& doc);

  void processModeEvent(const QJsonDocument& doc);

  void processWindowEvent(const QJsonDocument& doc);

  void processBarUpdateEvent(const QJsonDocument& doc);

  void processBindingEvent(const QJsonDocument& doc);

  void processShutdownEvent(const QJsonDocument& doc);

  void processTickEvent(const QJsonDocument& doc);

  void processCommandReply(const QJsonDocument& doc);

  void processWorkspaceReply(const QJsonDocument& doc);

  void processOutputReply(const QJsonDocument& doc);

  void processTreeReply(const QJsonDocument& doc);

  void processMarkReply(const QJsonDocument& doc);

  void processBarConfigReply(const QJsonDocument& doc);

  void processVersionReply(const QJsonDocument& doc);

  void processBindingModesReply(const QJsonDocument& doc);

  void processConfigReply(const QJsonDocument& doc);

  void processTickReply(const QJsonDocument& doc);

  void processSyncReply(const QJsonDocument& doc);

  void processBindingStateReply(const QJsonDocument& doc);

  static WorkspaceChange WorkspaceChangeFromString(const QString& s);

  static WindowChange WindowChangeFromString(const QString& s);

  static ShutdownChange ShutdownChangeFromString(const QString& s);

  static OutputChange OutputChangeFromString(const QString& s);

  static BindingChange BindingChangeFromString(const QString& s);

  static void WritePayload(QLocalSocket& socket, const QByteArray& payload, IpcType type);
 
private:
  QString m_socketPath; 
 
  QLocalSocket m_eventSocket; 
  QLocalSocket m_messageSocket; 
 
  DataObject m_tree;       
  DataArray m_workspaces;  
  DataArray m_outputs;     
  DataArray m_marks;       
  DataObject m_barConfigs; 
  DataObject m_version;    
  DataArray m_bindingModes; 
  DataString m_bindingState; 
  DataObject m_config;     
 
signals:
  void commandRan(qi3pc::CommandResults result);

  void tickSent(bool success);

  void synced(bool success);

  void subscribed(bool success);

  void workspaceEvent(qi3pc::WorkspaceChange change,
                      const QJsonObject& current,
                      const QJsonObject& old);
  void outputEvent(qi3pc::OutputChange change);

  void modeEvent(QString change, bool pango);

  void windowEvent(qi3pc::WindowChange change, const QJsonObject& container);

  void barUpdateEvent(const QJsonObject& doc);

  void bindingEvent(qi3pc::BindingChange change, const QJsonObject& binding, const QString& mode);

  void shutdownEvent(qi3pc::ShutdownChange change);

  void tickEvent(const QString& payload);

  void workspacesUpdated(const qi3pc::DataArray& workspaces);

  void treeUpdated(const qi3pc::DataObject& tree);

  void outputsUpdated(const qi3pc::DataArray& outputs);

  void marksUpdated(const qi3pc::DataArray& marks);

  void barConfigUpdated(const QJsonObject& config);

  void newBarConfig(const QString& id);

  void versionUpdated(const qi3pc::DataObject& version);

  void bindingModesUpdated(const qi3pc::DataArray& modes);

  void configUpdated(const qi3pc::DataObject& config);

  void bindingStateUpdated(const qi3pc::DataString& state);
};
 
#endif // QI3PC_H