/************************************************************************************
   Copyright (C) 2013,2016 MariaDB Corporation AB
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
   
   You should have received a copy of the GNU Library General Public
   License along with this library; if not see <http://www.gnu.org/licenses>
   or write to the Free Software Foundation, Inc., 
   51 Franklin St., Fifth Floor, Boston, MA 02110, USA
*************************************************************************************/
#include <ma_odbc.h>

extern Client_Charset utf8;

/* {{{ MADB_ErrorList[] */
MADB_ERROR MADB_ErrorList[] =
{
  { "00000", "", "", SQL_ERROR},
  { "01000", "", "General warning", SQL_ERROR},
  { "01001", "01S03", "Cursor operation conflict", SQL_ERROR},
  { "01002", "", "Disconnect error", SQL_ERROR},
  { "01003", "", "NULL value eliminated in set function", SQL_ERROR},
  { "01004", "", "String data, right-truncated", SQL_ERROR},
  { "01006", "", "Privilege not revoked", SQL_ERROR},
  { "01007", "", "Privilege not granted", SQL_ERROR},
  { "01S00", "", "Invalid connection string attribute", SQL_ERROR},
  { "01S01", "", "Error in row", SQL_ERROR},
  { "01S02", "", "Option value changed", SQL_ERROR},
  { "01S06", "", "Attempt to fetch before the result set returned the first rowset", SQL_ERROR},
  { "01S07", "", "Fractional truncation", SQL_ERROR},
  { "01S08", "", "Error saving File DSN", SQL_ERROR},
  { "01S09", "", "Invalid keyword", SQL_ERROR},
  { "07001", "", "Wrong number of parameters", SQL_ERROR},
  { "07002", "", "COUNT field incorrect", SQL_ERROR},
  { "07005", "2400", "Prepared statement not a cursor-specification", SQL_ERROR},
  { "07006", "", "Restricted data type attribute violation", SQL_ERROR},
  { "07009", "S1002", "Invalid descriptor index", SQL_ERROR},
  { "07S01", "", "Invalid use of default parameter", SQL_ERROR},
  { "08001", "", "Client unable to establish connection", SQL_ERROR},
  { "08002", "", "Connection name in use", SQL_ERROR},
  { "08003", "", "Connection not open", SQL_ERROR},
  { "08004", "", "Server rejected the connection", SQL_ERROR},
  { "08007", "", "Connection failure during transaction", SQL_ERROR},
  { "08S01", "", "Communication link failure", SQL_ERROR},
  { "21S01", "", "Insert value list does not match column list", SQL_ERROR},
  { "21S02", "", "Degree of derived table does not match column list", SQL_ERROR},
  { "22001", "", "String data, right-truncated", SQL_ERROR},
  { "22002", "", "Indicator variable required but not supplied", SQL_ERROR},
  { "22003", "", "Numeric value out of range", SQL_ERROR},
  { "22007", "22008", "Invalid datetime format", SQL_ERROR},
  { "22008", "", "Datetime field overflow", SQL_ERROR},
  { "22012", "", "Division by zero", SQL_ERROR},
  { "22015", "", "Interval field overflow", SQL_ERROR},
  { "22018", "22005", "Invalid character value for cast specification", SQL_ERROR},
  { "22019", "", "Invalid escape character", SQL_ERROR},
  { "22025", "", "Invalid escape sequence", SQL_ERROR},
  { "22026", "", "String data, length mismatch", SQL_ERROR},
  { "23000", "", "Integrity constraint violation", SQL_ERROR},
  { "24000", "", "Invalid cursor state", SQL_ERROR},
  { "25000", "", "Invalid transaction state", SQL_ERROR},
  { "25S01", "", "Transaction state", SQL_ERROR},
  { "25S02", "", "Transaction is still active", SQL_ERROR},
  { "25S03", "", "Transaction is rolled back", SQL_ERROR},
  { "28000", "", "Invalid authorization specification", SQL_ERROR},
  { "34000", "", "Invalid cursor name", SQL_ERROR},
  { "3C000", "", "Duplicate cursor name", SQL_ERROR},
  { "3D000", "", "Invalid catalog name", SQL_ERROR},
  { "3F000", "", "Invalid schema name", SQL_ERROR},
  { "40001", "", "Serialization failure", SQL_ERROR},
  { "40002", "", "Integrity constraint violation", SQL_ERROR},
  { "40003", "", "Statement completion unknown", SQL_ERROR},
  { "42000", "37000", "Syntax error or access violation", SQL_ERROR},
  { "42S01", "S0001", "Base table or view already exists", SQL_ERROR},
  { "42S02", "S0002", "Base table or view not found", SQL_ERROR},
  { "42S11", "S0011", "Index already exists", SQL_ERROR},
  { "42S12", "S0012", "Index not found", SQL_ERROR},
  { "42S21", "S0021", "Column already exists", SQL_ERROR},
  { "42S22", "S0022", "Column not found", SQL_ERROR},
  { "44000", "", "WITH CHECK OPTION violation", SQL_ERROR},
  { "HY000", "S1000", "General error", SQL_ERROR},
  { "HY001", "S1001", "Memory allocation error", SQL_ERROR},
  { "HY003", "S1003", "Invalid application buffer type", SQL_ERROR},
  { "HY004", "S1004", "Invalid SQL data type", SQL_ERROR},
  { "HY007", "S1010", "Associated statement is not prepared", SQL_ERROR},
  { "HY008", "S1008", "Operation canceled", SQL_ERROR},
  { "HY009", "S1009", "Invalid use of null pointer", SQL_ERROR},
  { "HY010", "S1010", "Function sequence error", SQL_ERROR},
  { "HY011", "S1011", "Attribute cannot be set now", SQL_ERROR},
  { "HY012", "S1012", "Invalid transaction operation code", SQL_ERROR},
  { "HY013", "", "Memory management error", SQL_ERROR},
  { "HY014", "", "Limit on the number of handles exceeded", SQL_ERROR},
  { "HY015", "", "No cursor name available", SQL_ERROR},
  { "HY016", "", "Cannot modify an implementation row descriptor", SQL_ERROR},
  { "HY017", "", "Invalid use of an automatically allocated descriptor handle", SQL_ERROR},
  { "HY018", "70100", "Server declined cancel request", SQL_ERROR},
  { "HY019", "22003", "Non-character and non-binary data sent in pieces", SQL_ERROR},
  { "HY020", "", "Attempt to concatenate a null value", SQL_ERROR},
  { "HY021", "", "Inconsistent descriptor information", SQL_ERROR},
  { "HY024", "S1009", "Invalid attribute value", SQL_ERROR},
  { "HY090", "S1009", "Invalid string or buffer length", SQL_ERROR},
  { "HY091", "S1091", "Invalid descriptor field identifier", SQL_ERROR},
  { "HY092", "S1092", "Invalid attribute/option identifier", SQL_ERROR},
  { "HY095", "", "Function type out of range", SQL_ERROR},
  { "HY096", "S1096", "Invalid information type", SQL_ERROR},
  { "HY097", "S1097", "Column type out of range", SQL_ERROR},
  { "HY098", "S1098", "Scope type out of range", SQL_ERROR},
  { "HY099", "S1099", "Nullable type out of range", SQL_ERROR},
  { "HY100", "S1100", "Uniqueness option type out of range", SQL_ERROR},
  { "HY101", "S1101", "Accuracy option type out of range", SQL_ERROR},
  { "HY103", "S1103", "Invalid retrieval code", SQL_ERROR},
  { "HY104", "S1104", "Invalid precision or scale value", SQL_ERROR},
  { "HY105", "S1105", "Invalid parameter type", SQL_ERROR},
  { "HY106", "S1106", "Fetch type out of range", SQL_ERROR},
  { "HY107", "S1107", "Row value out of range", SQL_ERROR},
  { "HY109", "S1109", "Invalid cursor position", SQL_ERROR},
  { "HY110", "S1110", "Invalid driver completion", SQL_ERROR},
  { "HY111", "S1111", "Invalid bookmark value", SQL_ERROR},
  { "HYC00", "S1C00", "Optional feature not implemented", SQL_ERROR},
  { "HYT00", "S1T00", "Timeout expired", SQL_ERROR},
  { "HYT01", "", "Connection timeout expired", SQL_ERROR},
  { "IM001", "", "Driver does not support this function", SQL_ERROR},
  { "IM002", "", "Data source name not found and no default driver specified", SQL_ERROR},
  { "IM003", "", "Specified driver could not be loaded", SQL_ERROR},
  { "IM004", "", "Driver's SQLAllocHandle on SQL_HANDLE_ENV failed", SQL_ERROR},
  { "IM005", "", "Driver's SQLAllocHandle on SQL_HANDLE_DBC failed", SQL_ERROR},
  { "IM006", "", "Driver's SQLSetConnectAttr failed", SQL_ERROR},
  { "IM007", "", "No data source or driver specified; dialog prohibited", SQL_ERROR},
  { "IM008", "", "Dialog failed", SQL_ERROR},
  { "IM009", "", "Unable to load translation DL", SQL_ERROR},
  { "IM010", "", "Data source name too long", SQL_ERROR},
  { "IM011", "", "Driver name too long", SQL_ERROR},
  { "IM012", "", "DRIVER keyword syntax error", SQL_ERROR},
  { "IM013", "", "Trace file error", SQL_ERROR},
  { "IM014", "", "Invalid name of File DSN", SQL_ERROR},
  { "IM015", "", "Corrupt file data source", SQL_ERROR},
  { "S1000", "", "General error", SQL_ERROR},
  { "S1107", "", "Row value out of range", SQL_ERROR},
  { "S1C00", "", "Optional feature not implemented", SQL_ERROR},
  { 0,0,0, -1}
};
/* }}} */


char* MADB_PutErrorPrefix(MADB_Dbc *dbc, MADB_Error *error)
{
  /* If prefix is already there - we do not write again. One shoud reset error->PrefixLen in order to force */
  if (error->PrefixLen == 0)
  {
    error->PrefixLen= strlen(MARIADB_ODBC_ERR_PREFIX);
    strcpy_s(error->SqlErrorMsg, SQL_MAX_MESSAGE_LENGTH + 1, MARIADB_ODBC_ERR_PREFIX);
    if (dbc != NULL && dbc->mariadb != NULL)
    {
      error->PrefixLen += _snprintf(error->SqlErrorMsg + error->PrefixLen,
        SQL_MAX_MESSAGE_LENGTH + 1 - error->PrefixLen, "[%s]", mysql_get_server_info(dbc->mariadb)); 
    }
  }
  return error->SqlErrorMsg + error->PrefixLen;
}


SQLRETURN MADB_SetNativeError(MADB_Error *Error, SQLSMALLINT HandleType, void *Ptr)
{
  char *Sqlstate= NULL, *Errormsg= NULL;
  int NativeError= 0;

  switch (HandleType) {
  case SQL_HANDLE_DBC:
    Sqlstate= (char *)mysql_sqlstate((MYSQL *)Ptr);
    Errormsg= (char *)mysql_error((MYSQL *)Ptr);
    NativeError= mysql_errno((MYSQL *)Ptr);
    break;
  case SQL_HANDLE_STMT:
    Sqlstate= (char *)mysql_stmt_sqlstate((MYSQL_STMT *)Ptr);
    Errormsg= (char *)mysql_stmt_error((MYSQL_STMT *)Ptr);
    NativeError= mysql_stmt_errno((MYSQL_STMT *)Ptr);
    break;
  }
  /* work-around of probalby a bug in mariadb_stmt_execute_direct, that returns 1160 in case of lost connection */
  if ((NativeError == 2013 || NativeError == 2006 || NativeError == 1160) && (strcmp(Sqlstate, "HY000") == 0 || strcmp(Sqlstate, "00000") == 0))
  {
    Sqlstate= "08S01";
  }

  Error->ReturnValue= SQL_ERROR;
  if (Errormsg)
  {
    strcpy_s(Error->SqlErrorMsg + Error->PrefixLen, SQL_MAX_MESSAGE_LENGTH + 1 - Error->PrefixLen, Errormsg);
  }
  if (Sqlstate)
    strcpy_s(Error->SqlState, SQLSTATE_LENGTH + 1, Sqlstate);
  Error->NativeError= NativeError;
  if (Error->SqlState[0] == '0')
    Error->ReturnValue= (Error->SqlState[1] == '0') ? SQL_SUCCESS :
                        (Error->SqlState[1] == '1') ? SQL_SUCCESS_WITH_INFO : SQL_ERROR;

  return Error->ReturnValue;
}

/* {{{ MADB_SetError */
SQLRETURN MADB_SetError(MADB_Error  *Error,
                        unsigned int SqlErrorCode,
                        const char  *NativeErrorMsg,
                        unsigned int NativeError)
{
  unsigned int ErrorCode= SqlErrorCode;

  Error->ErrorNum= 0;
  if ((NativeError == 2013 || NativeError == 2006 || NativeError == 1160) && SqlErrorCode == MADB_ERR_HY000)
    ErrorCode= MADB_ERR_08S01;

  Error->ErrRecord= &MADB_ErrorList[ErrorCode];

  Error->ReturnValue= SQL_ERROR;

  if (NativeErrorMsg)
  {
    strcpy_s(Error->SqlErrorMsg + Error->PrefixLen, SQL_MAX_MESSAGE_LENGTH + 1 - Error->PrefixLen, NativeErrorMsg);
  }
  else
  {
    strcpy_s(Error->SqlErrorMsg + Error->PrefixLen, SQL_MAX_MESSAGE_LENGTH + 1 - Error->PrefixLen,
             MADB_ErrorList[ErrorCode].SqlErrorMsg);
  }
  strcpy_s(Error->SqlState, SQLSTATE_LENGTH + 1, MADB_ErrorList[ErrorCode].SqlState);
  Error->NativeError= NativeError;
  /* Check the return code */
  if (Error->SqlState[0] == '0')
    Error->ReturnValue= (Error->SqlState[1] == '0') ? SQL_SUCCESS :
                        (Error->SqlState[1] == '1') ? SQL_SUCCESS_WITH_INFO : SQL_ERROR;

  return Error->ReturnValue;
}
/* }}} */

/* {{{ MADB_CopyError */
void MADB_CopyError(MADB_Error *ErrorTo, MADB_Error *ErrorFrom)
{
  ErrorTo->NativeError= ErrorFrom->NativeError;
  ErrorTo->ReturnValue= ErrorFrom->ReturnValue;
  ErrorTo->PrefixLen=   ErrorFrom->PrefixLen;
  strcpy_s(ErrorTo->SqlState, SQLSTATE_LENGTH + 1, ErrorFrom->SqlState);
  strcpy_s(ErrorTo->SqlErrorMsg, SQL_MAX_MESSAGE_LENGTH + 1, ErrorFrom->SqlErrorMsg);
}
/* }}} */

/* {{{ MADB_GetDiagRec */
SQLRETURN MADB_GetDiagRec(MADB_Error *Err, SQLSMALLINT RecNumber,
                         void *SQLState, SQLINTEGER *NativeErrorPtr,
                         void *MessageText, SQLSMALLINT BufferLength,
                         SQLSMALLINT *TextLengthPtr, my_bool isWChar,
                         SQLINTEGER OdbcVersion)
{
  MADB_Error InternalError;
  char *SqlStateVersion= Err->SqlState;
  SQLSMALLINT Length= 0;

  InternalError.PrefixLen= 0;
  MADB_CLEAR_ERROR(&InternalError);
  if (RecNumber > 1)
    return SQL_NO_DATA;
  
  /* check if we have to map the SQLState to ODBC version 2 state */
  if (OdbcVersion == SQL_OV_ODBC2)
  {
    int i= 0;
    while (MADB_ErrorList[i].SqlState[0])
    {
      if (strcmp(Err->SqlState, MADB_ErrorList[i].SqlState) == 0)
      {
        if (MADB_ErrorList[i].SqlStateV2[0])
          SqlStateVersion= MADB_ErrorList[i].SqlStateV2;
        break;
      }
      ++i;
    }
  }

  if (NativeErrorPtr)
    *NativeErrorPtr= Err->NativeError;
  if (SQLState)
    MADB_SetString(isWChar ?  &utf8 : 0, (void *)SQLState, SQL_SQLSTATE_SIZE + 1,
                   SqlStateVersion, SQL_SQLSTATE_SIZE, &InternalError);
   if (MessageText)
     Length=  (SQLSMALLINT)MADB_SetString(isWChar ?  &utf8 : 0, (void*)MessageText, BufferLength,
                   Err->SqlErrorMsg, strlen(Err->SqlErrorMsg), &InternalError);
   if (TextLengthPtr)
     *TextLengthPtr= (SQLSMALLINT)strlen(Err->SqlErrorMsg);
   
   if (!MessageText || !BufferLength)
     return SQL_SUCCESS;
   return InternalError.ReturnValue;
}
/* }}} */

/* {{{ MADB_GetDiagField */
SQLRETURN MADB_GetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
                            SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier, SQLPOINTER
                            DiagInfoPtr, SQLSMALLINT BufferLength,
                            SQLSMALLINT *StringLengthPtr, my_bool isWChar)
{
  MADB_Error *Err=  NULL;
  MADB_Stmt  *Stmt= NULL;
  MADB_Desc  *Desc= NULL;
  MADB_Dbc   *Dbc=  NULL;
  MADB_Env   *Env=  NULL;
  MADB_Error  Error;
  SQLLEN      Length;

  if (StringLengthPtr)
    *StringLengthPtr= 0;

  Error.PrefixLen= 0;
  MADB_CLEAR_ERROR(&Error);

  if (RecNumber > 1)
    return SQL_NO_DATA;

  switch(HandleType) {
  case SQL_HANDLE_DBC:
    Dbc= (MADB_Dbc *)Handle;
    Err= &Dbc->Error;
    break;
  case SQL_HANDLE_STMT:
    Stmt= (MADB_Stmt *)Handle;
    Err= &Stmt->Error;
    break;
  case SQL_HANDLE_ENV:
    Env= (MADB_Env *)Handle;
    Err= &Env->Error;
    break;
   case SQL_HANDLE_DESC:
     Desc= (MADB_Desc *)Handle;
     Err= &Desc->Error;
     break;
   default:
     return SQL_INVALID_HANDLE;
  }

  switch(DiagIdentifier) {
  case SQL_DIAG_CURSOR_ROW_COUNT:
    if (!Stmt)
      return SQL_ERROR;
    *(SQLLEN *)DiagInfoPtr= (Stmt->result) ?(SQLLEN)mysql_stmt_num_rows(Stmt->stmt) : 0;
    break;
  case SQL_DIAG_DYNAMIC_FUNCTION:
    if (!Stmt)
      return SQL_ERROR;
    /* Todo */
    break;
  case SQL_DIAG_DYNAMIC_FUNCTION_CODE:
    if (!Stmt)
      return SQL_ERROR;
    *(SQLINTEGER *)DiagInfoPtr= 0;
    break;
  case SQL_DIAG_NUMBER:
    *(SQLINTEGER *)DiagInfoPtr= 1;
    break;
  case SQL_DIAG_RETURNCODE:
    *(SQLRETURN *)DiagInfoPtr= Err->ReturnValue;
    break;
  case SQL_DIAG_ROW_COUNT:
    if (HandleType != SQL_HANDLE_STMT ||
        !Stmt)
      return SQL_ERROR;
    *(SQLLEN *)DiagInfoPtr= (Stmt->stmt) ? (SQLLEN)mysql_stmt_affected_rows(Stmt->stmt) : 0;
    break;
  case SQL_DIAG_CLASS_ORIGIN:
    Length= MADB_SetString(isWChar ?  &utf8 : 0, DiagInfoPtr,  isWChar ? BufferLength / sizeof(SQLWCHAR) : BufferLength,
                                     strncmp(Err->SqlState, "IM", 2)== 0 ? "ODBC 3.0" : "ISO 9075", SQL_NTS, &Error);
    if (StringLengthPtr)
      *StringLengthPtr= (SQLSMALLINT)Length;
    break;
  case SQL_DIAG_COLUMN_NUMBER:
    *(SQLINTEGER *)DiagInfoPtr= SQL_COLUMN_NUMBER_UNKNOWN;
    break;
  case SQL_DIAG_CONNECTION_NAME:
    /* MariaDB ODBC Driver always returns an empty string */
    if (StringLengthPtr)
      *StringLengthPtr= 0;
    DiagInfoPtr= (isWChar) ? (SQLPOINTER)L"" : (SQLPOINTER)"";
    break;
  case SQL_DIAG_MESSAGE_TEXT:
    Length= MADB_SetString(isWChar ?  &utf8 : 0, DiagInfoPtr,  isWChar ? BufferLength / sizeof(SQLWCHAR) : BufferLength,
                                     Err->SqlErrorMsg, strlen(Err->SqlErrorMsg), &Error);
    if (StringLengthPtr)
      *StringLengthPtr= (SQLSMALLINT)Length;
    break;
  case SQL_DIAG_NATIVE:
    *(SQLINTEGER *)DiagInfoPtr= Err->NativeError;
    break;
  case SQL_DIAG_ROW_NUMBER:
     if (HandleType != SQL_HANDLE_STMT ||
         RecNumber < 1)
       return SQL_ERROR;
      *(SQLLEN*)DiagInfoPtr= SQL_ROW_NUMBER_UNKNOWN;
    break;
  case SQL_DIAG_SERVER_NAME:
    {
      char *ServerName= "";
      if (Stmt && Stmt->stmt)
      {
        mariadb_get_infov(Stmt->stmt->mysql, MARIADB_CONNECTION_HOST, (void*)&ServerName);
      }
      else if (Dbc && Dbc->mariadb)
      {
        mariadb_get_infov(Dbc->mariadb, MARIADB_CONNECTION_HOST, (void*)&ServerName);
      }
      Length= MADB_SetString(isWChar ?  &utf8 : 0, DiagInfoPtr, 
                                        isWChar ? BufferLength / sizeof(SQLWCHAR) : BufferLength, 
                                        ServerName ? ServerName : "", ServerName ? strlen(ServerName) : 0, &Error);
      if (StringLengthPtr)
        *StringLengthPtr= (SQLSMALLINT)Length;
    }
    break;
  case SQL_DIAG_SQLSTATE:
    Length= MADB_SetString(isWChar ?  &utf8 : 0, DiagInfoPtr, 
                           isWChar ? BufferLength / sizeof(SQLWCHAR) : BufferLength, Err->SqlState, strlen(Err->SqlState), &Error);
    if (StringLengthPtr)
      *StringLengthPtr= (SQLSMALLINT)Length;
   
    break;
  case SQL_DIAG_SUBCLASS_ORIGIN:
    Length= MADB_SetString(isWChar ?  &utf8 : 0, DiagInfoPtr, 
                           isWChar ? BufferLength / sizeof(SQLWCHAR) : BufferLength, "ODBC 3.0", 8, &Error);
    if (StringLengthPtr)
      *StringLengthPtr= (SQLSMALLINT)Length;
    break;
  default:
    return SQL_ERROR;
  }
  if (isWChar && StringLengthPtr)
    *StringLengthPtr*= sizeof(SQLWCHAR);
  return Error.ReturnValue;
}