/**
 * @file sim.cpp
 * @brief ZOMG! A sim!
 *
 * Copyright (c) Gareth Nelson
 *
 */

#include "linden_common.h"

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <map>

#include "indra_constants.h"
#include "llcommon.h"
#include "llapp.h"
#include "llapr.h"
#include "llerror.h"
#include "lltimer.h"
#include "lldir.h"
#include "llstring.h"
#include "llerrorcontrol.h"
#include "llhttpclient.h"
#include "llpumpio.h"
#include "lliohttpserver.h"
#include "llhttpnode.h"
#include "llsd.h"

class sessionsREST;
class sessionData;

time_t                  gLaunchTime;
LLPumpIO                *gServicePump;
LLHTTPNode              *gHTTPD;
bool                    gQuit=false;

LLHTTPRegistration<sessionsREST> HTTPServiceSessions("/sessions");
std::map<LLUUID, sessionData> sessions;

class sessionData
{
        public:
                LLUUID SessionID;
                LLUUID SecureSessionID;
                U16 circode;

                sessionData() {}

                sessionData(LLSD input)
                {
                        SessionID       = input["SessionID"];
                        SecureSessionID = input["SecureSessionID"];
                        circode         = input["circode"].asInteger();
                }

                LLSD getLLSD()
                {
                        LLSD _sessionData;
                        _sessionData = LLSD::emptyMap();
                        _sessionData["SessionID"]       = SessionID;
                        _sessionData["SecureSessionID"] = SecureSessionID;
                        _sessionData["circode"]         = circode;
                        return _sessionData;
                }
};

class SessionHTTPNode : public LLHTTPNode
{
        public:
                SessionHTTPNode()
                {
                        active=false;
                }

                SessionHTTPNode(LLUUID sessionID)
                {
                        if(sessions.count(sessionID)>0)
                        {
                                active=true;
                                data=sessions[sessionID];
                        } else {
                                active=false;
                        }
                }

                LLSD get() const
                {
                        if(!active) return LLSD();
                        LLSD LLSDdata = data.getLLSD();
                        return LLSDdata;
                }

                LLSD post(const LLSD& input) const
                {
                        if(!input.has("SessionID")) return LLSD();
                        if(!input.has("SecureSessionID")) return LLSD();
                        if(!input.has("circode")) return LLSD();
                        data = sessionData(LLSD(input));
                        sessions[data.SessionID] = data;
                }

        private:
                bool active;
                sessionData data;
};

class sessionsREST : public LLHTTPNode
{
        LLSD get() const
        {
                llinfos << "Returning session data!" << llendl;
                LLSD _sessionData = LLSD::emptyMap();
                std::map<LLUUID, sessionData>::iterator it;
                for(it=sessions.begin(); it!=sessions.end(); it++)
                {
                        _sessionData.insert((*it).first.asString(),sessions[(*it).first].getLLSD());
                }
                return _sessionData;
        }

        LLHTTPNode* getChild(const std::string& name, LLSD& context) const
        {
                if(sessions.count(LLUUID(name))>0)
                {
                        return new SessionHTTPNode(LLUUID(name));
                } else {
                        return new SessionHTTPNode();
                }
        }
};

void init_networking()
{
        llinfos << "Starting networking/messaging subsystem" << llendl;
        gServicePump = new LLPumpIO(gAPRPoolp);
        LLHTTPClient::setPump(*gServicePump);
        gHTTPD = &LLIOHTTPServer::create(gAPRPoolp, *gServicePump, (U16)8080);
}

void init_httpd()
{
        llinfos << "Setting up web services" << llendl;
        LLHTTPRegistrar::buildAllServices(*gHTTPD);
}

void main_loop()
{
        while(!gQuit)
        {
                gServicePump->pump();
        }
}

int main(int argc, char **argv)
{
        time(&gLaunchTime);

        LLError::initForServer(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));

        llinfos << "Starting up region host" << llendl;

        LLCommon::initClass();
        init_networking();
        init_httpd();

        llinfos << "Starting main loop" << llendl;
        main_loop();

        return 0;
}