/*

 * Copyright (c) 2012-2017 The Khronos Group Inc.
 *
 * 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.
 */

#ifdef OPENVX_USE_IX

#include <string.h>
#include <VX/vx.h>
#include <VX/vxu.h>
#include <VX/vx_khr_ix.h>

#include "test_engine/test.h"

#define TEST_TENSOR_MIN_DIM_SZ                  1
#define TEST_TENSOR_MAX_DIM_SZ                  20

TESTCASE(ExtensionObject, CT_VXContext, ct_setup_vx_context, 0)

typedef struct
{
    const char* name;
    vx_enum     type;
} format_arg;

#define EXPORT_IMPORT_TEST_CASE(tp) \
    {#tp, tp}

static vx_size lut_count(vx_enum data_type)
{
    vx_size count = 0;

    switch (data_type)
    {
    case VX_TYPE_UINT8:
        count = 256;
        break;
    case VX_TYPE_INT16:
        count = 65536;
        break;
    }

    return count;
}

TEST_WITH_ARG(ExtensionObject, testExtensionObject, format_arg,
        EXPORT_IMPORT_TEST_CASE(VX_IX_USE_EXPORT_VALUES),
        EXPORT_IMPORT_TEST_CASE(VX_IX_USE_NO_EXPORT_VALUES),
        EXPORT_IMPORT_TEST_CASE(VX_IX_USE_APPLICATION_CREATE),
        )
{
    vx_context context = context_->vx_context_;
    vx_reference reference_list[13];
    vx_reference import_list[13]={NULL};
    vx_enum uses_list[] = {
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        VX_IX_USE_EXPORT_VALUES
    };

    vx_enum uses_import_list[] = {
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        arg_->type,
        VX_IX_USE_EXPORT_VALUES
    };

    const vx_uint8 *blob_ptr = NULL;
    vx_size blob_bytes = 0;

    vx_image image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
    reference_list[0] = (vx_reference ) image;

    vx_size count = lut_count(VX_TYPE_UINT8);
    vx_lut lut = vxCreateLUT(context, VX_TYPE_UINT8, count);
    const char* lut_name= "Lut";
    VX_CALL(vxSetReferenceName((vx_reference)lut, lut_name));
    reference_list[1] = (vx_reference ) lut;

    vx_distribution distribution = vxCreateDistribution(context, 32, 0, 255);
    reference_list[2] = (vx_reference ) distribution;

    vx_threshold threshold = vxCreateThreshold(context, VX_THRESHOLD_TYPE_BINARY, VX_TYPE_UINT8);
    reference_list[3] = (vx_reference ) threshold;

    vx_matrix matrix = vxCreateMatrix(context, VX_TYPE_UINT8, 3, 5);
    reference_list[4] = (vx_reference ) matrix;

    vx_convolution conv = vxCreateConvolution(context, 3, 3);
    reference_list[5] = (vx_reference ) conv;

    vx_char ref = 1;
    vx_scalar scalar = vxCreateScalar(context, VX_TYPE_CHAR, &ref);
    reference_list[6] = (vx_reference ) scalar;

    vx_array array = vxCreateArray(context, VX_TYPE_COORDINATES2D, 10);
    reference_list[7] = (vx_reference ) array;

    vx_remap map = vxCreateRemap(context, 16, 32, 128, 64);
    reference_list[8] = (vx_reference ) map;

    vx_pyramid pyramid = vxCreatePyramid(context, 2, VX_SCALE_PYRAMID_HALF,  320, 240, VX_DF_IMAGE_S16);
    reference_list[9] = (vx_reference ) pyramid;

    vx_image imagedelay = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
    vx_delay delay = vxCreateDelay(context, (vx_reference)imagedelay, 2);
    reference_list[10] = (vx_reference ) delay;

    uint64_t rng;
    {
        uint64_t * seed = &CT()->seed_;
        ASSERT(!!seed);
        CT_RNG_INIT(rng, *seed);
    }

    size_t in_dims[4];
    in_dims[0] = 5;
    in_dims[1] = 3;
    in_dims[2] = (size_t)CT_RNG_NEXT_INT(rng, TEST_TENSOR_MIN_DIM_SZ, TEST_TENSOR_MAX_DIM_SZ+1);
    in_dims[3] = (size_t)CT_RNG_NEXT_INT(rng, TEST_TENSOR_MIN_DIM_SZ, TEST_TENSOR_MAX_DIM_SZ+1);

    vx_uint8 fixed_point_position = 0;
    vx_tensor tensor = vxCreateTensor(context, 4, in_dims, VX_TYPE_UINT8, fixed_point_position);
    ASSERT_VX_OBJECT(tensor, VX_TYPE_TENSOR);
    reference_list[11] = (vx_reference ) tensor;

    vx_image src_image = 0, interm_image = 0, dst_image = 0;
    ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
    vx_graph graph = vxCreateGraph(context);
    vxGaussian3x3Node(graph, src_image, interm_image);
    vxIntegralImageNode(graph, interm_image, dst_image);
    VX_CALL(vxVerifyGraph(graph));
    reference_list[12] = (vx_reference ) graph;

    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxExportObjectsToMemory( context, 13, &reference_list[0], &uses_list[0], &blob_ptr, &blob_bytes));
    void * export_blob = malloc(blob_bytes);
    memcpy(export_blob, blob_ptr, blob_bytes);

    VX_CALL(vxReleaseImage(&image));
    VX_CALL(vxReleaseLUT(&lut));
    VX_CALL(vxReleaseDistribution(&distribution));
    VX_CALL(vxReleaseThreshold(&threshold));
    VX_CALL(vxReleaseMatrix(&matrix));
    VX_CALL(vxReleaseConvolution(&conv));
    VX_CALL(vxReleaseScalar(&scalar));
    VX_CALL(vxReleaseArray(&array));
    VX_CALL(vxReleaseRemap(&map));
    VX_CALL(vxReleasePyramid(&pyramid));
    VX_CALL(vxReleaseDelay(&delay));
    VX_CALL(vxReleaseImage(&imagedelay));
    VX_CALL(vxReleaseTensor(&tensor));
    VX_CALL(vxReleaseImage(&src_image));
    VX_CALL(vxReleaseImage(&interm_image));
    VX_CALL(vxReleaseImage(&dst_image));
    VX_CALL(vxReleaseGraph(&graph));
    VX_CALL(vxReleaseExportedMemory(context, &blob_ptr));
    //VX_CALL(vxReleaseContext(&context));

    vx_context context1 = vxCreateContext();
    vx_image image1 = vxCreateImage(context1, 128, 128, VX_DF_IMAGE_U8);
    import_list[0] = (vx_reference ) image1;
    vx_lut lut1 = vxCreateLUT(context1, VX_TYPE_UINT8, count);
    VX_CALL(vxSetReferenceName((vx_reference)lut1, lut_name));
    import_list[1] = (vx_reference ) lut1;
    vx_distribution distribution1 = vxCreateDistribution(context1, 32, 0, 255);
    import_list[2] = (vx_reference ) distribution1;
    vx_threshold threshold1 = vxCreateThreshold(context1, VX_THRESHOLD_TYPE_BINARY, VX_TYPE_UINT8);
    import_list[3] = (vx_reference ) threshold1;
    vx_matrix matrix1 = vxCreateMatrix(context1, VX_TYPE_UINT8, 3, 5);
    import_list[4] = (vx_reference ) matrix1;
    vx_convolution conv1 = vxCreateConvolution(context1, 3, 3);
    import_list[5] = (vx_reference ) conv1;
    vx_scalar scalar1 = vxCreateScalar(context1, VX_TYPE_CHAR, &ref);
    import_list[6] = (vx_reference ) scalar1;
    vx_array array1 = vxCreateArray(context1, VX_TYPE_COORDINATES2D, 10);
    import_list[7] = (vx_reference ) array1;
    vx_remap map1 = vxCreateRemap(context1, 16, 32, 128, 64);
    import_list[8] = (vx_reference ) map1;
    vx_pyramid pyramid1 = vxCreatePyramid(context1, 2, VX_SCALE_PYRAMID_HALF,  320, 240, VX_DF_IMAGE_S16);
    import_list[9] = (vx_reference ) pyramid1;
    vx_image imagedelay1 = vxCreateImage(context1, 128, 128, VX_DF_IMAGE_U8);
    vx_delay delay1 = vxCreateDelay(context1, (vx_reference)imagedelay1, 2);
    import_list[10] = (vx_reference ) delay1;
    vx_tensor tensor1 = vxCreateTensor(context1, 4, in_dims, VX_TYPE_UINT8, fixed_point_position);
    ASSERT_VX_OBJECT(tensor1, VX_TYPE_TENSOR);
    import_list[11] = (vx_reference ) tensor1;

    vx_import import = vxImportObjectsFromMemory ( context1, 13, &import_list[0], &uses_import_list[0], export_blob, blob_bytes );
    ASSERT_VX_OBJECT(import, VX_TYPE_IMPORT);
    ASSERT_VX_OBJECT((vx_lut)import_list[2], VX_TYPE_DISTRIBUTION);

    vx_reference name_reference = vxGetImportReferenceByName(import, lut_name);

    ASSERT_VX_OBJECT((vx_lut)name_reference, VX_TYPE_LUT);
    ASSERT(vxGetStatus(name_reference) == VX_SUCCESS);


    VX_CALL(vxReleaseImage(&image1));
    VX_CALL(vxReleaseLUT(&lut1));
    VX_CALL(vxReleaseDistribution(&distribution1));
    VX_CALL(vxReleaseThreshold(&threshold1));
    VX_CALL(vxReleaseMatrix(&matrix1));
    VX_CALL(vxReleaseConvolution(&conv1));
    VX_CALL(vxReleaseScalar(&scalar1));
    VX_CALL(vxReleaseArray(&array1));
    VX_CALL(vxReleaseRemap(&map1));
    VX_CALL(vxReleasePyramid(&pyramid1));
    VX_CALL(vxReleaseImage(&imagedelay1));
    VX_CALL(vxReleaseDelay(&delay1));
    VX_CALL(vxReleaseTensor(&tensor1));


    if(arg_->type != VX_IX_USE_APPLICATION_CREATE)
    {
        vxReleaseReference(&import_list[0]);
        vxReleaseReference(&import_list[1]);
        vxReleaseReference(&import_list[2]);
        vxReleaseReference(&import_list[3]);
        vxReleaseReference(&import_list[4]);
        vxReleaseReference(&import_list[5]);
        vxReleaseReference(&import_list[6]);
        vxReleaseReference(&import_list[7]);
        vxReleaseReference(&import_list[8]);
        vxReleaseReference(&import_list[9]);
        vxReleaseReference(&import_list[10]);
        vxReleaseReference(&import_list[11]);
    }
    vxReleaseReference(&import_list[12]);

    vxReleaseReference(&name_reference);

    ASSERT_EQ_VX_STATUS(VX_SUCCESS,vxReleaseImport(&import));
    free(export_blob);
}

TESTCASE_TESTS(ExtensionObject, testExtensionObject)

#endif