#include <wx/app.h>
#include <wx/log.h>
#include <wx/snglinst.h>
#include <wx/ipc.h>
#include <wx/msgdlg.h>
#include <wx/dialog.h>
#include <iostream>
 
#define IPC_TOPIC wxT("myapp")
#define IPC_NAME wxT("myapp.ipc")
 
// Connection class, for use by both communicating instances
class stConnection : public wxConnection
{
    public:
        stConnection(): wxConnection() {}
        ~stConnection() {}
        bool OnExecute(const wxString& topic, wxChar*data, int size, wxIPCFormat format)
        {
            std::cout << "OnExecute" << std::endl;
            wxString filename(data);
            std::cout << "Receive: " << filename << std::endl;
            return true;
        }
 
};
 
// Server class, for listening to connection requests
class stServer: public wxServer
{
    public:
        stServer(): wxServer() {}
        wxConnectionBase *OnAcceptConnection(const wxString& topic)
        {
            std::cout << "OnAcceptConnection" << std::endl;
            if (topic.Lower() == IPC_TOPIC)
            {
                return new stConnection();
            }
 
            return NULL;
        }
};
 
// Client class, to be used by subsequent instances in OnInit
class stClient: public wxClient
{
    public:
        stClient(): wxClient() {};
        wxConnectionBase *OnMakeConnection() { std::cout << "OnMakeConnection" << std::endl; return new stConnection; }
};
 
class MyApp: public wxApp
{
    protected:
        wxSingleInstanceChecker* m_singleInstanceChecker;
        stServer* m_server;
 
    public:
        bool OnInit()
        {
            m_singleInstanceChecker = new wxSingleInstanceChecker(wxT("ipc-test"));
            if (!m_singleInstanceChecker->IsAnotherRunning())
            {
                // Create a new server
                m_server = new stServer;
                if ( !m_server->Create(IPC_NAME) )
                {
                    wxLogDebug(wxT("Failed to create an IPC service."));
                    delete m_singleInstanceChecker;
                    return false;
                }
                else
                {
                    std::cout << "IPC server starting." << std::endl;
                    wxDialog* d = new wxDialog(NULL, wxID_ANY, wxT("Server"));
                    d->Show();
                }
            }
            else
            {
//                wxLogNull logNull;
                stClient* client = new stClient;
                wxConnectionBase* connection = client->MakeConnection(wxEmptyString, IPC_NAME, IPC_TOPIC);
                if (connection)
                {
                    std::cout << "IPC client starting." << std::endl;
                    connection->Execute("test_file.txt");
                    connection->Disconnect();
                    delete connection;
                }
                else
                {
                    wxMessageBox(wxT("Sorry, the existing instance may be too busy too respond.\nPlease close any open dialogs and retry."), wxT("My application"), wxICON_INFORMATION|wxOK);
                }
                delete client;
                delete m_singleInstanceChecker;
                return false;
            }
 
            return true;
        }
 
        int OnExit()
        {
            delete m_singleInstanceChecker;
        }
};
 
IMPLEMENT_APP(MyApp)
 

#define IPC_NAME wxT("myapp.ipc")

#define IPC_NAME wxT("4242")