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

#include "global.h"

/*

MySQLtoPostgres - Copyright 2000-2006 by Michael Kohn
mike@mikekohn.net
http://www.mikekohn.net/

This program falls under the GPL license.

*/

void parse_mysql_affected_rows(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"pg_affected_rows(%s)",param1);

}

void parse_mysql_change_user(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_change_user() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_change_user() not supported.\n");

}

void parse_mysql_close(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"pg_close(%s)",param1);
}

void parse_mysql_connect(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* fprintf("pg_connect(%s,%s,%s,,%s)",param1,param2,param3,mp2p->dbname); */
  fprintf(mp2p->out,"pg_connect(\"dbname=%s host=\".%s.\" user=\".%s.\" password=\".%s)",mp2p->dbname,param1,param2,param3);
}

void parse_mysql_create_db(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  if (strcmp(param2,"")==0) sprintf(param2,"%s",mp2p->convar);

  /* fprintf(mp2p->out,"pg_query(%s,'create database %s')",param2,param1,mp2p->convar); */
  fprintf(mp2p->out,"pg_query(%s,'create database %s')",param2,param1);
}

void parse_mysql_data_seek(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

/* can't find an equivlant right now */
  printf("Warning: mysql_data_seek() not supported.\n");
  fprintf(mp2p->out,"// Warning: mysql_data_seek() not supported.\n");

}

void parse_mysql_db_query(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  if (strcmp(param3,"")==0) sprintf(param3,"%s",mp2p->convar);

/*
  if (cflag==0)
  { fprintf(mp2p->out,"pg_query(%s,%s);",param3,param2); }
    else
  { fprintf(mp2p->out,"pg_query(%s,%s); %s_countt=0",param3,param2,mp2p->convar); }
*/

  fprintf(mp2p->out,"pg_query(%s,%s);",param3,param2);

  printf("Warning: mysql_db_query() doesn't have an equivlant postgres function. Could create problems.\n");
}

void parse_mysql_drop_db(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  if (strcmp(param2,"")==0) sprintf(param2,"%s",mp2p->convar);

  fprintf(mp2p->out,"pg_query(%s,'drop database %s')",param2,param1);
}

void parse_mysql_errno(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_errno() not supported.\n");
/* can't find an equivlant right now */

  getparameters(mp2p,param1,param2,param3);

  if (strcmp(param1,"")==0) sprintf(param1,"%s",mp2p->convar);

  fprintf(mp2p->out,"// Warning: mysql_errno() not supported.\n");
}

void parse_mysql_error(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  if (strcmp(param1,"")==0) sprintf(param1,"%s",mp2p->convar);

  fprintf(mp2p->out,"pg_result_error(%s)",param1);
}

void parse_mysql_fetch_array(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];
char result_type[8192];

strcpy(result_type,"PGSQL_BOTH");

  getparameters(mp2p,param1,param2,param3);

/*
  array mysql_fetch_array ( resource Ergebnis-Kennung [, int Ergebnistyp])
  array pg_fetch_array ( resource result [, int row [, int result_type]])
  result_type = PGSQL_ASSOC, PGSQL_NUM, PGSQL_BOTH
*/
  
  if (strlen(param2)!=0)
  { 
    if (strcmp("MYSQL_ASSOC",param2)==0) { strcpy(result_type,"PGSQL_ASSOC");}
    if (strcmp("MYSQL_NUM",param2)==0) { strcpy(result_type,"PGSQL_NUM");}
    if (strcmp("MYSQL_BOTH",param2)==0) { strcpy(result_type,"PGSQL_BOTH");}

    /* fprintf(mp2p->out,"pg_fetch_array(%s,%s_countt++,%s)",param1,param1,result_type); */
    fprintf(mp2p->out,"pg_fetch_array(%s,NULL,%s)",param1,result_type);
  }
    else
  { fprintf(mp2p->out,"pg_fetch_array(%s)",param1); }
  /* { fprintf(mp2p->out,"pg_fetch_array(%s,%s_countt++)",param1,param1); } */
}

void parse_mysql_fetch_assoc(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

/*
  array mysql_fetch_assoc ( resource Ergebnis)
  array pg_fetch_assoc ( resource result [, int row])
*/
  
  if (strlen(param2)!=0)
  { fprintf(mp2p->out,"pg_fetch_assoc(%s,%s)",param1,param2); }
    else
  { fprintf(mp2p->out,"pg_fetch_assoc(%s)",param1); }
}

void parse_mysql_fetch_field(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_fetch_field() not supported.\n");
/* can't find an equivlant right now */

  getparameters(mp2p,param1,param2,param3);
  
  fprintf(mp2p->out,"// Warning: mysql_fetch_field() not supported.\n");
}

void parse_mysql_fetch_lengths(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_fetch_lengths() not supported.\n");
/* can't find an equivlant right now */

  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_fetch_lengths() not supported.\n");
}

void parse_mysql_fetch_object(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* object pg_fetch_object ( resource result [, int row [, int result_type]]) */

  if (strlen(param2)!=0)
  { fprintf(mp2p->out,"pg_fetch_object(%s,NULL,%s)",param1,param2); }
  /* { fprintf(mp2p->out,"pg_fetch_object(%s,%s_countt++,%s)",param1,param1,param2); } */
    else
  { fprintf(mp2p->out,"pg_fetch_object(%s)",param1); }
  /* { fprintf(mp2p->out,"pg_fetch_object(%s,%s_countt++)",param1,param1); } */
  /* { fprintf(mp2p->out,"pg_fetch_object(%s,%s_countt++)",param1,param1,param2); } */
}

void parse_mysql_fetch_row(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* array pg_fetch_row ( resource result, int row) */

  if (strlen(param2)!=0)
  { fprintf(mp2p->out,"pg_fetch_row(%s,NULL,%s)",param1,param2); }
    else
  { fprintf(mp2p->out,"pg_fetch_row(%s)",param1); }
  /* { fprintf(mp2p->out,"pg_fetch_row(%s,%s_countt++)",param1,param1); } */
  /* { fprintf(mp2p->out,"pg_fetch_row(%s,%s_countt++)",param1,param1,param2); } */
}

void parse_mysql_field_name(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* string pg_field_name ( resource result, int field_number) */

  fprintf(mp2p->out,"pg_fieldname(%s,%s)",param1,param2);
}

void parse_mysql_field_seek(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_field_seek() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_field_seek() not supported.\n");
}

void parse_mysql_field_table(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_field_table() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_field_table() not supported.\n");
}

void parse_mysql_field_type(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* string pg_field_type ( resource result, int field_number) */

  fprintf(mp2p->out,"pg_field_type(%s,%s)",param1,param2);
}

void parse_mysql_field_flags(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_field_flags() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_field_flags() not supported.\n");
}

void parse_mysql_field_len(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* int pg_field_prtlen ( resource result, int row_number, string field_name) */

  fprintf(mp2p->out,"pg_field_prtlen(%s,%s,\"\")",param1,param2);
}

void parse_mysql_free_result(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* bool pg_free_result ( resource result) */

  fprintf(mp2p->out,"pg_free_result(%s)",param1);
}

void parse_mysql_insert_id(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* int mysql_insert_id ( [resource Verbindungs-Kennung]) */
  /* int pg_last_oid ( resource result) */
  printf("mysql_insert_id: pg_last_oid\n");
  printf("mysql_insert_id: For tables without OID use pg_result_status\n");
  
  fprintf(mp2p->out,"pg_last_oid(%s)",param1);
}

void parse_mysql_list_fields(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_list_fields() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_list_fields() not supported.\n");
}

void parse_mysql_list_dbs(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_list_dbs() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_list_dbs() not supported.\n");
}

void parse_mysql_list_tables(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_list_tables() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_list_tables() not supported.\n");
}

void parse_mysql_num_fields(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* int pg_num_fields ( resource result) */

  fprintf(mp2p->out,"pg_num_fields(%s)",param1);
}

void parse_mysql_num_rows(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* int pg_num_rows ( resource result) */

  fprintf(mp2p->out,"pg_num_rows(%s)",param1);
}

void parse_mysql_pconnect(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* resource pg_pconnect ( string connection_string) */

  /* fprintf("pg_connect(%s,%s,%s,,%s)",param1,param2,param3,mp2p->dbname); */
  fprintf(mp2p->out,"pg_pconnect(\"dbname=%s host=\".%s.\" user=\".%s.\" password=\".%s)",mp2p->dbname,param1,param2,param3);
}

void parse_mysql_ping(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  getparameters(mp2p,param1,param2,param3);

  /* bool pg_ping ( resource connection) */

  fprintf(mp2p->out,"pg_ping(%s)",param1);
}
void parse_mysql_query(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  param2[0]=0;
  getparameters(mp2p,param1,param2,param3);

  /* resource pg_query ( resource connection, string query) */

  /* if (strcmp(param2,"")==0) sprintf(param2,"%s",mp2p->convar); */
 
  if (param2[0]==0)
  { fprintf(mp2p->out,"pg_query(%s)",param1); }
    else
  { fprintf(mp2p->out,"pg_query(%s,%s)",param2,param1); }

}

void parse_mysql_result(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  /* printf("Warning: mysql_result() not supported.\n"); */
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  if (param3[0]==0)
  { fprintf(mp2p->out,"pg_query(%s,%s)",param1,param2); }
    else
  { fprintf(mp2p->out,"pg_query(%s,%s,%s)",param1,param2,param3); }

/*
  fprintf(mp2p->out,"// Warning: mysql_result() not supported.\n");
  fprintf(mp2p->out,"// Alternative: mysql_fetch_row(), mysql_fetch_array() und mysql_fetch_object()\n");
*/
}

void parse_mysql_select_db(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

/* can't find an equivlant right now */

  getparameters(mp2p,param1,param2,param3);

  printf("Warning: mysql_select_db() not supported.\n");

  if (param1[0]=='\'' || param1[0]=='\"')
  {
    strcpy(param3,&param1[1]);
    if (strlen(param3)>=1) param3[strlen(param3)-1]=0;

    if (strcmp(param3,mp2p->dbname)==0)
    { printf("%s == %s ..  This is a good thing.\n\n",param3,mp2p->dbname); }
      else
    {
      printf("Suggestion: mysqlphp2postgres -d %s %s %s\n\n",param3,mp2p->inname,mp2p->outname);
    }
  }
    else
  {
    printf("You will most likely have to edit this PHP code by hand to make it work.\n");
  }

  fprintf(mp2p->out,"// Warning: mysql_select_db() not supported.\n");
}

void parse_mysql_tablename(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_tablename() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_tablename() not supported.\n");
}

void parse_mysql_template(struct mp2p_context_t *mp2p)
{
char param1[8192];
char param2[8192];
char param3[8192];

  printf("Warning: mysql_() not supported.\n");
/* can't find an equivlant right now */
  getparameters(mp2p,param1,param2,param3);

  fprintf(mp2p->out,"// Warning: mysql_() not supported.\n");
}