/**
 * Copyright (c) 2025 Huawei Technologies Co., Ltd.
 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
 * CANN Open Software License Agreement Version 2.0 (the "License").
 * Please refer to the License for details. You may not use this file except in compliance with the License.
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
 * See LICENSE in the root of the software repository for the full text of the License.
 */

#ifndef ACL_MODEL_SRC_MODEL_ACL_MODEL_IMPL_H_
#define ACL_MODEL_SRC_MODEL_ACL_MODEL_IMPL_H_

#include <stddef.h>
#include <stdint.h>

#include "acl_base_rt.h"
#include "acl_rt.h"
#include "acl_mdl.h"

#ifdef __cplusplus
extern "C" {
#endif

ACL_FUNC_VISIBILITY aclError aclmdlGetDescImpl(aclmdlDesc *modelDesc, uint32_t modelId);

ACL_FUNC_VISIBILITY aclError aclmdlGetDescFromFileImpl(aclmdlDesc *modelDesc, const char *modelPath);

ACL_FUNC_VISIBILITY aclError aclmdlGetDescFromMemImpl(aclmdlDesc *modelDesc, const void *model, size_t modelSize);

ACL_FUNC_VISIBILITY aclError aclmdlSetDatasetTensorDescImpl(aclmdlDataset *dataset, aclTensorDesc *tensorDesc,
                                                            size_t index);

ACL_FUNC_VISIBILITY aclError aclmdlLoadFromFileImpl(const char *modelPath, uint32_t *modelId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleLoadFromFileImpl(const char *modelPath, uint32_t *bundleId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleLoadFromMemImpl(const void *model, size_t modelSize, uint32_t *bundleId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleUnloadImpl(uint32_t bundleId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleGetModelNumImpl(uint32_t bundleId, size_t *modelNum);

ACL_FUNC_VISIBILITY aclError aclmdlBundleGetModelIdImpl(uint32_t bundleId, size_t index, uint32_t *modelId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleQueryInfoFromFileImpl(const char *fileName, aclmdlBundleQueryInfo *queryInfo);

ACL_FUNC_VISIBILITY aclError aclmdlBundleQueryInfoFromMemImpl(const void *model, size_t modelSize,
                                                              aclmdlBundleQueryInfo *queryInfo);

ACL_FUNC_VISIBILITY aclError aclmdlBundleInitFromFileImpl(const char *modelPath, void *varWeightPtr,
                                                          size_t varWeightSize, uint32_t *bundleId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleInitFromMemImpl(const void *model, size_t modelSize, void *varWeightPtr,
                                                         size_t varWeightSize, uint32_t *bundleId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleLoadModelImpl(uint32_t bundleId, size_t index, uint32_t *modelId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleLoadModelWithMemImpl(uint32_t bundleId, size_t index, void *workPtr,
                                                              size_t workSize, void *weightPtr, size_t weightSize,
                                                              uint32_t *modelId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleLoadModelWithConfigImpl(uint32_t bundleId, size_t index,
                                                                 aclmdlConfigHandle *handle, uint32_t *modelId);

ACL_FUNC_VISIBILITY aclError aclmdlBundleUnloadModelImpl(uint32_t bundleId, uint32_t modelId);

ACL_FUNC_VISIBILITY aclError aclmdlLoadFromMemImpl(const void *model, size_t modelSize, uint32_t *modelId);

ACL_FUNC_VISIBILITY aclError aclmdlLoadFromFileWithMemImpl(const char *modelPath, uint32_t *modelId, void *workPtr,
                                                           size_t workSize, void *weightPtr, size_t weightSize);

ACL_FUNC_VISIBILITY aclError aclmdlLoadFromMemWithMemImpl(const void *model, size_t modelSize, uint32_t *modelId,
                                                          void *workPtr, size_t workSize, void *weightPtr,
                                                          size_t weightSize);

ACL_FUNC_VISIBILITY aclError aclmdlLoadFromFileWithQImpl(const char *modelPath, uint32_t *modelId,
                                                         const uint32_t *inputQ, size_t inputQNum,
                                                         const uint32_t *outputQ, size_t outputQNum);

ACL_FUNC_VISIBILITY aclError aclmdlLoadFromMemWithQImpl(const void *model, size_t modelSize, uint32_t *modelId,
                                                        const uint32_t *inputQ, size_t inputQNum,
                                                        const uint32_t *outputQ, size_t outputQNum);

ACL_FUNC_VISIBILITY aclError aclmdlExecuteImpl(uint32_t modelId, const aclmdlDataset *input, aclmdlDataset *output);

ACL_FUNC_VISIBILITY aclError aclmdlExecuteV2Impl(uint32_t modelId, const aclmdlDataset *input, aclmdlDataset *output,
                                                 aclrtStream stream, const aclmdlExecConfigHandle *handle);

ACL_FUNC_VISIBILITY aclError aclmdlExecuteAsyncV2Impl(uint32_t modelId, const aclmdlDataset *input,
                                                      aclmdlDataset *output, aclrtStream stream,
                                                      const aclmdlExecConfigHandle *handle);

ACL_FUNC_VISIBILITY aclError aclmdlExecuteAsyncImpl(uint32_t modelId, const aclmdlDataset *input, aclmdlDataset *output,
                                                    aclrtStream stream);

ACL_FUNC_VISIBILITY aclError aclmdlUnloadImpl(uint32_t modelId);

ACL_FUNC_VISIBILITY aclError aclmdlSetAttributeImpl(uint32_t modelId, aclmdlAttr attr, aclmdlAttrValue_t *attrValue);

ACL_FUNC_VISIBILITY aclError aclmdlGetAttributeImpl(uint32_t modelId, aclmdlAttr attr, aclmdlAttrValue_t *attrValue);

ACL_FUNC_VISIBILITY aclError aclmdlQuerySizeImpl(const char *fileName, size_t *workSize, size_t *weightSize);

ACL_FUNC_VISIBILITY aclError aclmdlQueryExeOMDescImpl(const char *fileName, aclmdlExeOMDesc *mdlPartitionSize);

ACL_FUNC_VISIBILITY aclError aclmdlQuerySizeFromMemImpl(const void *model, size_t modelSize, size_t *workSize,
                                                        size_t *weightSize);

ACL_FUNC_VISIBILITY aclError aclmdlSetDynamicBatchSizeImpl(uint32_t modelId, aclmdlDataset *dataset, size_t index,
                                                           uint64_t batchSize);

ACL_FUNC_VISIBILITY aclError aclmdlSetDynamicHWSizeImpl(uint32_t modelId, aclmdlDataset *dataset, size_t index,
                                                        uint64_t height, uint64_t width);

ACL_FUNC_VISIBILITY aclError aclmdlSetInputDynamicDimsImpl(uint32_t modelId, aclmdlDataset *dataset, size_t index,
                                                           const aclmdlIODims *dims);

ACL_FUNC_VISIBILITY aclError aclmdlGetCurOutputDimsImpl(const aclmdlDesc *modelDesc, size_t index, aclmdlIODims *dims);

ACL_FUNC_VISIBILITY const char *aclmdlGetOpAttrImpl(aclmdlDesc *modelDesc, const char *opName, const char *attr);

ACL_FUNC_VISIBILITY aclError aclmdlSetInputAIPPImpl(uint32_t modelId, aclmdlDataset *dataset, size_t index,
                                                    const aclmdlAIPP *aippParmsSet);

ACL_FUNC_VISIBILITY aclError aclmdlSetAIPPByInputIndexImpl(uint32_t modelId, aclmdlDataset *dataset, size_t index,
                                                           const aclmdlAIPP *aippParmsSet);

ACL_FUNC_VISIBILITY aclError aclmdlGetAippTypeImpl(uint32_t modelId, size_t index, aclmdlInputAippType *type,
                                                   size_t *dynamicAttachedDataIndex);

ACL_FUNC_VISIBILITY aclError aclmdlGetFirstAippInfoImpl(uint32_t modelId, size_t index, aclAippInfo *aippInfo);

ACL_FUNC_VISIBILITY aclError aclmdlCreateAndGetOpDescImpl(uint32_t deviceId, uint32_t streamId, uint32_t taskId,
                                                          char *opName, size_t opNameLen, aclTensorDesc **inputDesc,
                                                          size_t *numInputs, aclTensorDesc **outputDesc,
                                                          size_t *numOutputs);

ACL_FUNC_VISIBILITY aclError aclmdlInitDumpImpl();

ACL_FUNC_VISIBILITY aclError aclmdlSetDumpImpl(const char *dumpCfgPath);

ACL_FUNC_VISIBILITY aclError aclmdlFinalizeDumpImpl();

ACL_FUNC_VISIBILITY aclError aclmdlLoadWithConfigImpl(const aclmdlConfigHandle *handle, uint32_t *modelId);

ACL_FUNC_VISIBILITY aclError aclRecoverAllHcclTasksImpl(int32_t deviceId);

ACL_FUNC_VISIBILITY aclError aclTransTensorDescFormatImpl(const aclTensorDesc *srcDesc, aclFormat dstFormat,
                                                          aclTensorDesc **dstDesc);

#ifdef __cplusplus
}
#endif

#endif  // ACL_MODEL_SRC_MODEL_ACL_MODEL_IMPL_H_