/*
    * Themis: Java Project Framework
    * Copyright 2012-2026. Tony Washer
    *
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
    * use this file except in compliance with the License.  You may obtain a copy
    * of the License at
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
   * License for the specific language governing permissions and limitations under
   * the License.
   */
  package io.github.tonywasher.joceanus.themis.xanalysis.parser.base;
  
  import com.github.javaparser.ast.Node;
  import com.github.javaparser.ast.NodeList;
  import com.github.javaparser.ast.PackageDeclaration;
  import com.github.javaparser.ast.body.BodyDeclaration;
  import com.github.javaparser.ast.expr.Expression;
  import com.github.javaparser.ast.modules.ModuleDirective;
  import com.github.javaparser.ast.stmt.Statement;
  import com.github.javaparser.ast.type.Type;
  import io.github.tonywasher.joceanus.oceanus.base.OceanusException;
  import io.github.tonywasher.joceanus.themis.xanalysis.parser.base.ThemisXAnalysisInstance.ThemisXAnalysisClassInstance;
  import io.github.tonywasher.joceanus.themis.xanalysis.parser.base.ThemisXAnalysisInstance.ThemisXAnalysisDeclarationInstance;
  import io.github.tonywasher.joceanus.themis.xanalysis.parser.base.ThemisXAnalysisInstance.ThemisXAnalysisExpressionInstance;
  import io.github.tonywasher.joceanus.themis.xanalysis.parser.base.ThemisXAnalysisInstance.ThemisXAnalysisModuleInstance;
  import io.github.tonywasher.joceanus.themis.xanalysis.parser.base.ThemisXAnalysisInstance.ThemisXAnalysisNodeInstance;
  import io.github.tonywasher.joceanus.themis.xanalysis.parser.base.ThemisXAnalysisInstance.ThemisXAnalysisStatementInstance;
  import io.github.tonywasher.joceanus.themis.xanalysis.parser.base.ThemisXAnalysisInstance.ThemisXAnalysisTypeInstance;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  /**
   * Parser interface.
   */
  public interface ThemisXAnalysisParserDef {
      /**
       * Process the file as javaCode.
       *
       * @return the parsed compilation unit
       * @throws OceanusException on error
       */
      ThemisXAnalysisNodeInstance parseJavaFile() throws OceanusException;
  
      /**
       * Process the file as a module-info instance.
       *
       * @param pInfoFile the module-info file
       * @return the parsed moduleInfo
       * @throws OceanusException on error
       */
      ThemisXAnalysisModuleInstance parseModuleInfo(File pInfoFile) throws OceanusException;
  
      /**
       * Set the current package.
       *
       * @param pPackage the package
       */
      void setCurrentPackage(String pPackage);
  
      /**
       * Set the current file.
       *
       * @param pFile the file
       */
      void setCurrentFile(File pFile);
  
      /**
       * Obtain the classList.
       *
       * @return the classList
       */
      List<ThemisXAnalysisClassInstance> getClasses();
  
      /**
       * Build exception.
       *
       * @param pMessage the message
       * @param pNode    the failing node
       * @return the built exception
       */
      OceanusException buildException(String pMessage,
                                      Node pNode);
  
      /**
       * Check the package name.
       *
       * @param pPackage the package name
       * @throws OceanusException on error
       */
      void checkPackage(PackageDeclaration pPackage) throws OceanusException;
 
     /**
      * Register Instance.
      *
      * @param pInstance the instance
      * @return the parent node
      * @throws OceanusException on error
      */
     ThemisXAnalysisInstance registerInstance(ThemisXAnalysisInstance pInstance) throws OceanusException;
 
     /**
      * Register Class.
      *
      * @param pClass the class
      * @return the class name
      */
     String registerClass(ThemisXAnalysisClassInstance pClass) throws OceanusException;
 
     /**
      * Parse a declaration.
      *
      * @param pDecl the declaration
      * @return the parsed declaration
      * @throws OceanusException on error
      */
     ThemisXAnalysisDeclarationInstance parseDeclaration(BodyDeclaration<?> pDecl) throws OceanusException;
 
     /**
      * parse a list of declarations.
      *
      * @param pDeclList the list of Declarations
      * @return the list of parsed declarations
      * @throws OceanusException on error
      */
     default List<ThemisXAnalysisDeclarationInstance> parseDeclarationList(final NodeList<? extends BodyDeclaration<?>> pDeclList) throws OceanusException {
         /* Handle null list */
         if (pDeclList == null) {
             return Collections.emptyList();
         }
 
         /* Create list of declarations */
         final List<ThemisXAnalysisDeclarationInstance> myList = new ArrayList<>();
         for (BodyDeclaration<?> myDecl : pDeclList) {
             final ThemisXAnalysisDeclarationInstance myParsed = parseDeclaration(myDecl);
             myList.add(myParsed);
         }
         return myList;
     }
 
     /**
      * Parse a node.
      *
      * @param pNode the node
      * @return the parsed node
      * @throws OceanusException on error
      */
     ThemisXAnalysisNodeInstance parseNode(Node pNode) throws OceanusException;
 
     /**
      * parse a list of nodes.
      *
      * @param pNodeList the list of Nodes
      * @return the list of parsed nodes
      * @throws OceanusException on error
      */
     default List<ThemisXAnalysisNodeInstance> parseNodeList(final NodeList<? extends Node> pNodeList) throws OceanusException {
         /* Handle null list */
         if (pNodeList == null) {
             return Collections.emptyList();
         }
 
         /* Create list of nodes */
         final List<ThemisXAnalysisNodeInstance> myList = new ArrayList<>();
         for (Node myNode : pNodeList) {
             final ThemisXAnalysisNodeInstance myParsed = parseNode(myNode);
             myList.add(myParsed);
         }
         return myList;
     }
 
     /**
      * parse a list of modifiers.
      *
      * @param pNodeList the list of Modifiers
      * @return the list of parsed modifiers
      * @throws OceanusException on error
      */
     ThemisXAnalysisModifierList parseModifierList(NodeList<? extends Node> pNodeList) throws OceanusException;
 
     /**
      * Parse a type.
      *
      * @param pType the type
      * @return the parsed type
      * @throws OceanusException on error
      */
     ThemisXAnalysisTypeInstance parseType(Type pType) throws OceanusException;
 
     /**
      * parse a list of types.
      *
      * @param pTypeList the list of Types
      * @return the list of parsed types
      * @throws OceanusException on error
      */
     default List<ThemisXAnalysisTypeInstance> parseTypeList(final NodeList<? extends Type> pTypeList) throws OceanusException {
         /* Handle null list */
         if (pTypeList == null) {
             return Collections.emptyList();
         }
 
         /* Create list of nodes */
         final List<ThemisXAnalysisTypeInstance> myList = new ArrayList<>();
         for (Type myType : pTypeList) {
             final ThemisXAnalysisTypeInstance myParsed = parseType(myType);
             myList.add(myParsed);
         }
         return myList;
     }
 
     /**
      * Parse a statement.
      *
      * @param pStatement the statement
      * @return the parsed statement
      * @throws OceanusException on error
      */
     ThemisXAnalysisStatementInstance parseStatement(Statement pStatement) throws OceanusException;
 
     /**
      * parse a list of statements.
      *
      * @param pStatementList the list of Statements
      * @return the list of parsed statements
      * @throws OceanusException on error
      */
     default List<ThemisXAnalysisStatementInstance> parseStatementList(final NodeList<? extends Statement> pStatementList) throws OceanusException {
         /* Handle null list */
         if (pStatementList == null) {
             return Collections.emptyList();
         }
 
         /* Create list of statements */
         final List<ThemisXAnalysisStatementInstance> myList = new ArrayList<>();
         for (Statement myStatement : pStatementList) {
             final ThemisXAnalysisStatementInstance myParsed = parseStatement(myStatement);
             myList.add(myParsed);
         }
         return myList;
     }
 
     /**
      * Parse an expression.
      *
      * @param pExpression the expression
      * @return the parsed expression
      * @throws OceanusException on error
      */
     ThemisXAnalysisExpressionInstance parseExpression(Expression pExpression) throws OceanusException;
 
     /**
      * parse a list of expressions.
      *
      * @param pExprList the list of Expressions
      * @return the list of parsed expressions
      * @throws OceanusException on error
      */
     default List<ThemisXAnalysisExpressionInstance> parseExprList(final NodeList<? extends Expression> pExprList) throws OceanusException {
         /* Handle null list */
         if (pExprList == null) {
             return Collections.emptyList();
         }
 
         /* Create list of expressions */
         final List<ThemisXAnalysisExpressionInstance> myList = new ArrayList<>();
         for (Expression myExpr : pExprList) {
             final ThemisXAnalysisExpressionInstance myParsed = parseExpression(myExpr);
             myList.add(myParsed);
         }
         return myList;
     }
 
     /**
      * Parse a module.
      *
      * @param pDeclaration the module declaration/directive
      * @return the parsed declaration/directive
      * @throws OceanusException on error
      */
     ThemisXAnalysisModuleInstance parseModule(Node pDeclaration) throws OceanusException;
 
     /**
      * parse a list of module directives.
      *
      * @param pDirList the list of Directives
      * @return the list of parsed directives
      * @throws OceanusException on error
      */
     default List<ThemisXAnalysisModuleInstance> parseModuleList(final NodeList<? extends ModuleDirective> pDirList) throws OceanusException {
         /* Handle null list */
         if (pDirList == null) {
             return Collections.emptyList();
         }
 
         /* Create list of directives */
         final List<ThemisXAnalysisModuleInstance> myList = new ArrayList<>();
         for (ModuleDirective myDir : pDirList) {
             final ThemisXAnalysisModuleInstance myParsed = parseModule(myDir);
             myList.add(myParsed);
         }
         return myList;
     }
 }