/*

 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>

 *

 * This program is free software: you can use, redistribute, and/or modify

 * it under the terms of the GNU Affero General Public License, version 3

 * or later ("AGPL"), as published by the Free Software Foundation.

 *

 * This program 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.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#include "cmdnodes.h"

#include "nodesUtil.h"

#include "plannodes.h"

#include "querynodes.h"

#include "taos.h"

#include "taoserror.h"

#include "thash.h"

int32_t nodesNodeToSQLFormat(SNode *pNode, char *buf, int32_t bufSize, int32_t *len, bool longFormat);

const char *operatorTypeStr(EOperatorType type) {

  switch (type) {

    case OP_TYPE_ADD:

      return "+";

    case OP_TYPE_SUB:

      return "-";

    case OP_TYPE_MULTI:

      return "*";

    case OP_TYPE_DIV:

      return "/";

    case OP_TYPE_REM:

      return "%";

    case OP_TYPE_MINUS:

      return "-";

    case OP_TYPE_BIT_AND:

      return "&";

    case OP_TYPE_BIT_OR:

      return "|";

    case OP_TYPE_GREATER_THAN:

      return ">";

    case OP_TYPE_GREATER_EQUAL:

      return ">=";

    case OP_TYPE_LOWER_THAN:

      return "<";

    case OP_TYPE_LOWER_EQUAL:

      return "<=";

    case OP_TYPE_EQUAL:

      return "=";

    case OP_TYPE_NOT_EQUAL:

      return "<>";

    case OP_TYPE_IN:

      return "IN";

    case OP_TYPE_NOT_IN:

      return "NOT IN";

    case OP_TYPE_LIKE:

      return "LIKE";

    case OP_TYPE_NOT_LIKE:

      return "NOT LIKE";

    case OP_TYPE_MATCH:

      return "MATCH";

    case OP_TYPE_NMATCH:

      return "NMATCH";

    case OP_TYPE_IS_NULL:

      return "IS NULL";

    case OP_TYPE_IS_NOT_NULL:

      return "IS NOT NULL";

    case OP_TYPE_IS_TRUE:

      return "IS TRUE";

    case OP_TYPE_IS_FALSE:

      return "IS FALSE";

    case OP_TYPE_IS_UNKNOWN:

      return "IS UNKNOWN";

    case OP_TYPE_IS_NOT_TRUE:

      return "IS NOT TRUE";

    case OP_TYPE_IS_NOT_FALSE:

      return "IS NOT FALSE";

    case OP_TYPE_IS_NOT_UNKNOWN:

      return "IS NOT UNKNOWN";

    case OP_TYPE_EXISTS:

      return "EXISTS";

    case OP_TYPE_NOT_EXISTS:

      return "NOT EXISTS";

    case OP_TYPE_JSON_GET_VALUE:

      return "=>";

    case OP_TYPE_JSON_CONTAINS:

      return "CONTAINS";

    case OP_TYPE_ASSIGN:

      return "=";

    default:

      break;

  }

  return "UNKNOWN";

}

const char *operatorTypeStrEx(EOperatorType type, bool isNegative) {

  if (isNegative) {

    switch (type) {

      case OP_TYPE_IN:

        return "!= ANY";

      case OP_TYPE_NOT_IN:

        return "= ALL";

      default:

        break;

    }

    return "UNKNOWN";

  }

  return operatorTypeStr(type);

}

const char *logicConditionTypeStr(ELogicConditionType type) {

  switch (type) {

    case LOGIC_COND_TYPE_AND:

      return "AND";

    case LOGIC_COND_TYPE_OR:

      return "OR";

    case LOGIC_COND_TYPE_NOT:

      return "NOT";

    default:

      break;

  }

  return "UNKNOWN";

}

static int32_t sqlWindowBoundToSQL(SSqlWindowBound *pBound, char *buf, int32_t bufSize, int32_t *len) {

  switch (pBound->boundType) {

    case WINDOW_BOUND_UNBOUNDED_PRECEDING:

      *len += snprintf(buf + *len, bufSize - *len, "UNBOUNDED PRECEDING");

      return TSDB_CODE_SUCCESS;

    case WINDOW_BOUND_N_PRECEDING:

      if (NULL == pBound->pOffset) {

        return TSDB_CODE_FAILED;

      }

      NODES_ERR_RET(nodesNodeToSQLFormat(pBound->pOffset, buf, bufSize, len, true));

      *len += snprintf(buf + *len, bufSize - *len, " PRECEDING");

      return TSDB_CODE_SUCCESS;

    case WINDOW_BOUND_CURRENT_ROW:

      *len += snprintf(buf + *len, bufSize - *len, "CURRENT ROW");

      return TSDB_CODE_SUCCESS;

    case WINDOW_BOUND_N_FOLLOWING:

      if (NULL == pBound->pOffset) {

        return TSDB_CODE_FAILED;

      }

      NODES_ERR_RET(nodesNodeToSQLFormat(pBound->pOffset, buf, bufSize, len, true));

      *len += snprintf(buf + *len, bufSize - *len, " FOLLOWING");

      return TSDB_CODE_SUCCESS;

    case WINDOW_BOUND_UNBOUNDED_FOLLOWING:

      *len += snprintf(buf + *len, bufSize - *len, "UNBOUNDED FOLLOWING");

      return TSDB_CODE_SUCCESS;

    default:

      break;

  }

  return TSDB_CODE_FAILED;

}

int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {

  return nodesNodeToSQLFormat(pNode, buf, bufSize, len, false);

}

int32_t nodesNodeToSQLFormat(SNode *pNode, char *buf, int32_t bufSize, int32_t *len, bool longFormat) {

  switch (pNode->type) {

    case QUERY_NODE_COLUMN: {

      SColumnNode *colNode = (SColumnNode *)pNode;

      if (colNode->dbName[0]) {

        *len += snprintf(buf + *len, bufSize - *len, "`%s`.", colNode->dbName);

      }

      if (colNode->tableAlias[0]) {

        *len += snprintf(buf + *len, bufSize - *len, "`%s`.", colNode->tableAlias);

      } else if (colNode->tableName[0]) {

        *len += snprintf(buf + *len, bufSize - *len, "`%s`.", colNode->tableName);

      }

      if (colNode->node.userAlias[0]) {

        *len += snprintf(buf + *len, bufSize - *len, "`%s`", colNode->node.userAlias);

      } else {

        *len += snprintf(buf + *len, bufSize - *len, "`%s`", colNode->colName);

      }

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_VALUE: {

      SValueNode *colNode = (SValueNode *)pNode;

      char       *t = nodesGetStrValueFromNode(colNode);

      if (NULL == t) {

        // NULL type value (e.g. ELSE NULL in CASE WHEN)

        *len += tsnprintf(buf + *len, bufSize - *len, "NULL");

        return TSDB_CODE_SUCCESS;

      }

      int32_t tlen = strlen(t);

      if (longFormat) {

        *len += snprintf(buf + *len, bufSize - *len, "%s", t);

      } else {

        if (tlen > 32) {

          *len += snprintf(buf + *len, bufSize - *len, "%.*s...%s", 32, t, t + tlen - 1);

        } else {

          *len += snprintf(buf + *len, bufSize - *len, "%s", t);

        }

      }

      taosMemoryFree(t);

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_OPERATOR: {

      SOperatorNode *pOpNode = (SOperatorNode *)pNode;

      *len += snprintf(buf + *len, bufSize - *len, "(");

      if (pOpNode->pLeft) {

        NODES_ERR_RET(nodesNodeToSQLFormat(pOpNode->pLeft, buf, bufSize, len, true));

      }

      *len += tsnprintf(buf + *len, bufSize - *len, " %s ", operatorTypeStrEx(pOpNode->opType, pOpNode->flag & OPERATOR_FLAG_NEGATIVE_OP));

      if (pOpNode->pRight) {

        NODES_ERR_RET(nodesNodeToSQLFormat(pOpNode->pRight, buf, bufSize, len, true));

      }

      *len += snprintf(buf + *len, bufSize - *len, ")");

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_SQL_WINDOW_SPEC: {

      SWindowSpecNode *pWin = (SWindowSpecNode *)pNode;

      SNode           *node = NULL;

      bool             first = true;

      if (pWin->refWindowName[0] != '\0' && NULL == pWin->pPartitionByList && NULL == pWin->pOrderByList &&

          NULL == pWin->pFrame) {

        *len += snprintf(buf + *len, bufSize - *len, "%s", pWin->refWindowName);

        return TSDB_CODE_SUCCESS;

      }

      *len += snprintf(buf + *len, bufSize - *len, "(");

      if (pWin->refWindowName[0] != '\0') {

        *len += snprintf(buf + *len, bufSize - *len, "%s", pWin->refWindowName);

        first = false;

      }

      if (NULL != pWin->pPartitionByList) {

        if (!first) {

          *len += snprintf(buf + *len, bufSize - *len, " ");

        }

        *len += snprintf(buf + *len, bufSize - *len, "PARTITION BY ");

        bool firstExpr = true;

        FOREACH(node, pWin->pPartitionByList) {

          if (!firstExpr) {

            *len += snprintf(buf + *len, bufSize - *len, ", ");

          }

          NODES_ERR_RET(nodesNodeToSQLFormat(node, buf, bufSize, len, true));

          firstExpr = false;

        }

        first = false;

      }

      if (NULL != pWin->pOrderByList) {

        if (!first) {

          *len += snprintf(buf + *len, bufSize - *len, " ");

        }

        *len += snprintf(buf + *len, bufSize - *len, "ORDER BY ");

        bool firstExpr = true;

        FOREACH(node, pWin->pOrderByList) {

          if (!firstExpr) {

            *len += snprintf(buf + *len, bufSize - *len, ", ");

          }

          NODES_ERR_RET(nodesNodeToSQLFormat(node, buf, bufSize, len, true));

          firstExpr = false;

        }

        first = false;

      }

      if (NULL != pWin->pFrame) {

        if (!first) {

          *len += snprintf(buf + *len, bufSize - *len, " ");

        }

        NODES_ERR_RET(nodesNodeToSQLFormat(pWin->pFrame, buf, bufSize, len, true));

      }

      *len += snprintf(buf + *len, bufSize - *len, ")");

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_SQL_WINDOW_FRAME: {

      SWindowFrameNode *pFrame = (SWindowFrameNode *)pNode;

      *len += snprintf(buf + *len, bufSize - *len, "%s BETWEEN ",

                       WINDOW_FRAME_UNIT_RANGE == pFrame->frameUnit ? "RANGE" : "ROWS");

      NODES_ERR_RET(sqlWindowBoundToSQL(&pFrame->start, buf, bufSize, len));

      *len += snprintf(buf + *len, bufSize - *len, " AND ");

      NODES_ERR_RET(sqlWindowBoundToSQL(&pFrame->end, buf, bufSize, len));

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_SQL_NAMED_WINDOW: {

      SNamedWindowNode *pWin = (SNamedWindowNode *)pNode;

      *len += snprintf(buf + *len, bufSize - *len, "%s AS ", pWin->windowName);

      NODES_ERR_RET(nodesNodeToSQLFormat(pWin->pSpec, buf, bufSize, len, true));

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_LOGIC_CONDITION: {

      SLogicConditionNode *pLogicNode = (SLogicConditionNode *)pNode;

      SNode               *node = NULL;

      bool                 first = true;

      *len += snprintf(buf + *len, bufSize - *len, "(");

      FOREACH(node, pLogicNode->pParameterList) {

        if (!first) {

          *len += snprintf(buf + *len, bufSize - *len, " %s ", logicConditionTypeStr(pLogicNode->condType));

        }

        NODES_ERR_RET(nodesNodeToSQLFormat(node, buf, bufSize, len, true));

        first = false;

      }

      *len += snprintf(buf + *len, bufSize - *len, ")");

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_FUNCTION: {

      SFunctionNode *pFuncNode = (SFunctionNode *)pNode;

      SNode         *node = NULL;

      bool           first = true;

      *len += snprintf(buf + *len, bufSize - *len, "%s(", pFuncNode->functionName);

      FOREACH(node, pFuncNode->pParameterList) {

        if (!first) {

          *len += snprintf(buf + *len, bufSize - *len, ", ");

        }

        NODES_ERR_RET(nodesNodeToSQLFormat(node, buf, bufSize, len, true));

        first = false;

      }

      *len += snprintf(buf + *len, bufSize - *len, ")");

      if (NULL != pFuncNode->pOver) {

        *len += snprintf(buf + *len, bufSize - *len, " OVER ");

        NODES_ERR_RET(nodesNodeToSQLFormat(pFuncNode->pOver, buf, bufSize, len, true));

      }

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_NODE_LIST: {

      SNodeListNode *pListNode = (SNodeListNode *)pNode;

      SNode         *node = NULL;

      bool           first = true;

      int32_t        num = 0;

      *len += snprintf(buf + *len, bufSize - *len, "(");

      FOREACH(node, pListNode->pNodeList) {

        if (!first) {

          *len += snprintf(buf + *len, bufSize - *len, ", ");

          if (!longFormat) {

            if (++num >= 10) {

              *len += snprintf(buf + *len, bufSize - *len, "...");

              break;

            }

          }

        }

        NODES_ERR_RET(nodesNodeToSQLFormat(node, buf, bufSize, len, true));

        first = false;

      }

      *len += snprintf(buf + *len, bufSize - *len, ")");

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_REMOTE_VALUE: {

      SRemoteValueNode* pRemote = (SRemoteValueNode*)pNode;

      *len += snprintf(buf + *len, bufSize - *len, "$(InitPlan %d)", pRemote->subQIdx + 1);

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_REMOTE_VALUE_LIST: {

      SRemoteValueListNode* pRemote = (SRemoteValueListNode*)pNode;

      *len += tsnprintf(buf + *len, bufSize - *len, "$(InitPlan %d)", pRemote->subQIdx + 1);

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_REMOTE_ROW: {

      SRemoteRowNode* pRemote = (SRemoteRowNode*)pNode;

      *len += tsnprintf(buf + *len, bufSize - *len, "$(InitPlan %d)", pRemote->subQIdx + 1);

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_REMOTE_ZERO_ROWS: {

      SRemoteZeroRowsNode* pRemote = (SRemoteZeroRowsNode*)pNode;

      *len += tsnprintf(buf + *len, bufSize - *len, "$(InitPlan %d)", pRemote->subQIdx + 1);

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_REMOTE_TABLE: {

      SRemoteTableNode* pRemote = (SRemoteTableNode*)pNode;

      *len += tsnprintf(buf + *len, bufSize - *len, "$(InitPlan %d)", pRemote->subQIdx + 1);

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_WHEN_THEN: {

      SWhenThenNode *pWhenThen = (SWhenThenNode *)pNode;

      *len += tsnprintf(buf + *len, bufSize - *len, "WHEN ");

      NODES_ERR_RET(nodesNodeToSQLFormat(pWhenThen->pWhen, buf, bufSize, len, true));

      *len += tsnprintf(buf + *len, bufSize - *len, " THEN ");

      NODES_ERR_RET(nodesNodeToSQLFormat(pWhenThen->pThen, buf, bufSize, len, true));

      return TSDB_CODE_SUCCESS;

    }

    case QUERY_NODE_CASE_WHEN: {

      SCaseWhenNode *pCaseWhen = (SCaseWhenNode *)pNode;

      *len += tsnprintf(buf + *len, bufSize - *len, "CASE");

      if (pCaseWhen->pCase) {

        *len += tsnprintf(buf + *len, bufSize - *len, " ");

        NODES_ERR_RET(nodesNodeToSQLFormat(pCaseWhen->pCase, buf, bufSize, len, true));

      }

      SNode *pWhenThen = NULL;

      FOREACH(pWhenThen, pCaseWhen->pWhenThenList) {

        *len += tsnprintf(buf + *len, bufSize - *len, " ");

        NODES_ERR_RET(nodesNodeToSQLFormat(pWhenThen, buf, bufSize, len, true));

      }

      if (pCaseWhen->pElse) {

        *len += tsnprintf(buf + *len, bufSize - *len, " ELSE ");

        NODES_ERR_RET(nodesNodeToSQLFormat(pCaseWhen->pElse, buf, bufSize, len, true));

      }

      *len += tsnprintf(buf + *len, bufSize - *len, " END");

      return TSDB_CODE_SUCCESS;

    }

    default:

      break;

  }

  nodesError("nodesNodeToSQL unknown node = %s", nodesNodeName(pNode->type));

  NODES_RET(TSDB_CODE_APP_ERROR);

}