#ifndef FACT_RemoteControl
#define FACT_RemoteControl

// **************************************************************************
/** @class RemoteControlImp

@brief This implements the basic functions of a remote control via dim

Through a ServiceList object this object subscribes to all available
SERVICE_LISTs  in the dim network. This allows to keep an up-to-date
list of all servers and services. Its ProcessCommand member function
allows to emit commands according to the services found in the network.
Its infoHandler() is called as an update notifier from the ClientList
object.

**/
// **************************************************************************
#include <string>

using namespace std;

class RemoteControlImp
{
protected:
    std::ostream &lout;          /// Output stream for local synchrounous output

    std::string fCurrentServer;  /// The server to which we currently cd'ed

protected:
    // Redirect asynchronous output to the output window
    RemoteControlImp(std::ostream &, std::ostream &in) : lout(in)
    {
    }
    virtual ~RemoteControlImp() { }
    bool ProcessCommand(const std::string &str);

    virtual bool HasServer(const std::string &) { return false; }
    virtual bool SendDimCommand(ostream &, std::string &, const std::string &) { return false; }
};

// **************************************************************************
/** @class RemoteControl

@brief Implements a remote control based on a Readline class for the dim network

This template implements all functions which overwrite any function from the
Readline class. Since several derivatives of the Readline class implement
different kind of Readline access, this class can be derived by any of them
due to its template argument. However, the normal case will be
deriving it from either Console or Shell.

@tparam T
   The base class for RemoteControl. Either Readlien or a class
    deriving from it. This is usually either Console or Shell.

**/
// **************************************************************************
#include "StateMachineDimControl.h"

#include "InterpreterV8.h"
#include "ReadlineColor.h"
#include "Event.h"
#include "tools.h"

template <class T>
class RemoteControl : public T, public RemoteControlImp, public InterpreterV8
{
protected:
    StateMachineDimControl *fImp;

    void SetSection(int s) { if (fImp) fImp->Write(Time(), "", s); }

    int Write(const Time &time, const std::string &txt, int qos=MessageImp::kMessage)
    {
        if (!fImp)
            return 0;
        return fImp ? fImp->Write(time, txt, qos) : MessageImp::Write(time, txt, qos);
    }

    void exitHandler(int code) { if (dynamic_cast<MainImp*>(fImp)) dynamic_cast<MainImp*>(fImp)->Stop(code); else exit(code); }

    // ==================== Readline tab-completion =====================

    static void append(std::string &str)
    {
        str.append("/");
    }
    static void chop(std::string &str)
    {
        const size_t p = str.find_first_of('/');
        if (p!=string::npos)
            str = str.substr(p+1);
    }

    // This funtion defines which generator should be called.
    // If it returns 0 the standard reaqdline generator are called.
    // Otherwise set the right generator with rl_completion_matches.
    char **Completion(const char *text, int start, int)
    {
        // Get the whole buffer before the tab-position
        const string b = string(T::GetBuffer());
        const string s = b.substr(0, start);
        const string l = Tools::Trim(s.c_str());
        if (l.empty())
        {
            if (fCurrentServer.empty())
            {
                const size_t p1 = b.find_first_of(' ');
                const size_t p2 = b.find_first_of('/');

                if (p1==string::npos && p2!=string::npos)
                    return T::Complete(GetCommandList(), text);

                std::vector<std::string> v = GetServerList();
                for_each(v.begin(), v.end(), RemoteControl::append);
                return T::Complete(v, text);
            }
            else
            {
                std::vector<std::string> v = GetCommandList(fCurrentServer);
                for_each(v.begin(), v.end(), RemoteControl::chop);
                return T::Complete(v, text);
            }
        }
        return T::Complete(GetCommandList(l), text);
    }

    void EventHook()
    {
        if (fImp && !fImp->HasServer(fCurrentServer))
            fCurrentServer = "";

        T::EventHook();
    }

    // ===== Interface to access the DIM network through the StateMachine ====

    bool HasServer(const std::string &server) { return fImp ? fImp->HasServer(server) : false; }
    vector<string> GetServerList() const { return fImp ? fImp->GetServerList() : vector<string>(); }
    vector<string> GetCommandList(const string &server) const { return fImp ? fImp->GetCommandList(server) : vector<string>(); }
    vector<string> GetCommandList() const { return fImp ? fImp->GetCommandList() : vector<string>(); }
    int PrintStates(std::ostream &out, const std::string &serv="") const { return fImp ? fImp->PrintStates(out, serv) : 0; }
    int PrintDescription(std::ostream &out, bool iscmd, const std::string &serv="", const std::string &service="") const
    { return fImp ? fImp->PrintDescription(out, iscmd, serv, service) : 0; }
    bool SendDimCommand(ostream &out, std::string &server, const std::string &str)
    {
        try
        {
            if (fImp)
                fImp->SendDimCommand(server, str, out);
            //lout << kGreen << "Command emitted successfully to " << server << "." << endl;
            return true;
        }
        catch (const runtime_error &e)
        {
            lout << kRed << e.what() << endl;
            return false;
        }
    }

    // ============ Pseudo-callback interface for the JavaScrip engine =======

    virtual void  JsLoad(const std::string &)         { SetSection(-2); }
    virtual void  JsStart(const std::string &)        { SetSection(-1); }
    virtual void  JsEnd(const std::string &)          { UnsubscribeAll(); SetSection(-3); }
    virtual bool  JsSend(const std::string &str)      { return ProcessCommand(str); }
    virtual void  JsOut(const std::string &msg)       { lout << msg << endl; }
    virtual void  JsPrint(const std::string &msg)     { if (fImp) fImp->Comment(msg.empty()?" ":msg); }
    virtual void  JsException(const std::string &str) { if (fImp) fImp->Error(str.empty()?" ":str); }

    pair<int32_t, string> JsState(const std::string &server)
    {
        return fImp ? fImp->GetServerState(server) : make_pair(-256, string());
    }

    void JsSleep(uint32_t ms)
    {
        const Time timeout = Time()+boost::posix_time::millisec(ms==0?1:ms);

        T::Lock();

        while (timeout>Time() && !T::IsScriptStopped())
            usleep(1);

        T::Unlock();
    }

    int JsWait(const string &server, int32_t state, uint32_t ms)
    {
        if (!fImp)
        {
            lout << kRed << "RemoteControl class not fully initialized." << endl;
            T::StopScript();
            return -1;
        }

        if (!HasServer(server))
        {
            lout << kRed << "Server '" << server << "' not found." << endl;
            T::StopScript();
            return -1;
        }

        T::Lock();

        const Time timeout = ms<=0 ? Time(Time::none) : Time()+boost::posix_time::millisec(ms);

        int rc = 0;
        while (timeout>Time() && !T::IsScriptStopped())
        {
            const pair<int32_t, string> st = fImp->GetServerState(server);
            if (st.first==-256)
            {
                lout << kRed << "Server '" << server << "' disconnected." << endl;
                T::StopScript();
                return -1;
            }
            if (st.first==state)
            {
                rc = 1;
                break;
            }

            usleep(1);
        }
        T::Unlock();

        return rc;
    }

    vector<Description> JsDescription(const string &service)
    {
        return fImp ? fImp->GetDescription(service) :  vector<Description>();
    }

    // Keep a copy of the data for access by V8
    map<string, EventImp *> fEvents;   // For unsibscription
    map<string, pair<uint64_t, Event>> fData;

    std::mutex fMutex;

    pair<uint64_t, EventImp *> JsGetEvent(const std::string &service)
    {
        const lock_guard<mutex> lock(fMutex);

        const auto it = fData.find(service);

        return it==fData.end() ? make_pair(uint64_t(0), (Event*)0) : make_pair(it->second.first, &it->second.second);
    }

    int Handle(const EventImp &evt, const string &service)
    {
        const lock_guard<mutex> lock(fMutex);

        const auto it = fData.find(service);
        if (it==fData.end())
            fData[service] = make_pair(0, static_cast<Event>(evt));
        else
        {
            it->second.first++;
            it->second.second = static_cast<Event>(evt);
        }

        return StateMachineImp::kSM_KeepState;
    }

    void *JsSubscribe(const std::string &service)
    {
        if (!fImp)
            return 0;

        // Do not subscribe twice
        if (fEvents.find(service)!=fEvents.end())
            return 0;

        return fEvents[service] = &fImp->Subscribe(service)(fImp->Wrap(bind(&RemoteControl<T>::Handle, this, placeholders::_1, service)));
    }

    bool JsUnsubscribe(const std::string &service)
    {
        if (!fImp)
            return false;

        const auto it = fEvents.find(service);
        if (it==fEvents.end())
            return false;

        fImp->Unsubscribe(it->second);
        fEvents.erase(it);

        return true;
    }

    void UnsubscribeAll()
    {
        for (auto it=fEvents.begin(); it!=fEvents.end(); it++)
            fImp->Unsubscribe(it->second);
        fEvents.clear();
    }

    // ===========================================================================


public:
    // Redirect asynchronous output to the output window
    RemoteControl(const char *name) : T(name),
        RemoteControlImp(T::GetStreamOut(), T::GetStreamIn()), fImp(0)
    {
    }

    bool PrintGeneralHelp()
    {
        T::PrintGeneralHelp();
        lout << " " << kUnderline << "Specific commands:\n";
        lout << kBold << "   h,help <arg> " << kReset << "List help text for given server or command.\n";
        lout << kBold << "   svc,services " << kReset << "List all services in the network.\n";
        lout << kBold << "   st,states    " << kReset << "List all states in the network.\n";
        lout << kBold << "   > <text>     " << kReset << "Echo <text> to the output stream\n";
        lout << kBold << "   .s           " << kReset << "Wait for the state-machine to change to the given state.\n";
        lout <<          "                "              "     .s <server> [<state> [<timeout> [<label>]]]\n";
        lout <<          "                "              "<server>  The server for which state to wait (e.g. FTM_CONTROL)\n";
        lout <<          "                "              "<state>   The state id (see 'states') for which to wait (e.g. 3)\n";
        lout <<          "                "              "<imeout>  A timeout in millisenconds how long to wait (e.g. 500)\n";
        lout <<          "                "              "<label>   A label (number) until which everything is skipped in case of timeout\n";
        lout << endl;
        return true;
    }

    bool PrintCommands()
    {
        lout << endl << kBold << "List of commands:" << endl;
        PrintDescription(lout, true);
        return true;
    }

    // returns whether a command should be put into the history
    bool Process(const std::string &str)
    {
        if (str.substr(0, 2)=="h " || str.substr(0, 5)=="help ")
        {
            const size_t p1 = str.find_first_of(' ');
            const string svc = str.substr(p1+1);

            const size_t p3 = svc.find_first_of('/');
            const string s = svc.substr(0, p3);
            const string c = p3==string::npos?"":svc.substr(p3+1);

            lout << endl;
            if (!fCurrentServer.empty())
            {
                if (PrintDescription(lout, true, fCurrentServer, svc)==0)
                    lout << "   " << svc << ": <not found>" << endl;
            }
            else
            {
                if (PrintDescription(lout, true, s, c)==0)
                    lout << "   <no matches found>" <<endl;
            }

            return true;
        }

        if (str.substr(0, 4)==".js ")
        {
            string opt(str.substr(4));

            map<string,string> data = Tools::Split(opt, true);
            if (opt.size()==0)
            {
                if (data.size()==0)
                    lout << kRed << "JavaScript filename missing." << endl;
                else
                    lout << kRed << "Equal sign missing in argument '" << data.begin()->first << "'" << endl;

                return true;
            }

            T::fScript = opt;
            JsRun(opt, data);
            return true;
        }

        if (str.substr(0, 3)==".s ")
        {
            istringstream in(str.substr(3));

            int state=-100, ms=0;
            string server;

            in >> server >> state >> ms;
            if (state==-100)
            {
                lout << kRed << "Couldn't parse state id in '" << str.substr(3) << "'" << endl;
                return true;
            }

            const int rc = JsWait(server, state, ms);

            if (rc<0 || rc==1)
                return true;

            int label = -1;
            in >> label;
            if (in.fail() && !in.eof())
            {
                lout << kRed << "Invalid label in '" << str.substr(3) << "'" << endl;
                T::StopScript();
                return true;
            }
            T::SetLabel(label);

            return true;
        }

        if (str[0]=='>')
        {
            fImp->Comment(Tools::Trim(str.substr(1)));
            return true;
        }

        if (ReadlineColor::Process(lout, str))
            return true;

        if (T::Process(str))
            return true;

        if (str=="services" || str=="svc")
        {
            PrintDescription(lout, false);
            return true;
        }

        if (str=="states" || str=="st")
        {
            PrintStates(lout);
            return true;
        }

        return !ProcessCommand(str);
    }

    void SetReceiver(StateMachineDimControl &imp) { fImp = &imp; }
};



// **************************************************************************
/** @class RemoteStream

 */
// **************************************************************************
#include "Console.h"

class RemoteStream : public RemoteControl<ConsoleStream>
{
public:
    RemoteStream(const char *name, bool null = false)
        : RemoteControl<ConsoleStream>(name) { SetNullOutput(null); }
};

// **************************************************************************
/** @class RemoteConsole

@brief Derives the RemoteControl from Control and adds a proper prompt

This is basically a RemoteControl, which derives through the template
argument from the Console class. It enhances the functionality of
the remote control with a proper updated prompt.

 */
// **************************************************************************

class RemoteConsole : public RemoteControl<Console>
{
public:
    RemoteConsole(const char *name, bool continous=false) :
        RemoteControl<Console>(name)
    {
        SetContinous(continous);
    }
    string GetUpdatePrompt() const;
};

// **************************************************************************
/** @class RemoteShell

@brief Derives the RemoteControl from Shell and adds colored prompt

This is basically a RemoteControl, which derives through the template
argument from the Shell class. It enhances the functionality of
the local control with a proper updated prompt.

 */
// **************************************************************************
#include "Shell.h"

class RemoteShell : public RemoteControl<Shell>
{
public:
    RemoteShell(const char *name, bool = false) :
        RemoteControl<Shell>(name)
    {
    }
    string GetUpdatePrompt() const;
};

#endif