// serwer corbowy pod mico/C++ (12.2015)
// + co do wyciekow pamieci: spojrz do Hello2.cc...
//

#include <iostream>
//#include <stdlib.h>
#include <CORBA.h>
#include "Hello2.h"
     
using namespace std;

// impl. VT qqq oraz fabryki VT qqq
class qqqImpl
  : virtual public ::OBV_HelloApp::qqq,
    virtual public ::CORBA::DefaultValueRefCountBase {
public:
  qqqImpl() {}
  void nic() {}
};
class qqqFactoryImpl
  : virtual public ::CORBA::ValueFactoryBase {
public:
  CORBA::ValueBase*
  create_for_unmarshal() {
    return new qqqImpl;
  }
};

class HelloImpl 
  : virtual public ::POA_HelloApp::Hello {
public:
  int licznik;
  HelloImpl() {
    licznik= 0;
  }
  char* sayHello() {
    return CORBA::string_dup("a ku ku !!!");
  }
  char* sayHello2( const char* we ) {
    exit(0); // chwilowo, na uzytek valgrind-a
    return 0;
  }
  CORBA::Long podajLiczbe() {
    return licznik++;
  }
  ::HelloApp::Hello::long_seq* met1( const ::HelloApp::Hello::long_seq& s1 ) {
    int s1_len= s1.length();
    ::HelloApp::Hello::long_seq* s2w= new ::HelloApp::Hello::long_seq;
      // czy na pewno nie powinnismy tego zwalniac ???
      // jak sprawdz. czy nie ma wycieku pamici? (valgrind??)
      // wszyst. jedno czy sa "()" przy new...
    s2w->length(s1_len);
      // to jest konieczne ? (nawet jesli robic *ws2= s1;)
      // bez tego jest segm. fault ?!?!?!?!
    
    //for (int i=0; i<s1_len; i++) (*ws2)[i]=s1[i];
      // czy nie da sie prosciej przepisac? np. *ws2= s1; TAK!!
    *s2w= s1;
    
    if (s1_len>=2) {
      (*s2w)[0]= 123;
      (*s2w)[1]= 321;
    }
    return s2w;
  }
  ::HelloApp::Hello::macierz* zwrocMacierz( CORBA::Long w, CORBA::Long k ) {
    // w - l. wierszy, k - l. kolumn
    ::HelloApp::Hello::macierz *mac= new ::HelloApp::Hello::macierz;
    mac->length(w); for(int i=0; i<w; i++) (*mac)[i].length(k);
      // mamy pusta macierz (przypadkowe wartosci!)
    for(int i=0; i<w; i++)
      for(int j=0; j<k; j++)
        (*mac)[i][j]=123.123;
    return mac;
  }
  ::HelloApp::Hello::S_arr_slice* met2( 
    const ::HelloApp::Hello::S_arr v1 
  ) {
    ::HelloApp::Hello::S_arr_slice* ret= ::HelloApp::Hello::S_arr_alloc();
      // KONIECZNIE trzeba uzyc S_arr_alloc() !!!
    /*
    ret[0].i1= 123;
    ret[0].s1= (const char*)"A ku ku 1";
    ret[1].i1= 123;
    ret[1].s1= (const char*)"A ku ku 2";
    ret[2].i1= 123;
    ret[2].s1= (const char*)"A ku ku 3";
      // ok
      // uwaga: tu NIE nalezy uzywac (*ret) !!!
    */
    for(int i=0; i<3; i++) ret[i]= v1[i];
      // tutaj ret i v1 to normalne tablice (a nie przec. op. []) !
      // nie ma lepszej metody kopiowania v1 do ret... ?
    
    return ret;
  }
  ::HelloApp::Hello::S_seq* met3( const ::HelloApp::Hello::S_seq& v1 ) {
    ::HelloApp::Hello::S_seq* ret= new ::HelloApp::Hello::S_seq;
    ret->length(v1.length());
    *ret= v1;
    return ret;
  }
  ::HelloApp::qqq* met4( ::HelloApp::qqq* v1 ) {
      ::HelloApp::qqq* ret= new qqqImpl;
      // qqqImpl dziedziczy m.in. z ::OBV_HelloApp::qqq
      //   ale ::OBV_HelloApp::qqq jest cialge klasa abstrak.
      //   dlatego trzeba dziedziczyc jeszcze z czegos!!
      // przekazywanie VT przez par v1
      //   zacznie dzialac dopiero po zarejestrowaniu factory !!
 
    if(v1!=0) 
      ret->i1(v1->i1());
    else
      ret->i1(123);
    ret->s1("A ku ku !!!");
    return ret;
  }
};

int main(int argc, char ** argv)
{
  try {
    CORBA::ORB_ptr orb= CORBA::ORB_init(argc, argv);
    CORBA::Object_var poaobj= orb->resolve_initial_references("RootPOA");
    PortableServer::POA_var poa = PortableServer::POA::_narrow(poaobj);
    CORBA::release(poaobj);
    PortableServer::POAManager_var mgr = poa->the_POAManager();
    mgr->activate();

    qqqFactoryImpl* fact= new qqqFactoryImpl;
    orb->register_value_factory("IDL:HelloApp/qqq:1.0", fact);
      // dopiero po zarej. tej fabryki
      //   zaczna dziala VT przychodzace do serwera!!

    HelloImpl hello_servant;
    CORBA::Object_var hello_obj= poa->servant_to_reference(&hello_servant);
    cout << orb->object_to_string(hello_obj) << endl;
      // string zwracany przez object_to_string trzeba zwalniac!!
      //   podobnie ref do ob. Corby - specyfika C++...

    cout << "przed orb->run()" << endl;
    orb->run();
    cout << "po orb->run()" << endl;
  } catch (...) {cout << "ERROR" << endl;}
}