#include <minigui/common.h>

#include <minigui/minigui.h>

#include <minigui/gdi.h>

#include <minigui/window.h>

#include <minigui/control.h>

#include <sys/mman.h>

#include <fcntl.h>

#include <json.h>

#include <stdio.h>

#include <unistd.h>

#include <signal.h>

#include <ctype.h>

#include <string.h>

#include <libusb.h>

#include <ev.h>

#include "ghttp/ghttp.h"

#define REQ_REGISTER 1

#define REQ_SUBMIT 2

#define REQ_QUERY 3

#define REQ_CANCEL 4

#define REQ_TYPE "req_type"

#define BODY "body"

#define RESP_TYPE "resp_type"

#define RESP_RESULT "resp_result"

#define RESULT_SUCCESS 0

#define RESULT_FAILURE -1

#define RESULT_TIMEOUT -2

#define MACHINE_ID "m_id"

#define ORDER_ID "o_id"

#define INFO_VERSION "info_version"

#define ENCODE_FORMAT "encode_format"

#define HOST "host"

#define AMOUNT "amount"

#define USB_BUF_SIZE 64

#define USB_VENDORID 0x10c4

#define USB_PRODUCTID 0x0000

extern HWND hwnd_pic,hwnd_txt;

extern BITMAP pic;

enum STATUS

}status;

typedef struct {

int type;

int result;

}RESP_RET;

static RESP_RET resp_ret;

static struct ghttp_request *request;

static struct json_object *my_object;

static unsigned int machine_id;

static unsigned int *p_order_id;

static unsigned int info_version;

static char *amount;

static char usb_in_buf[USB_BUF_SIZE];

static char usb_out_buf[USB_BUF_SIZE];

static ev_signal usb_watcher;

static ev_io net_watcher;

static int fd_net,net_io;

static int transferred;

static pthread_t main_thread;

static libusb_device_handle *handle;

static char qrcode_buf[80];

static ghttp_status http_status;

static char* format_qrcode;

void update_display(const char* img,int type)//undone

{

char txt[50];

if(type==1)

{

sprintf(txt,"The amount is : %s\n",amount);

}

else

{

sprintf(txt,"Wait for order.\n");

}

LoadBitmap (HDC_SCREEN, &pic, img);

SendMessage(hwnd_pic,STM_SETIMAGE,(WPARAM)&pic,(LPARAM)0);

SetWindowText (hwnd_txt, txt);

}

static void write_to_usb(int resp_type,int resp_result)

{

int err;

usb_out_buf[0]=resp_type;

usb_out_buf[1]=resp_result;

err=libusb_interrupt_transfer(handle,0x02,usb_out_buf,USB_BUF_SIZE,&transferred,0);

if(err)

puts(libusb_error_name(err));

}

static void *read_from_usb()

{

int err;

while(1)

{

if(err=libusb_interrupt_transfer(handle,0x81,usb_in_buf,USB_BUF_SIZE,&transferred,0))

{

puts(libusb_error_name(err));

}

if(err=pthread_kill(main_thread,SIGUSR1))

{

perror("Pthread_kill ERROR");

}

}

}

static void http_request(int req_type)

{

char *str;

struct json_object *json,*body;

json = json_object_new_object();

json_object_object_add(json, REQ_TYPE, json_object_new_int(req_type));

if(req_type==REQ_REGISTER)

{

body=my_object;

}

else

{

body=json_object_new_object();

if(req_type==REQ_SUBMIT)

{

int ms_async;

(*p_order_id)++;

ms_async=msync((void*)p_order_id,(size_t)sizeof(unsigned int),MS_ASYNC);

if(ms_async==-1)

perror("MSYNC_ERROR");

json_object_object_add(body, AMOUNT, json_object_new_string(amount));

}

json_object_object_add(body, MACHINE_ID, json_object_new_int(machine_id));

json_object_object_add(body, ORDER_ID, json_object_new_int(*p_order_id));

}

json_object_object_add(json, BODY, body);

str=json_object_to_json_string(json);

ghttp_set_body(request, str, strlen(str));

http_status=ghttp_process(request);

fd_net=ghttp_get_socket(request);

// json_object_put(body);

json_object_put(json);

}

static int http_response_process(void * arg)

{

struct json_object *resp;

if(ghttp_process(request)==ghttp_done)

{

resp=json_tokener_parse(ghttp_get_body(request));

resp_ret.type=json_object_get_int(json_object_object_get(resp,RESP_TYPE));

resp_ret.result=json_object_get_int(json_object_object_get(resp,RESP_RESULT));

if(resp_ret.type==REQ_REGISTER)

{

json_object_object_del(resp, RESP_TYPE);

json_object_to_file((char *)arg,resp);

}

else

{

if((resp_ret.type==REQ_SUBMIT)&&(!resp_ret.result))

{

sprintf(qrcode_buf,format_qrcode,machine_id,*p_order_id,info_version);

pid_t pid=vfork();

if(!pid)

execlp("qrencode","qrencode","-s 6","-m 2","-lH","-oqrcode.png",qrcode_buf,0);

else

wait(NULL);

}

}

json_object_put(resp);

return 0;

}

else

return -1;

}

static void usb_cb (EV_P_ ev_io *w, int revents)

{

switch(usb_in_buf[0])

{

case 'N':

{

if(status==READY)

{

http_request(REQ_SUBMIT);

net_io=1;

status=SUBMIT;

update_display("qrcode.png",1);

}

break;

}

case 'C':

{

if(status==WAIT)

{

http_request(REQ_CANCEL);

net_io=1;

status=CANCEL;

}

else

{

status=READY;

update_display("default.png",0);

}

break;

}

}

memset(usb_in_buf,0,USB_BUF_SIZE);

ev_break (EV_A_ EVBREAK_ALL);

}

static void net_cb (EV_P_ ev_io *w, int revents)

{

if(http_response_process(NULL))

{

net_io=0;

if((resp_ret.type==REQ_SUBMIT)&&(!resp_ret.result))

{

http_request(REQ_QUERY);

net_io=1;

status=WAIT;

}

else

{

status=READY;

update_display("default.png",0);

}

write_to_usb(resp_ret.type,resp_ret.type);

}

ghttp_flush_response_buffer(request);

ev_break (EV_A_ EVBREAK_ALL);

}

static int init(const char *config_file,const char *orderid_file)

{

int fd_order;

request = ghttp_request_new();

my_object = json_object_from_file(config_file);

machine_id = json_object_get_int(json_object_object_get(my_object,MACHINE_ID));

info_version = json_object_get_int(json_object_object_get(my_object,INFO_VERSION));

format_qrcode = json_object_get_string(json_object_object_get(my_object,ENCODE_FORMAT));

fd_order=open(orderid_file,O_RDWR);

if(fd_order==-1)

{

int order_id=0;

fd_order=open(orderid_file,O_RDWR|O_CREAT,0666);

write(fd_order,(void*)&order_id,sizeof(unsigned int));

lseek(fd_order,0,SEEK_SET);

}

p_order_id=(unsigned int*)mmap(NULL,sizeof(unsigned int),PROT_READ|PROT_WRITE,MAP_SHARED,fd_order,0);

if(p_order_id==-1)

return -3;

ghttp_set_uri(request, json_object_get_string(json_object_object_get(my_object,HOST)));

ghttp_prepare(request);

ghttp_set_sync(request, ghttp_async);

ghttp_set_type(request, ghttp_type_post);

ghttp_set_header(request, http_hdr_Connection, "keep-alive");

http_request(REQ_REGISTER);

while(http_response_process((void*)config_file)==-1);

ghttp_flush_response_buffer(request);

return 0;

}

void *MainService(void * arg)

{

status=INITIALIZE;

if(init("config","orderid")){

puts("Initialization error.");

exit(1);

}

else

status=READY;

update_display("default.png",0);

libusb_init(NULL);

handle=libusb_open_device_with_vid_pid(NULL,USB_VENDORID,USB_PRODUCTID);

if(!handle)

{

printf("OPEN DEVICE ERROR.\n");

getchar();

exit(1);

}

libusb_claim_interface(handle,0);

pthread_t readusb_thread;

main_thread=pthread_self();

struct ev_loop *loop = EV_DEFAULT;

ev_init (&net_watcher, net_cb);

ev_signal_init(&usb_watcher,usb_cb,SIGUSR1);

ev_signal_start(loop,&usb_watcher);

if(pthread_create(&readusb_thread,NULL,read_from_usb,NULL))

{

printf("CREATE THREAD ERROR.\n");

getchar();

exit(1);

}

while(1)

{

if(!ev_is_active(EV_A_ &net_watcher))

{

ev_io_set (&net_watcher, fd_net, EV_READ);

ev_io_start(loop,&net_watcher);

}

ev_run (loop, 0);

if(net_io)

ev_io_stop (EV_A_ &net_watcher);

}

munmap((void *)p_order_id,sizeof(unsigned int));

ghttp_close(request);

ghttp_request_destroy(request);

return 0;

}