#include <UserInterface/NetworkUI.h>
#include <Core/Exceptions/IllegalArgument.h>
#include <Core/Util/Args.h>
#include <Interface/Camera.h>
#include <Model/Cameras/MatrixCamera.h>
#include <Interface/Context.h>
#include <Interface/MantaInterface.h>
#include <Interface/Transaction.h>
#include <Core/Thread/Runnable.h>
#include <Core/Thread/Thread.h>
#include <sgi_stl_warnings_off.h>
#include <iostream>
#include <sstream>
#include <sgi_stl_warnings_on.h>


using namespace Manta;
using namespace SCIRun;
using namespace std;

UserInterface* NetworkUI::create(const vector<string>& args,
                                 MantaInterface *rtrt_interface)
{
  //UserInterface *newUI = new NetworkUI(args, rtrt_interface);
  //peturn newUI;
  return new NetworkUI(args, rtrt_interface);
}


NetworkUI::NetworkUI(const vector<string>& args, MantaInterface *rtrt_interface)
  : rtrt_interface(rtrt_interface),
    server_socket_number ( -1 ),
    socket_number ( -1 ),
    port ( 30000)

{
  string temp_port;
  // Parse command line args.
  for (int i=0;i<args.size();++i) {
    if (args[i] == "-port") {
      if (!getStringArg( i, args, temp_port )) {
        throw IllegalArgument( "NetworkUI", i, args );
      }
      else
      {
        istringstream port_input(temp_port);
        port_input >> port;
      }
    }
  }
  memset ( &address,
           '\0',
           sizeof ( address ) );

  server_socket_number = socket ( AF_INET,
                    SOCK_STREAM,
                    0 );

  int weight_for_socket=1; //1 means dont weight for socket to be free before binding

  if ( setsockopt(server_socket_number,SOL_SOCKET,SO_REUSEADDR,&weight_for_socket,sizeof(int)) == -1 )

  if ( server_socket_number == -1 )
  {
    cout<<"Error:  Problem creating socket descriptor\n";
    exit(1);
  }

  address.sin_family = AF_INET;
  address.sin_port = htons ( port );
  address.sin_addr.s_addr = htons ( INADDR_ANY );

  if ( bind ( server_socket_number,
                             ( struct sockaddr * ) &address,
                             sizeof ( address ) ) == -1 )
  {
    cout<<"Error:  Problem binding socket\n";
    exit(1);
  }

  int number_of_connections = 1;
  if ( listen ( server_socket_number, number_of_connections ) == -1 )
  {
    cout<<"Error:  Problem occured while listening to socket\n";
    exit(1);
  }
  cout<<"NetworkUI: Accepting  socket connection\n";
  int address_length = sizeof ( address );
  socket_number = accept ( server_socket_number, ( sockaddr * ) &address, ( socklen_t * ) &address_length );
  cout<<"NetworkUI: Socket Connected\n";

  if (socket_number == -1 )
  {
    cout<<"Error: Problem when accepting socket connection\n";
    exit(1);
  }
  close(server_socket_number);

}

NetworkUI::~NetworkUI()
{
  close(socket_number);
}

void NetworkUI::startup()
{
  Thread* t = new Thread(this, "Manta User Interface");
  t->setDaemon(true);
  t->detach();
}

void NetworkUI::run()
{
  int recv_check;
  unsigned char *buffer = new unsigned char[16];
  for(;;)
  {
    recv_check = recv ( socket_number, buffer, 1, 0 );
    //cout<<recv_check<<endl;
    if (recv_check>0)
      cout<<"NetworkUI: Control signal received: "<<buffer[0]<<endl;
    if ( recv_check == -1 )
      { 
        std::cout << "Error: recv returned -1\n";
        break;
      }
    else if ( recv_check == 0 )
      {
        //std::cout<<"nothing received\n";
        //break;
      }
    else if ( buffer[0] == 'r' )
      {
        int xres,yres;
        cout<<"UserInterface::Run: Frame #: "<<rtrt_interface->getCurrentFrame()<<endl;
        recv_check = recv ( socket_number, &xres, sizeof(int), 0 );
        recv_check = recv ( socket_number, &yres, sizeof(int), 0 );
        rtrt_interface->addOneShotCallback(MantaInterface::Relative, 0,
                                           Callback::create(this, &NetworkUI::changeResolution,
                                                            0, xres, yres));
        cout<<"NetworkUI: Resolution Updated "<<"x: "<<xres<<" y: "<<yres<<endl;
      }
    else if ( buffer[0]=='c' )
    {
        Camera* camera = rtrt_interface->getCamera(0);
        //cout<<typeid(*camera).name()<<endl;
        MatrixCamera* tempCamera = dynamic_cast <MatrixCamera*>(camera);
        if(tempCamera==NULL)
        {
		cout<<"Error:  MatrixCamera not detected"<<endl;
        } else{
          long int tempNumber=0;
          recv_check = recv ( socket_number, &tempNumber, sizeof(tempNumber), 0 );
          tempCamera->setCameraNumber(tempNumber);
          cout<<"NetworkUI::run: camera number: "<<tempCamera->getCameraNumber()<<endl;
          float invMat[16];
          recv_check = recv ( socket_number, invMat, sizeof(invMat), 0 );
          rtrt_interface->addTransaction("set Matrix",
                                 Callback::create(tempCamera, &MatrixCamera::setMatrix,
                                                  invMat));

        }
    }else if ( buffer[0]=='q' )
    {
       rtrt_interface->finish();
    }


  }
  delete [] buffer;
}

void NetworkUI::changeResolution(int, int, int channel,
                                 int new_xres, int new_yres)
{
  // cerr << "Resolution: " << new_xres << " " << new_yres << endl;
  rtrt_interface->changeResolution(channel, new_xres, new_yres, true);
}