/*

 * Copyright (c) 2024 Huawei Device Co., Ltd.

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

 */



#ifndef OHOS_IDL_PARSER_H

#define OHOS_IDL_PARSER_H



#include <memory>

#include <set>

#include <vector>

#include <regex>

#include <unordered_set>

#include <algorithm>

#include "ast/ast.h"

#include "ast/ast_array_type.h"

#include "ast/ast_set_type.h"

#include "ast/ast_attribute.h"

#include "ast/ast_interface_type.h"

#include "ast/ast_method.h"

#include "ast/ast_type.h"

#include "ast/ast_enum_type.h"

#include "ast/ast_map_type.h"

#include "ast/ast_orderedmap_type.h"

#include "ast/ast_parameter.h"

#include "ast/ast_ptr_type.h"

#include "ast/ast_rawdata_type.h"

#include "ast/ast_sequenceable_type.h"

#include "ast/ast_smq_type.h"

#include "ast/ast_struct_type.h"

#include "ast/ast_union_type.h"

#include "lexer/lexer.h"

#include "lexer/token.h"

#include "preprocessor/preprocessor.h"

#include "util/autoptr.h"

#include "util/light_refcount_base.h"

#include "util/logger.h"



namespace OHOS {

namespace Idl {



struct AstCompare {

    bool operator()(const AutoPtr<AST> &lhs, const AutoPtr<AST> &rhs) const

    {

        return lhs->GetMinorVer() < rhs->GetMinorVer();

    }

};



using AttrSet = std::set<Token, TokenTypeCompare>;



using AstMergeMap = std::map<std::string, std::set<AutoPtr<AST>, AstCompare>>;



class Parser {

public:

    Parser() = default;



    ~Parser() = default;



    bool Parse(const std::vector<FileDetail> &fileDetails);



    using StrAstMap = std::unordered_map<std::string, AutoPtr<AST>>;

    inline const StrAstMap &GetAllAst() const

    {

        return allAsts_;

    }



private:

    static constexpr int MIN_TRANSACTION_ID = 0x01;

    static constexpr int MAX_TRANSACTION_ID = 0x00ffffff;

    static constexpr int MIN_IPC_CAPACITY = 1;

    static constexpr int MAX_IPC_CAPACITY = 0x0001ffff;



    class Attribute : public LightRefCountBase {

    public:

        bool isOneWay = false;

        bool isCallback = false;

        bool isFull = false;

        bool isLite = false;

    };



    bool ParseOne(const std::string &sourceFile);



    bool Reset(const std::string &sourceFile);



    bool ParseFile();



    std::string ParseLicense();



    bool ParsePackage();



    bool ParseInterfaceToken();



    bool ParseKeywordWithId(TokenType expectedKeyword, const std::string& context);



    bool ParseSupportDelegator();



    bool ParseOptionStubHooks();



    bool ParseOptionParcelHooks();



    bool ParseOptionMacroHilog();



    bool ParseOptionUsingHooks();



    bool ParserPackageInfo(const std::string &packageName);



    bool ParseImports();



    void ParseImportInfo();



    void ParseSequenceableInfo();



    void ParseRawDataInfo();



    bool ParseTypeDecls();



    // parse attributes of type

    void ParseAttribute();



    AttrSet ParseAttributeInfo();



    bool ParseAttrUnit(AttrSet &attrs);



    void ParseAttrUnitFreezecontrol(AttrSet &attrs, Token &token);



    void ParseAttrUnitCustomMsgOption(AttrSet &attrs, Token &token);



    void ParseAttrUnitMarco(AttrSet &attrs, Token &token);



    void ParseAttrUnitIpccode(AttrSet &attrs, Token &token);



    void ParseAttrUnitIpcCapacity(AttrSet &attrs, Token &token);



    // parse interface type

    void ParseInterface(const AttrSet &attrs = {});



    AutoPtr<ASTAttr> ParseInfAttrInfo(const AttrSet &attrs);



    void CheckInterfaceAttr(const AutoPtr<ASTInterfaceType> &interface, Token token);



    void CheckIpcCodeValue(

        const AutoPtr<ASTMethod> &method, int32_t &ipcCodeValue, std::unordered_set<int32_t> &ipcCodeSet);



    void ParseInterfaceExternal(const AutoPtr<ASTInterfaceType> &interface);



    void ParseInterfaceBody(const AutoPtr<ASTInterfaceType> &interface);



    AutoPtr<ASTMethod> ParseMethod(const AutoPtr<ASTInterfaceType> &interface);



    AutoPtr<ASTType> ParseMethodReturnType();



    AutoPtr<ASTAttr> ParseMethodAttr();



    AutoPtr<ASTMethod> CreateGetVersionMethod();



    void CheckMethodAttr(const AutoPtr<ASTInterfaceType> &interface, const AutoPtr<ASTMethod> &method);



    void ParseMethodParamList(const AutoPtr<ASTMethod> &method);



    AutoPtr<ASTParameter> ParseParam();



    bool CheckParamAttr();



    void SetParamAttrVal(Token token, AutoPtr<ASTParamAttr> attr);



    AutoPtr<ASTParamAttr> ParseParamAttr();



    // parse type

    AutoPtr<ASTType> ParseType();



    AutoPtr<ASTType> ParseBasicType();



    AutoPtr<ASTType> ParseUnsignedType();



    AutoPtr<ASTType> ParseArrayType(const AutoPtr<ASTType> &elementType);



    AutoPtr<ASTType> ParseListType();



    AutoPtr<ASTType> ParseSetType();



    AutoPtr<ASTType> ParsePtrType(TokenType ptrKind);



    AutoPtr<ASTType> ParseMapType();



    AutoPtr<ASTType> ParseOrderedMapType();



    AutoPtr<ASTType> ParseSmqType();



    AutoPtr<ASTType> ParseUserDefType();



    // parse declaration of enum

    void ParseEnumDeclaration(const AttrSet &attrs = {});



    AutoPtr<ASTType> ParseEnumBaseType();



    void ParserEnumMember(const AutoPtr<ASTEnumType> &enumType);



    // parse declaration of struct

    void ParseStructDeclaration(const AttrSet &attrs = {});



    AutoPtr<ASTStructType> ParseStructParentType();



    void ParseStructMember(const AutoPtr<ASTStructType> &structType);



    // parse declaration of union

    void ParseUnionDeclaration(const AttrSet &attrs = {});



    void ParseUnionMember(const AutoPtr<ASTUnionType> &unionType);



    bool AddUnionMember(

        const AutoPtr<ASTUnionType> &unionType, const AutoPtr<ASTType> &type, const std::string &name) const;



    AutoPtr<ASTAttr> ParseUserDefTypeAttr(const AttrSet &attrs);



    // parse expression

    AutoPtr<ASTExpr> ParseExpr();



    AutoPtr<ASTExpr> ParseAndExpr();



    AutoPtr<ASTExpr> ParseXorExpr();



    AutoPtr<ASTExpr> ParseOrExpr();



    AutoPtr<ASTExpr> ParseShiftExpr();



    AutoPtr<ASTExpr> ParseAddExpr();



    AutoPtr<ASTExpr> ParseMulExpr();



    AutoPtr<ASTExpr> ParseUnaryExpr();



    AutoPtr<ASTExpr> ParsePrimaryExpr();



    AutoPtr<ASTExpr> ParseNumExpr();



    AutoPtr<ASTExpr> ParseEnumExpr();



    bool CheckNumber(const std::string& integerVal) const;



    bool CheckType(const Token &token, const AutoPtr<ASTType> &type);



    bool CheckTypeByMode(const Token &token, const AutoPtr<ASTType> &type);



    void SetAstFileType();



    bool CheckPackageName(const std::string &filePath, const std::string &packageName) const;



    bool CheckImport(const Token &token);



    void ParseInterfaceExtends(AutoPtr<ASTInterfaceType> &interface);



    void ParseExtendsInfo(AutoPtr<ASTInterfaceType> &interfaceType);



    bool CheckExtendsName(AutoPtr<ASTInterfaceType> &interfaceType, const std::string &extendsName);



    bool CheckExtendsVersion(AutoPtr<AST> extendsAst);



    bool CheckImportsVersion(AutoPtr<AST> extendsAst);



    inline static bool IsPrimitiveType(Token token)

    {

        return token.kind >= TokenType::BOOLEAN && token.kind <= TokenType::ASHMEM;

    }



    bool AddAst(const AutoPtr<AST> &ast);



    void LogError(const char *funcName, int fileLine, const std::string &message)

    {

        errors_.push_back(StringHelper::Format("[%s:%d] error:%s", funcName, fileLine, message.c_str()));

    }



    void LogError(const char *funcName, int fileLine, const Token &token, const std::string &message)

    {

        errors_.push_back(StringHelper::Format("[%s:%d] [%s] error:%s",

            funcName, fileLine, LocInfo(token).c_str(), message.c_str()));

    }



    void LogErrorBeforeToken(const char *funcName, int fileLine, const Token &token, const std::string &message)

    {

        errors_.push_back(StringHelper::Format("[%s:%d] [%s] error:%s before '%s' token",

            funcName, fileLine, LocInfo(token).c_str(), message.c_str(), token.value.c_str()));

    }



    void ShowError()

    {

        for (const auto &errMsg : errors_) {

            Logger::E(TAG, "%s", errMsg.c_str());

        }

    }



    bool PostProcess();



    bool CheckExistExtends();



    bool GetGenVersion(std::vector<size_t> &version, std::string &genPackageName);



    void GetGenNamespace(AutoPtr<ASTNamespace> &ns);



    void SortAstByName(AstMergeMap &mergeMap, StrAstMap &allAsts);



    void MergeAsts(AstMergeMap &mergeMap);



    void MergeAst(AutoPtr<AST> &targetAst, AutoPtr<AST> sourceAst);



    void MergeImport(AutoPtr<AST> &targetAst, AutoPtr<AST> sourceAst);



    void MergeInterfaceDef(AutoPtr<AST> &targetAst, AutoPtr<AST> sourceAst);



    void MergeTypes(AutoPtr<AST> &targetAst, AutoPtr<AST> sourceAst);



    void MergeSequenceableDef(AutoPtr<AST> &targetAst, AutoPtr<AST> sourceAst);



    void MergeRawDataDef(AutoPtr<AST> &targetAst, AutoPtr<AST> sourceAst);



    void MergeTypeDefinitions(AutoPtr<AST> &targetAst, AutoPtr<AST> sourceAst);



    void ModifyImport(StrAstMap &allAsts, std::string &genPackageName);



    void ModifyPackageNameAndVersion(StrAstMap &allAsts, std::string &genPackageName, std::vector<size_t> genVersion);



    void ModifyInterfaceNamespace(AutoPtr<ASTNamespace> &ns);



    Lexer lexer_;

    std::vector<std::string> errors_;

    AutoPtr<AST> ast_;

    StrAstMap allAsts_;

    std::string freezecontrolAttr_;

    AutoPtr<ASTEnumType> currentEnum_;

    std::string messageOption_;

    std::string macroVal_;

    std::string macroType_;

};

} // namespace Idl

} // namespace OHOS



#endif // OHOS_IDL_PARSER_H