#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define CONNECTION_TARGET "tcp:postgresql://localhost:5432/postgres"

#define MAX_BUFFER_SIZE 256
#define MAX_STEPS 3

#define FALSE 0
#define TRUE 1

static int thread_step = 0;

static pthread_mutex_t thread1_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t thread2_lock = PTHREAD_MUTEX_INITIALIZER;

/* Wait flag of thread execution */
static int thread1_waiting = FALSE;
static int thread2_waiting = FALSE;

static void* thread_main1(void*);
static void* thread_main2(void*);

void
print_sqlca()
{
    fprintf(stderr, "==== sqlca ====\n");
    fprintf(stderr, "sqlcode: %ld\n", sqlca.sqlcode);
    fprintf(stderr, "sqlerrm.sqlerrml: %d\n", sqlca.sqlerrm.sqlerrml);
    fprintf(stderr, "sqlerrm.sqlerrmc: %s\n", sqlca.sqlerrm.sqlerrmc);
    fprintf(stderr, "sqlerrd: %ld %ld %ld %ld %ld %ld\n", sqlca.sqlerrd[0],sqlca.sqlerrd[1],sqlca.sqlerrd[2],
                                                          sqlca.sqlerrd[3],sqlca.sqlerrd[4],sqlca.sqlerrd[5]);
    fprintf(stderr, "sqlwarn: %d %d %d %d %d %d %d %d\n", sqlca.sqlwarn[0], sqlca.sqlwarn[1], sqlca.sqlwarn[2],
                                                          sqlca.sqlwarn[3], sqlca.sqlwarn[4], sqlca.sqlwarn[5],
                                                          sqlca.sqlwarn[6], sqlca.sqlwarn[7]);
    fprintf(stderr, "sqlstate: %5s\n", sqlca.sqlstate);
    fprintf(stderr, "===============\n");
}

EXEC SQL WHENEVER sqlerror do print_sqlca();

/* Setter of global wait flags */
static void
setThread1Status(int status)
{
    pthread_mutex_lock(&thread1_lock);
    thread1_waiting = status;
    pthread_mutex_unlock(&thread1_lock);
}

static void
setThread2Status(int status)
{
    pthread_mutex_lock(&thread2_lock);
    thread2_waiting = status;
    pthread_mutex_unlock(&thread2_lock);
}

/* Thead#1 */
static void*
thread_main1(void* param)
{
    /* DECLARE SECTION */
    EXEC SQL BEGIN DECLARE SECTION;
    int pid;
    char    *connection_target = CONNECTION_TARGET;
    EXEC SQL END DECLARE SECTION;

    /* Main loop : controlled by thread_step */
    while(thread_step < MAX_STEPS)
    {
        /* Wait for Thread#2 */
        while ( thread1_waiting == TRUE ){
            sleep(1);
        }

        switch(thread_step)
        {
        case 0:
            /* Thread#1 1. CONNECT TO database */
            EXEC SQL CONNECT TO :connection_target;
            break;

        case 1:
            /* Thread#2 2. Execute SQL on CURRENT connection */
            /* Thread#2 3. DISCONNECT */
            /* Thread#2 4. CONNECT TO database */
            break;

        case 2:
	    /* Thread#1 5. Execute SQL on CURRENT connection */
	    EXEC SQL PREPARE foo FROM "SELECT pg_backend_pid()";     /* In this line, app takes error */
            EXEC SQL EXECUTE foo INTO :pid;
            printf("Thread#1: Second backend pid : %d\n", pid);

            /* Thread#1 6. DISCONNECT */
            EXEC SQL DISCONNECT;
            break;

        default:
            break;
        }
        /* Set flag to wait for Thread#2 */
        setThread1Status(TRUE);
    }

    return NULL;
}

/* Thread#2 */
static void*
thread_main2(void* param)
{
    /* DECLARE SECTION */
    EXEC SQL BEGIN DECLARE SECTION;
    int pid;
    char    *connection_target = CONNECTION_TARGET;
    EXEC SQL END DECLARE SECTION;

    /* Main loop : controlled by thread_step */
    while(thread_step < MAX_STEPS)
    {
        /* Wait for Thread#2 */
        while ( thread2_waiting == TRUE ){
            sleep(1);
        }

        switch(thread_step)
        {
        case 0:
	    /* Thread#1 1. CONNECT TO database */
            break;

        case 1:
            /* Thread#2 2. Execute SQL on CURRENT connection */
	    EXEC SQL PREPARE foo2 FROM "SELECT pg_backend_pid()";
            EXEC SQL EXECUTE foo2 INTO :pid;
            printf("Thread#2: First backend pid : %d\n",  pid);

            /* Thread#2 3. DISCONNECT */
	    EXEC SQL DISCONNECT;

            /* Thread#2 4. CONNECT TO database */
	    EXEC SQL CONNECT TO :connection_target; 
            break;

	case 2:
	    /* Thread#1 5. Execute SQL on CURRENT connection */
            /* Thread#1 6. DISCONNECT */

        default:
            break;
        }
        /* Set flag to wait for Thread#2 */
        setThread2Status(TRUE);
    }

    return NULL;
}


int
main (void)
{
    pthread_t t1;
    pthread_t t2;
    int i;

    /* create thread */
    printf("create_thread\n");
    thread_step = 0;
    setThread1Status(FALSE);
    setThread2Status(FALSE);

    if ( pthread_create(&t1, NULL, thread_main1, NULL) != 0){
        perror("Failed to create Thread1.");
        exit(1);
    }

    if ( pthread_create(&t2, NULL, thread_main2, NULL) != 0){
        perror("Failed to create Thread2.");
        exit(1);
    }

    /* Run threads */
    for ( i = 0; i < MAX_STEPS; ++i)
    {
        thread_step = i;

        /* Wake up each Thread */
        setThread1Status(FALSE);
        setThread2Status(FALSE);
        printf(" -- STEP[%d] --\n", thread_step);

        /* Wait for each thread to finish the step */
        while ((thread1_waiting == FALSE) ||
               (thread2_waiting == FALSE))
        {
            sleep(1);
        }
    }

    printf("thread_finished\n");

    return 0;
}



