/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/***************************************************************************
 *            server.cc
 *
 *  Wed Aug 22 12:16:03 CEST 2007
 *  Copyright 2007 Bent Bisballe Nyeng, Lars Bisballe Jensen and Peter Skaarup
 *  deva@aasimon.org, elsenator@gmail.com and piparum@piparum.dk
 ****************************************************************************/

/*
 *  This file is part of Pracro.
 *
 *  Pracro is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Pracro 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Pracro; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "server.h"

#include "tcpsocket.h"
#include <errno.h>

#include <stdlib.h>

// For fork
#include <sys/types.h>
#include <unistd.h>

#include "configuration.h"

#include "transaction.h"
#include "xmlparser.h"

#include "database.h"

#include "macro.h"
#include "macro_parser.h"

#include "resumeparser.h"

#include "tostring.h"
#include <time.h>

static void send_macro_widget(Widget &widget, TCPSocket &socket, std::string tabs)
{
  socket.write(tabs + "<" + widget.type);
  WidgetPropertyList::iterator p = widget.properties.begin();
  while(p != widget.properties.end()) {
    WidgetProperty &property = *p;
    socket.write(" " + property.name + "=\"" + property.value + "\"");
    p++;
  }
  socket.write(">\n");

  WidgetList::iterator w = widget.widgets.begin();
  while(w != widget.widgets.end()) {
    send_macro_widget(*w, socket, tabs + "  ");
    w++;
  }
  socket.write(tabs + "</" + widget.type + ">\n");
}

static void connection(TCPSocket &socket)
{
  printf("Got connection...\n");

  Transaction transaction;
  parse(socket, transaction);

  socket.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
  socket.write("<pracro version=\"1.0\">\n");

  // Handle requests
  Requests::iterator i = transaction.requests.begin();
  while(i != transaction.requests.end()) {
    Request request = *i;

    printf("Handling request for \"%s\"...", request.macro.c_str());
    
    Macro macro;
    parse_macro(request.macro, macro);

    WidgetList::iterator w = macro.widgets.begin();
    while(w != macro.widgets.end()) {
      send_macro_widget(*w, socket, "  ");
      w++;
    }

    printf("done.\n");
    
    i++;
  }

  // Handle commits
  if(transaction.commits.size() > 0) {
    std::string now = toString((unsigned int)time(NULL));

    Commits::iterator i = transaction.commits.begin();
    while(i != transaction.commits.end()) {
      Commit &commit = *i;

      Database db;
      db.post(transaction.user, transaction.cpr, now, commit);

      Macro macro;
      parse_macro(commit.macro, macro);
      //parse_macro("example", macro);

      macro.format = "Det koster 50$$\\n\\tLinse: ${linse}D\\n"
        "\\y${combo}\\\\\\nHævelse: ${radio}\\n\\n${spl_note}";

      std::string resume = resume_parser(macro.format.c_str(), commit);

      printf("%s\n", resume.c_str());

      i++;
    }
  }

  socket.write("</pracro>\n");

  printf("Done with connection.\n");
}

void server()
{
  int port;
  try {
    port = config()->lookup("port");
  } catch( ... ) {
    fprintf(stderr, "Could not read port.");
    return;
  }

  TCPSocket *socket;
  
  try {
    socket = new TCPSocket();
    socket->listen(port);
  } catch (Exception &e) {
    fprintf(stderr, "Error during parsing:\n%s\n",
            e.what());
    delete socket;
    return;
  }

  while(socket->connected()) {

    { // Reload if new port i assigned.
      int old_port = port;
      try {
        port = config()->lookup("port");
      } catch( ... ) {
        fprintf(stderr, "Could not read port.");
        return;
      }

      if(port != old_port) {
        // Start listening on the new port
        delete socket;
        socket = new TCPSocket();
        socket->listen(port);
      }
    }

    TCPSocket child = socket->accept();
    if(child.connected()) {
      switch(fork()) {
      case -1: // error
        fprintf(stderr, "Could not fork: %s\n", strerror(errno));
        break;
        
      case 0: // child
        socket->disconnect();
        connection(child);
        delete socket;
        return;
        
      default: // parent
        break;
      }
    }
  }

  delete socket;
  fprintf(stderr, "Oups... dropped out of the main loop\n");
}