#include <iostream>
#include <vector>
#include <getopt.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/wait.h>
#include <dlfcn.h>
#include <cstdio>
#include <string>
#include <iomanip>
#include <string.h>
#include <list>
#include <algorithm>
#include <stdarg.h>
#include "acl/acl.h"
#include "aclnn/aclnn_base.h"
#include "acl/acl_base.h"
#include "acl/acl_rt.h"
#include "sec_common.h"
#include "utils.h"

#include "../fuzzlib/secodeFuzz.h"
#include "aclnnop/aclnn_attention_update.h"

using namespace std;

static std::string ShapeToStr(const std::vector<int64_t>& s) {
    std::string r = "[";
    for (size_t k = 0; k < s.size(); k++) {
        if (k) r += ",";
        r += std::to_string(s[k]);
    }
    return r + "]";
}
int aclnnAttentionUpdate_Normal(int fuzz_num)
{
    auto ret = Init(deviceId, &context, &stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
    WriteDTLog("aclnnAttentionUpdate", "aclnnAttentionUpdate op fuzz start \n");
    const long long kSingleInputSizeMax = 1073741824LL;
    const long long kTotalInputSizeMax = 2147483648LL;

    // dtype enums
    int dtype0Enum[] = { 0 };
    int dtype0Num = sizeof(dtype0Enum) / sizeof(dtype0Enum[0]);
    int dtype1Enum[] = { 0, 1, 27 };
    int dtype1Num = sizeof(dtype1Enum) / sizeof(dtype1Enum[0]);

    aclrtSetOpExecuteTimeOut(1091);
    DT_Set_TimeOut_Second(3000);
    DT_FUZZ_START(0, fuzz_num, "aclnnAttentionUpdate", 0)
    {
        int i = 0;
        int shapeDimMax = 16;
        int aclnnRet = -1;  // aclnn 实际调用返回值（成功判定依据）
        void* lseDeviceAddr = nullptr;
        aclTensor* lse = nullptr;
        void* localOutDeviceAddr = nullptr;
        aclTensor* localOut = nullptr;
        void* outDeviceAddr = nullptr;
        aclTensor* out = nullptr;
        void* lseOutDeviceAddr = nullptr;
        aclTensor* lseOut = nullptr;
        uint64_t workspaceSize = 0;
        aclOpExecutor* executor;
        void* workspaceAddr = nullptr;

        LOG_PRINT("aclnnAttentionUpdate_Normal %d\n", fuzzi);
        printf("[FUZZ_LOG] plog_file: aclnnAttentionUpdate_fuzz_plog_case_%d.log\n", fuzzi);
        aclnnRet = -1;
        try
        {
        // DT mutation data
            int sizeBucket = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 0, 3, "i");
            int dim_num0 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 0, 8, "i");  // 维度约束 [0,8]
            {
                const long long sizeTargets[4] = {1000LL, 1048576LL, 16777216LL, 134217728LL};
                int nTensors = 4;
                long long target = sizeTargets[sizeBucket] / nTensors;
                if (target < 1) { target = 1; }
                int nd = (dim_num0 > 0) ? dim_num0 : 1;
                long long perDim = (long long)pow((double)target, 1.0 / nd);
                if (perDim < 1) { perDim = 1; }
                if (perDim > MAX_SHAPE_SIZE) { perDim = MAX_SHAPE_SIZE; }
                shapeDimMax = (int)perDim;
            }
            int shape1 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            int shape2 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            int shape3 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            int shape4 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            int shape5 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            int shape6 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            int shape7 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            int shape8 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, shapeDimMax, "i");
            auto dtype0 = (aclDataType)*(int *)DT_SetGetNumberEnumV3(i++, aclDataType::ACL_FLOAT, dtype0Enum, dtype0Num);
            auto dtype1 = (aclDataType)*(int *)DT_SetGetNumberEnumV3(i++, aclDataType::ACL_FLOAT, dtype1Enum, dtype1Num);
            int64_t updateType = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 1, -100, 100, "i");
            // === Tiling coverage: per-tensor dtype aliases ===
            aclDataType lseDtype = dtype0;
            aclDataType outDtype = dtype0;
            aclDataType lseOutDtype = dtype0;
            aclDataType localOutDtype = dtype1;
            int dim_num1 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 0, 8, "i");
            std::vector<int64_t> lseShape;
            std::vector<int64_t> localOutShape;
            std::vector<int64_t> outShape;
            std::vector<int64_t> lseOutShape;
            if (dim_num0 == 1) {
                lseShape = {shape1};
            } else if (dim_num0 == 2) {
                lseShape = {shape1, shape2};
            } else if (dim_num0 == 3) {
                lseShape = {shape1, shape2, shape3};
            } else if (dim_num0 == 4) {
                lseShape = {shape1, shape2, shape3, shape4};
            } else if (dim_num0 == 5) {
                lseShape = {shape1, shape2, shape3, shape4, shape5};
            } else if (dim_num0 == 6) {
                lseShape = {shape1, shape2, shape3, shape4, shape5, shape6};
            } else if (dim_num0 == 7) {
                lseShape = {shape1, shape2, shape3, shape4, shape5, shape6, shape7};
            } else if (dim_num0 == 8) {
                lseShape = {shape1, shape2, shape3, shape4, shape5, shape6, shape7, shape8};
            }
            if (dim_num1 == 1) {
                localOutShape = {shape1};
            } else if (dim_num1 == 2) {
                localOutShape = {shape1, shape2};
            } else if (dim_num1 == 3) {
                localOutShape = {shape1, shape2, shape3};
            } else if (dim_num1 == 4) {
                localOutShape = {shape1, shape2, shape3, shape4};
            } else if (dim_num1 == 5) {
                localOutShape = {shape1, shape2, shape3, shape4, shape5};
            } else if (dim_num1 == 6) {
                localOutShape = {shape1, shape2, shape3, shape4, shape5, shape6};
            } else if (dim_num1 == 7) {
                localOutShape = {shape1, shape2, shape3, shape4, shape5, shape6, shape7};
            } else if (dim_num1 == 8) {
                localOutShape = {shape1, shape2, shape3, shape4, shape5, shape6, shape7, shape8};
            }
            outShape = lseShape;
            lseOutShape = lseShape;
            // === Tiling key coverage: 1 scenarios, round-robin (fuzzi % 1), every key >= MIN cases ===
            {
                int caseIdx = fuzzi % 1;
                int modeIdx = -1;
                switch (caseIdx) {
                case 0: { // TK001: bshSize_ == 0
                    printf("[FUZZ_TILING] case_%d: tiling_id=TK001, shape_mode=constraint, dtype=\n", fuzzi);
                    break; (void)modeIdx;
                }
                default: break;
                }
            }
            long long shape_size = GetShapeSize(lseShape);
            if (shape_size > kSingleInputSizeMax) { printf("shape_size too big\n"); goto ERROR; }
            std::vector<float> lseHostData(GetShapeSize(lseShape), 1);
            ret = CreateAclTensor_New(lseHostData, lseShape, &lseDeviceAddr, lseDtype, aclFormat::ACL_FORMAT_ND, &lse);
            CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            std::vector<float> outHostData(GetShapeSize(outShape), 1);
            ret = CreateAclTensor_New(outHostData, outShape, &outDeviceAddr, outDtype, aclFormat::ACL_FORMAT_ND, &out);
            CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            std::vector<float> lseOutHostData(GetShapeSize(lseOutShape), 1);
            ret = CreateAclTensor_New(lseOutHostData, lseOutShape, &lseOutDeviceAddr, lseOutDtype, aclFormat::ACL_FORMAT_ND, &lseOut);
            CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            if (localOutDtype == aclDataType::ACL_FLOAT) {
                std::vector<float> localOutHostData(GetShapeSize(localOutShape), 1);
                ret = CreateAclTensor_New(localOutHostData, localOutShape, &localOutDeviceAddr, localOutDtype, aclFormat::ACL_FORMAT_ND, &localOut);
            CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            } else if (localOutDtype == aclDataType::ACL_FLOAT16) {
                std::vector<int16_t> localOutHostData(GetShapeSize(localOutShape), 1);
                ret = CreateAclTensor_New(localOutHostData, localOutShape, &localOutDeviceAddr, localOutDtype, aclFormat::ACL_FORMAT_ND, &localOut);
            CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            } else if (localOutDtype == aclDataType::ACL_BF16) {
                std::vector<int16_t> localOutHostData(GetShapeSize(localOutShape), 1);
                ret = CreateAclTensor_New(localOutHostData, localOutShape, &localOutDeviceAddr, localOutDtype, aclFormat::ACL_FORMAT_ND, &localOut);
            CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            }

            ret = aclnnAttentionUpdateGetWorkspaceSize(lse, localOut, updateType, out, lseOut, &workspaceSize, &executor);
printf("[FUZZ_PARAM] lse: dtype=%d, shape=%s; localOut: dtype=%d, shape=%s; out: dtype=%d, shape=%s; lseOut: dtype=%d, shape=%s; updateType=%lld\n", (int)dtype0, ShapeToStr(lseShape).c_str(), (int)dtype1, ShapeToStr(localOutShape).c_str(), (int)dtype0, ShapeToStr(outShape).c_str(), (int)dtype0, ShapeToStr(lseOutShape).c_str(), (long long)updateType);
            CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAttentionUpdateGetWorkspaceSize failed. ERROR: %d\n", ret); goto ERROR);
            if (workspaceSize > 0) {
                ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); goto ERROR);
            }
            ret = aclnnAttentionUpdate(workspaceAddr, workspaceSize, executor, stream);
            aclnnRet = (int)ret;
            if (ret == ACL_SUCCESS) { printf("aclnnAttentionUpdate execute success :%d\n", (int)ret); }
            else { printf("aclnnAttentionUpdate execute failed :%d\n", (int)ret); goto ERROR; }
            ret = aclrtSynchronizeStream(stream);
            CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); goto ERROR);
            LOG_PRINT("aclnnAttentionUpdate execute success : %d\n", ret);
        }
        catch (std::exception& e)
        {
            printf("catch exception %s\n", e.what());
        }

ERROR:
        ret = aclrtSynchronizeStream(stream);
        if (aclnnRet == -1) { printf("[FUZZ_RESULT] case_%d: skip, ret=-1\n", fuzzi); }
        else { printf("[FUZZ_RESULT] case_%d: %s, ret=%d\n", fuzzi, (aclnnRet == 0) ? "success" : "faild", aclnnRet); }
        printf("end \n");
        CheckAndLog(ret);
        pid_t pid = getpid();
        std::string cmd = "grep -rin 'aicore error' /root/ascend/log/debug/plog/ ";
        printf("system return value %d\n", CheckResult(pid));
        if (lse) { aclDestroyTensor(lse); }
        if (localOut) { aclDestroyTensor(localOut); }
        if (out) { aclDestroyTensor(out); }
        if (lseOut) { aclDestroyTensor(lseOut); }
        if (lseDeviceAddr) { aclrtFree(lseDeviceAddr); }
        if (localOutDeviceAddr) { aclrtFree(localOutDeviceAddr); }
        if (outDeviceAddr) { aclrtFree(outDeviceAddr); }
        if (lseOutDeviceAddr) { aclrtFree(lseOutDeviceAddr); }
        if (workspaceSize > 0 && workspaceAddr) { aclrtFree(workspaceAddr); }
    }
    DT_FUZZ_END()
    WriteDTLog("aclnnAttentionUpdate", "aclnnAttentionUpdate op fuzz total number:%u, para error number %u, execute error number %u \n", fuzz_num, aclnn_INVALID_Para, aclnn_Inner_Error + Runtime_Error);
    WriteDTLog("aclnnAttentionUpdate", "aclnnAttentionUpdate op fuzz end \n");
    aclrtDestroyStream(stream);
    aclrtDestroyContext(context);
    aclrtResetDevice(deviceId);
    aclFinalize();
    return 0;
}

extern "C" int aclnnAttentionUpdate_fuzz(int argc, char *argv[]);
int aclnnAttentionUpdate_fuzz(int argc, char *argv[])
{
    int fuzz_num = MAXFUZZNUMBER;
    if (argc < 1) {
        cout << "[ERROR] input arg num must be bigger than 1 \n" << endl;
        return -1;
    } else if (argc > 1) {
        fuzz_num = atoi(argv[2]);
    }
    if (argc == 4) { deviceId = atoi(argv[3]); }
    printf("fuzz_num %d \n", fuzz_num);
    printf("aclnnAttentionUpdate_Normal :%d \n", aclnnAttentionUpdate_Normal(fuzz_num));
    return 0;
}