package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.EDbObjectType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.nodes.mssql.TProcedureOption;
import gudusoft.gsqlparser.nodes.oracle.TInvokerRightsClause;
import gudusoft.gsqlparser.nodes.oracle.TParallelEnableClause;
import gudusoft.gsqlparser.nodes.oracle.TResultCacheClause;
import gudusoft.gsqlparser.TBaseType;

/**
 * Internal use in the parser..
*/
public class TCreateFunctionSqlNode extends TParseTreeNode {
    private String className;
    private String resourceType;//jar, file
    private String resourceURI;//

    private TSelectSqlNode sqlQuery;

    public void setSqlQuery(TSelectSqlNode sqlQuery) {
        this.sqlQuery = sqlQuery;
    }

    public TSelectSqlNode getSqlQuery() {
        return sqlQuery;
    }

    public String getClassName() {
        return className;
    }

    public String getResourceType() {
        return resourceType;
    }

    public String getResourceURI() {
        return resourceURI;
    }

    public  void setSparkSqlResourceLocation(TDummy dummy){
        this.resourceType = dummy.st1.toString();
        this.resourceURI = dummy.st2.toString();
    }

    public void setClassNameByToken(TSourceToken st){
        this.className = st.toString();
    }

    private TExpression sqlExpression;//bigquery

    public void setSqlExpression(TExpression sqlExpression) {
        this.sqlExpression = sqlExpression;
    }

    public TExpression getSqlExpression() {
        return sqlExpression;
    }

    private TObjectName endlabelName;

    public void setEndlabelName(TObjectName endlabelName) {
        this.endlabelName = endlabelName;
    }

    public TObjectName getEndlabelName() {

        return endlabelName;
    }

    public TConstant getSharedLibraryName() {
        return sharedLibraryName;
    }

    public void setSharedLibraryName(TConstant sharedLibraryName) {

        this.sharedLibraryName = sharedLibraryName;
    }

    private TConstant sharedLibraryName;

    private TPTNodeList <TProcedureOption> procedureOptions;

    public void setProcedureOptions(TPTNodeList<TProcedureOption> procedureOptions) {
        this.procedureOptions = procedureOptions;
    }

    public TPTNodeList<TProcedureOption> getProcedureOptions() {

        return procedureOptions;
    }

    private boolean isDeterministic;
    private TInvokerRightsClause invokerRightsClause;
    private TParallelEnableClause parallelEnableClause;
    private TResultCacheClause resultCacheClause;
    private TObjectName implementionType;

    public void setImplementionType(TObjectName implementionType) {
        this.implementionType = implementionType;
    }

    public TObjectName getImplementionType() {

        return implementionType;
    }

    public  void setFunctionCharacter(TDummy dummy){
        if (dummy == null) return;
        if (dummy.list1 != null){
            setFuncHintList((TDummyList)dummy.list1);
        }
    }

    public void setFuncHintList(TDummyList dummyList){

        if (dummyList == null) return;

        for(int i=0; i<dummyList.size();i++){
            TDummy dummy = dummyList.getDummyItem(i);
            if (dummy.st1 != null){
                isDeterministic = true;
            }else{
                if (dummy.node1 instanceof TInvokerRightsClause){
                    invokerRightsClause = (TInvokerRightsClause)(dummy.node1);
                }else if (dummy.node1 instanceof  TParallelEnableClause){
                    parallelEnableClause = (TParallelEnableClause)(dummy.node1);
                }else if (dummy.node1 instanceof TResultCacheClause){
                    resultCacheClause = (TResultCacheClause)(dummy.node1);
                }
            }
        }
    }

    public boolean isDeterministic() {
        return isDeterministic;
    }

    public TParallelEnableClause getParallelEnableClause() {
        return parallelEnableClause;
    }

    public TResultCacheClause getResultCacheClause() {
        return resultCacheClause;
    }

    public TInvokerRightsClause getInvokerRightsClause() {

        return invokerRightsClause;
    }

    private TObjectName functionName = null;
    private TObjectName asName;

    public TObjectName getAsName() {
        return asName;
    }

    public TObjectName getFunctionName() {
        return functionName;
    }

    private TParameterDeclarationList parameters = null;

    public void setParameters(TParameterDeclarationList parameters) {
        this.parameters = parameters;
    }

    public void setParametersByDummy(TDummy node) {
        if (node == null) return;
        if (node.node1 != null){
            this.parameters = (TParameterDeclarationList)node.node1;
        }
    }

    public void init(Object arg1)
   {
      functionName = (TObjectName)arg1;
      if (functionName.getDbObjectType() != EDbObjectType.function){
          // not set yet, then do this here
          functionName.setObjectType(TObjectName.ttobjFunctionName);
      }

      functionName.splitNameInQuotedIdentifier();
   }

    public void init(Object arg1,Object arg2)
   {
       init(arg1);
       asName = (TObjectName)arg2;
   }

    public void setKind(int kind) {
        this.kind = kind;
    }

    public int getKind() {
        return kind;
    }

    private TCallSpec callSpec = null;

    public TCallSpec getCallSpec() {
        return callSpec;
    }

    public void setCallSpec(TCallSpec callSpec) {

        this.callSpec = callSpec;
    }

    private int kind = TBaseType.kind_create;// what's kind of this function

    private TBlockSqlNode blcok = null;    // sql server
    private TStatementListSqlNode stmts = null; // plsql
    private TStatementListSqlNode declareStmts = null; // plsql
    private TStatementSqlNode stmt = null;//mysql single stmt in function body
    private TConstant functionBody;

    public void setFunctionBody(TConstant functionBody) {
        this.functionBody = functionBody;
        this.functionDefinition = functionBody;
    }

    public TConstant getFunctionBody() {
        return functionBody;
    }

    public void setFunctionDefinition(TConstant functionDefinition) {
        this.functionDefinition = functionDefinition;
    }

    public TConstant getFunctionDefinition() {

        return functionDefinition;
    }

    private TConstant functionDefinition;

    public void setStmt(TStatementSqlNode stmt) {
        this.stmt = stmt;
    }

    public TStatementSqlNode getStmt() {

        return stmt;
    }

    public TExceptionClause getExceptionClause() {
        return exceptionClause;
    }

    public void setExceptionClause(TExceptionClause exceptionClause) {
        this.exceptionClause = exceptionClause;
    }

    private TExceptionClause exceptionClause = null; //plsql exception

    public TStatementListSqlNode getDeclareStmts() {
        return declareStmts;
    }

    public void setDeclareStmts(TStatementListSqlNode declareStmts) {

        this.declareStmts = declareStmts;
    }

    public TStatementListSqlNode getStmts() {
        return stmts;
    }

    public void setStmts(TStatementListSqlNode stmts) {

        this.stmts = stmts;
    }

    public TBlockSqlNode getBlcok() {
        return blcok;
    }

    public TReturnSqlNode getReturnSqlNode() {
        return returnSqlNode;
    }

    private TReturnSqlNode returnSqlNode = null;

    public void setReturnSqlNode(TReturnSqlNode returnSqlNode) {
        this.returnSqlNode = returnSqlNode;
    }

    public void setBlcok(TBlockSqlNode blcok) {
        this.blcok = blcok;
    }

    public TParameterDeclarationList getParameters() {
        return parameters;
    }

    private TTypeName returnDataType = null;

    public void setReturnDataType(TTypeName returnDataType) {
        this.returnDataType = returnDataType;
    }

    public TTypeName getReturnDataType() {

        return returnDataType;
    }

    private TDummy returnTable = null;

    public void setReturnTable(TDummy returnTable) {
        this.returnTable = returnTable;
    }

    public TDummy getReturnTable() {

        return returnTable;
    }

    private TCompoundSqlNode compoundSql = null;
    private TReturnSqlNode returnSql = null;

    public TCompoundSqlNode getCompoundSql() {
        return compoundSql;
    }

    public void setReturnSql(TReturnSqlNode returnSql) {
        this.returnSql = returnSql;
    }

    public TReturnSqlNode getReturnSql() {
        return returnSql;
    }

    public void setBody(Object arg1){
       if (arg1 instanceof TReturnSqlNode){
           returnSql = (TReturnSqlNode)arg1;
       }else if (arg1 instanceof TCompoundSqlNode){
           compoundSql = (TCompoundSqlNode)arg1;
       }
    }


    public void setFunctionOptions(TPTNodeList<TCreateFunctionOption> options){
        if (options == null) return;
        for(int i=0;i<options.size();i++){
            setFunctionOption(options.getElement(i));
        }
    }

    private TConstant objfile;

    public void setObjfile(TConstant objfile) {
        this.objfile = objfile;
    }

    public void setLinkSymbol(TConstant linkSymbol) {
        this.linkSymbol = linkSymbol;
    }

    private TConstant linkSymbol;

    public TConstant getLinkSymbol() {
        return linkSymbol;
    }

    public TConstant getObjfile() {
        return objfile;
    }

    private TConstant procedureLanguage;

    public TConstant getProcedureLanguage() {
        return procedureLanguage;
    }

    private TObjectName labelName = null;

    public void setLabelName(TObjectName labelName) {
        this.labelName = labelName;
    }

    public TObjectName getLabelName() {
        return labelName;
    }

    public void setFunctionOption(TCreateFunctionOption option){
//        boolean isplpgsql = true;
//        if (procedureLanguage != null){
//            if (!(procedureLanguage.toString().equalsIgnoreCase("plpgsql"))){
//                isplpgsql = false;
//            }
//        }
        switch (option.getOptionType()){
            case block:
//                TBlockSqlNode blockSqlNode = option.getBlockSqlNode();
//                labelName = blockSqlNode.getLabelName();
//                setDeclareStmts(blockSqlNode.getDeclareStmts());
//                setStmts(blockSqlNode.getStmts());
//                setExceptionClause(blockSqlNode.getExceptionClause());
                functionBody = option.getFunctionBody();
                break;
            case stmts:
                //setStmts(option.getSqlNodes());
                functionBody = option.getFunctionBody();
                break;
            case language:
                procedureLanguage = option.getLanguage();
                break;
            case objfile:
                objfile = option.getObjfile();
                linkSymbol = option.getLinkSymbol();
                break;
            default:
                break;
        }
    }

}