#include "bus_server_socket.h"
#include "shm_mod_socket.h"
#include "shm_mm_wrapper.h"
#include "usg_common.h"
#include "mm.h"
#include "logger_factory.h"
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include "bus_error.h"

#include "bh_api.h"
#include "proc_def.h"

#define TOTAL_REG_UNREG         2

#define MAGIC_STR       "INTER_"
#define STR_LEN         30

pthread_t tids;
void *res;

static ProcInfo proc_desc;

char *genStr(int length, char *buf)
{
  int flag, i;
  char *str;

  if (length < (strlen(buf) + 10)) {
    length = strlen(buf) + 10;
  }

  srand((unsigned) time(NULL));
  if ((str = (char *)malloc(length + 1)) == NULL) {
    printf("out of memory!\n");

    exit(0);
  }

  memset(str, 0x00, length + 1);
  memcpy(str, MAGIC_STR, strlen(MAGIC_STR));
  strcat(str, buf);
  for (i = strlen(str); i < length; i++) {
    flag = rand() % 3;
    switch (flag) {
      case 0:
        str[i] = 'A' + rand() % 26;
        break;

      case 1:
        str[i] = 'a' + rand() % 26;
        break;

      default:
        str[i] = '0' + rand() % 10;
        break;
    }
  }

  str[length] = '\0';

  return str;

}

void *client_recv(void *skptr) {
  
  pthread_detach(pthread_self());
  
  void *recvbuf = NULL;
  int recv_len;
  void *proc_id = NULL;
  int id_len;
  int rv;
  void *errBuf = NULL;
  int len;
  char proc_data[200] = { 0x00 };
  char topics[200] = { 0x00 };
  
  struct timespec timeout = {2, 0};

  while (true) {

    rv = BHReadSub(&proc_id, &id_len, &recvbuf, &recv_len, -1);
    if(rv == true) {

      memset(topics, 0x00, sizeof(topics));
      memset(proc_data, 0x00, sizeof(proc_data)); 

      memcpy(proc_data, proc_id, (sizeof(proc_data) - 1) > id_len ? id_len : (sizeof(proc_data) - 1));

      memcpy(topics, recvbuf, (sizeof(topics) - 1) > recv_len ? recv_len : (sizeof(topics) - 1));

      printf("Get the sub topics data(%s) from proc id(%s)\n", (char *)topics, (char *)proc_id);

      BHFree(recvbuf, len);
      BHFree(proc_id, id_len);

    } else {
      BHGetLastError(&errBuf, &len);
      printf("the thread recv fail with error: %s\n", (char *)errBuf);

      BHFree(errBuf, len);
    }

  }

}

void parseQueryTopicsBuf(void *buf, int len)
{
  if (buf == NULL)
    return;

  int total_topics = *(int *)buf;
  int i, j;
  int buf_pos = 0;
  void *ptr_temp = NULL;
  ProcInfo_query *ptr = NULL;
  ProcInfo *Proc_ptr = NULL;

  buf_pos = sizeof(ProcInfo_query);
  ptr = (ProcInfo_query *)((char *)buf + sizeof(int));
  ptr_temp = (void *)ptr;
  for (i = 0; i < total_topics; i++) {
    printf("topic %s:\n", ptr->name);
    for (j = 0; j < ptr->num; j++) {
      printf("the %dst process info:\n", j + 1);
      Proc_ptr = &(ptr->procData) +  j;
      printf("proc_id: %s\n", Proc_ptr->proc_id);
      printf("name: %s\n", Proc_ptr->name);
      printf("public_info: %s\n", Proc_ptr->public_info);
      printf("private_info: %s\n", Proc_ptr->private_info);

    }

    if (ptr->num > 1) {
      buf_pos += sizeof(ProcInfo) * (ptr->num - 1);
    }
    
    ptr = (ProcInfo_query *)((char *)ptr_temp + buf_pos);
  }

}

void parseQueryProcBuf(void *buf, int len)
{
  if (buf == NULL)
    return;

  int total = *(int *)buf;
  int i;
  ProcInfo_sum *Proc_ptr = NULL;

  Proc_ptr = (ProcInfo_sum *)((char *)buf + sizeof(int));
  for (i = 0; i < total; i++) {
    printf("proc_id: %s\n", (Proc_ptr + i)->procData.proc_id);
    printf("name: %s\n", (Proc_ptr + i)->procData.name);
    printf("public_info: %s\n", (Proc_ptr + i)->procData.public_info);
    printf("private_info: %s\n", (Proc_ptr + i)->procData.private_info);

    printf("service: %s\n", (Proc_ptr + i)->reg_info);
    printf("sub: %s\n", (Proc_ptr + i)->local_info);
  }
}

int main(int argc, char *argv[]) {
  int ret;
  char *ptr = NULL;
  char buf[] = "Process";
  void *buf_temp = NULL;
  void *errBuf = NULL;
  void *proc_id = NULL;
  int size;
  int id_len;
  int i;
  char data_buf[200] = { 0x00 };
  const int timeout_ms = 3000;

  memset(&proc_desc, 0x00, sizeof(ProcInfo));
  ptr = genStr(STR_LEN, buf);
  strncpy(proc_desc.proc_id, ptr, strlen(ptr) + 1); 
  //strncpy(proc_desc.proc_id, "Hello", strlen("Hello") + 1);
  free(ptr);

  sleep(2); //make rand change
  ptr = genStr(STR_LEN, buf);
  strncpy(proc_desc.name, ptr, strlen(ptr) + 1);
  //strncpy(proc_desc.name, "World", strlen("World") + 1);
  free(ptr);

  sleep(2);
  ptr = genStr(STR_LEN, buf);
  //strncpy(proc_desc.public_info, ptr, strlen(ptr) + 1);
  strncpy(proc_desc.public_info, "Good", strlen("Good") + 1);
  free(ptr);

  sleep(2);
  ptr = genStr(STR_LEN, buf);
  //strncpy(proc_desc.private_info, ptr, strlen(ptr) + 1);
  //strncpy(proc_desc.private_info, "Bye", strlen("Bye") + 1);
  free(ptr);

  printf("before the registered, process info:\n");
  printf("proc_id: %s\n", proc_desc.proc_id);
  printf("name: %s\n", proc_desc.name);
  printf("public_info: %s\n", proc_desc.public_info);
  printf("private_info: %s\n", proc_desc.private_info);

  for (i = 0; i < TOTAL_REG_UNREG; i++) {
    ret = BHRegister(&proc_desc, (const int)sizeof(ProcInfo), &buf_temp, &size, timeout_ms);
    if (ret == true) {
      printf("the process registered OKay\n");

      BHFree(buf_temp, size);
      
    } else {
      BHGetLastError(&errBuf, &size);
      printf("the process registered fail with error: %s\n", (char *)errBuf);
      BHFree(errBuf, size);
      
      printf("the second way to get the error log: %s\n", buf_temp);
      
    };

    ret = BHUnregister(NULL, 0, &buf_temp, &size, timeout_ms);
    if (ret == true) {
      printf("the process unregistered OKay\n");

      BHFree(buf_temp, size);
      
    } else {
      BHGetLastError(&errBuf, &size);
      printf("the process unregistered fail with error: %s\n", (char *)errBuf);
      BHFree(errBuf, size);
      
      printf("the second way to get the error log: %s\n", buf_temp);
      
    };  
  }

  //const char *topics_reg_buf1[] = {"topics demo1"};
  const char *topics_reg_buf1 = "topics demo1";
  const char *topics_query_buf1 = "topics demo1";
  const char *topics_query_buf2 = "Hello World,So,Great,Good"; //No space between each other 
  //const char *topics_reg_buf2[] = {"Hello World", "So", "Great", "Good"};
  const char *topics_reg_buf2 = "Hello World,So,Great,Good";

  //const char *topics_sub_buf1[] = {"news"};
  //const char *topics_sub_buf2[] = {"sports", "balls", "topics demo1"};
  const char *topics_sub_buf1 = "news";
  const char *topics_sub_buf2 = "sports,balls,topics demo1";

  const char *topics_pub_topic1 = "news";
  const char *topics_pub_topic1_data = "boob news";

  const char *topics_pub_topic2 = "balls";
  const char *topics_pub_topic2_data = "Great volleyballs and basketballs";

  ret = BHRegister(&proc_desc, (const int)sizeof(ProcInfo), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process registered OKay\n");

    BHFree(buf_temp, size);
    
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process registered fail with error: %s(%s)\n", (char *)errBuf, buf_temp);

    BHFree(errBuf, size);
  };

  ret = BHRegisterTopics(topics_reg_buf1, strlen(topics_reg_buf1), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process registered topics OKay\n");

    BHFree(buf_temp, size);
     
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process registered1 fail with errorL %s(%s)\n", (char *)errBuf, buf_temp);

    BHFree(errBuf, size);
  };

  ret = BHRegisterTopics(topics_reg_buf2, strlen(topics_reg_buf2), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process registered topics OKay\n");

    BHFree(buf_temp, size);
    
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process registered2 fail with error: %s(%s)\n", (char *)errBuf, buf_temp);

    BHFree(errBuf, size);
  };
  
  ret = BHQueryTopicAddress(NULL, 0, topics_query_buf1, strlen(topics_query_buf1), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process query topics OKay\n");

    parseQueryTopicsBuf(buf_temp, size);

    BHFree(buf_temp, size);
    
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process query3 fail with error: %s(%s)\n", (char *)errBuf, buf_temp);

    BHFree(errBuf, size);
  };

  ret = BHQueryTopicAddress(NULL, 0, topics_query_buf2, strlen(topics_query_buf2), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process query topics OKay\n");

    parseQueryTopicsBuf(buf_temp, size);

    BHFree(buf_temp, size);
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process query4 fail with error: %s(%s)\n", (char *)errBuf, buf_temp);

    BHFree(errBuf, size);
  };
 
  pthread_create(&tids, NULL, client_recv, NULL);

  ret = BHRegisterTopics(topics_reg_buf1, strlen(topics_reg_buf1), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process registered topics OKay\n");

    BHFree(buf_temp, size);
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process registered1 fail with errorL %s(%s)\n", (char *)errBuf, buf_temp);

    BHFree(errBuf, size);
  };

  ret = BHSubscribeTopics(topics_sub_buf1, strlen(topics_sub_buf1), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process subscribe topics OKay\n");

    BHFree(buf_temp, size);
    
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process sub1 fail with error: %s(%s)\n", (char *)errBuf, buf_temp);

    BHFree(errBuf, size);
  };  

  ret = BHSubscribeTopics(topics_sub_buf2, strlen(topics_sub_buf2), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("tthe process subscribe topics OKay\n");

    BHFree(buf_temp, size);
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process sub2 fail with error: %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  };

  ret = BHRegisterTopics(topics_reg_buf2, strlen(topics_reg_buf2), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process registered topics OKay\n");

    BHFree(buf_temp, size);
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process registered10 fail with errorL %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  };
  
  const char *topics_server_specific_reg_buf1 = "Server Specific topics demo1";
  const char *topics_server_specific_reg_buf2 = "Server Specific Hello World";
  void *msgID = NULL;
  int msg_id_len;
  
  ret = BHAsyncRequest(NULL, 0, topics_server_specific_reg_buf1, strlen(topics_server_specific_reg_buf1), &msgID, &msg_id_len);
  if (ret == true) {
    printf("the process BHAsyncRequest topics OKay\n");
   
    BHFree(msgID, msg_id_len);

  } else {
    
    BHGetLastError(&errBuf, &size);
    printf("the process BHAsyncRequest1 topics fail with error: %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  };
  
  ret = BHAsyncRequest(NULL, 0, topics_server_specific_reg_buf2, strlen(topics_server_specific_reg_buf2), NULL, 0);
  if (ret == true) {
    printf("the process BHAsyncRequest topics OKay\n");

  } else {
    
    BHGetLastError(&errBuf, &size);
    printf("the process BHAsyncRequest2 topics fail with error: %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  };

  ret = BHRequest(NULL, 0, topics_server_specific_reg_buf1, strlen(topics_server_specific_reg_buf1), &proc_id, &id_len,
              &buf_temp, &size, timeout_ms);
  if (ret == true) {
    
    memset(data_buf, 0x00, sizeof(data_buf));
    strncpy(data_buf, (char *)buf_temp, (sizeof(data_buf) - 1) > size ? size : (sizeof(data_buf) - 1));
    printf("the process BHRequest topics OKay\n");
    
    printf("the response data(%s) from procid(%s)\n", data_buf, (char *)proc_id);

    BHFree(buf_temp, size);
    
  } else {
    
    BHGetLastError(&errBuf, &size);
    printf("the process BHRequest topics fail with error: %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  }
  
  ret = BHRequest(NULL, 0, topics_server_specific_reg_buf2, strlen(topics_server_specific_reg_buf2), &proc_id, &id_len,
              &buf_temp, &size, timeout_ms);
  if (ret == true) {

    memset(data_buf, 0x00, sizeof(data_buf));
    strncpy(data_buf, (char *)buf_temp, (sizeof(data_buf) - 1) > size ? size : (sizeof(data_buf) - 1));
    printf("the process BHRequest topics OKay\n");
    
    printf("the response data(%s) from procid(%s)\n", data_buf, (char *)proc_id);

    BHFree(buf_temp, size);
    
  } else {
    
    BHGetLastError(&errBuf, &size);
    printf("the process BHRequest2 topics fail with error: %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  };

#if !defined(PRO_DE_SERIALIZE)
  ret = BHPublish(topics_pub_topic1, topics_pub_topic1_data, timeout_ms);
  if (ret == true) {
    printf("the process publish topic(%s) and content(%s) OKay\n", topics_pub_topic1, topics_pub_topic1_data);

  } else {
    printf("the process published1 fail\n");
  };

  ret = BHPublish(topics_pub_topic2, topics_pub_topic2_data, timeout_ms);
  if (ret == true) {
    printf("the process publish topic(%s) and content(%s) OKay\n", topics_pub_topic2, topics_pub_topic2_data);

  } else {
    printf("the process published2 fail\n");
  };
#endif 
 
  memset(data_buf, 0x00, sizeof(data_buf));
  strcpy(data_buf, "query the process");
  ret = BHQueryProcs(NULL, 0, data_buf, strlen(data_buf), &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process query all the process data OKay\n");

    parseQueryProcBuf(buf_temp, size);

    BHFree(buf_temp, size);
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process query proc fail with error: %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  };

#if 1
  while(1) {
    sleep(1);
  }
#else 
  /*if the process will exit finally, we must call BHUnregister to release the resources*/
  ret = BHUnregister(NULL, 0, &buf_temp, &size, timeout_ms);
  if (ret == true) {
    printf("the process unregistered OKay\n");

    BHFree(buf_temp, size);
    
  } else {
    BHGetLastError(&errBuf, &size);
    printf("the process unregistered fail with error: %s\n", (char *)errBuf);

    BHFree(errBuf, size);
  };
  
#endif 

  return 0;

}