//
// Copyright (c) 2020 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.
//
#include "testBase.h"
#include "harness/propertyHelpers.h"
#include "harness/typeWrappers.h"
#include <vector>
#include <algorithm>

struct test_queue_array_properties_data
{
    std::vector<cl_queue_properties> properties;
    std::string description;
};

int verify_if_properties_supported(
    cl_device_id deviceID, cl_command_queue_properties requested_bitfield,
    cl_uint requested_size)
{
    int error = CL_SUCCESS;
    bool on_host_queue = true;

    if (requested_bitfield & CL_QUEUE_ON_DEVICE)
    {
        on_host_queue = false;

        if (requested_size > 0)
        {
            cl_uint max_queue_size = 0;
            error =
                clGetDeviceInfo(deviceID, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE,
                                sizeof(max_queue_size), &max_queue_size, NULL);
            test_error(error,
                       "clGetDeviceInfo for "
                       "CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE failed");
            if (requested_size > max_queue_size)
            {
                log_info(
                    "The value of CL_QUEUE_SIZE = %d cannot be bigger than "
                    "CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE = %d, skipped\n",
                    requested_size, max_queue_size);
                return TEST_SKIPPED_ITSELF;
            }
        }
    }

    cl_command_queue_properties supported_properties = 0;
    cl_command_queue_properties all_properties = 0;

    std::vector<cl_command_queue_properties> all_properties_vector{
        CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_PROFILING_ENABLE
    };
    for (auto each_property : all_properties_vector)
    {
        all_properties |= each_property;
    }
    cl_command_queue_properties requested_properties =
        all_properties & requested_bitfield;

    if (on_host_queue)
    {
        error = clGetDeviceInfo(deviceID, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES,
                                sizeof(supported_properties),
                                &supported_properties, NULL);
        test_error(error,
                   "clGetDeviceInfo asking for "
                   "CL_DEVICE_QUEUE_ON_HOST_PROPERTIES failed");
    }
    else
    {
        error = clGetDeviceInfo(deviceID, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES,
                                sizeof(supported_properties),
                                &supported_properties, NULL);
        test_error(error,
                   "clGetDeviceInfo asking for "
                   "CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES failed");
    }

    for (auto each_property : all_properties_vector)
    {
        if ((each_property & requested_properties)
            && !(each_property & supported_properties))
        {
            log_info("\t%s not supported, skipped\n",
                     GetQueuePropertyName(each_property));
            return TEST_SKIPPED_ITSELF;
        }
        else if ((each_property & requested_properties)
                 && each_property & supported_properties)
        {
            log_info("\t%s supported\n", GetQueuePropertyName(each_property));
        }
    }
    return error;
}

static int create_queue_and_check_array_properties(
    cl_context context, cl_device_id deviceID,
    test_queue_array_properties_data test_case)
{
    cl_int error = CL_SUCCESS;

    clCommandQueueWrapper test_queue;

    if (test_case.properties.size() > 0)
    {
        test_queue = clCreateCommandQueueWithProperties(
            context, deviceID, test_case.properties.data(), &error);
        test_error(error, "clCreateCommandQueueWithProperties failed");
    }
    else
    {
        test_queue =
            clCreateCommandQueueWithProperties(context, deviceID, NULL, &error);
        test_error(error, "clCreateCommandQueueWithProperties failed");
    }

    std::vector<cl_queue_properties> check_properties;
    size_t set_size = 0;

    error = clGetCommandQueueInfo(test_queue, CL_QUEUE_PROPERTIES_ARRAY, 0,
                                  NULL, &set_size);
    test_error(error,
               "clGetCommandQueueInfo failed asking for "
               "CL_QUEUE_PROPERTIES_ARRAY size.");

    if (set_size == 0 && test_case.properties.size() == 0)
    {
        return TEST_PASS;
    }
    if (set_size != test_case.properties.size() * sizeof(cl_queue_properties))
    {
        log_error("ERROR: CL_QUEUE_PROPERTIES_ARRAY size is %d, expected %d.\n",
                  set_size,
                  test_case.properties.size() * sizeof(cl_queue_properties));
        return TEST_FAIL;
    }

    cl_uint number_of_props = set_size / sizeof(cl_queue_properties);
    check_properties.resize(number_of_props);
    error = clGetCommandQueueInfo(test_queue, CL_QUEUE_PROPERTIES_ARRAY,
                                  set_size, check_properties.data(), NULL);
    test_error(
        error,
        "clGetCommandQueueInfo failed asking for CL_QUEUE_PROPERTIES_ARRAY.");

    error = compareProperties(check_properties, test_case.properties);
    return error;
}

static int
run_test_queue_array_properties(cl_context context, cl_device_id deviceID,
                                test_queue_array_properties_data test_case)
{
    int error = TEST_PASS;

    std::vector<cl_queue_properties> requested_properties =
        test_case.properties;
    log_info("\nTC description: %s\n", test_case.description.c_str());

    // first verify if user properties are supported
    if (requested_properties.size() != 0)
    {
        requested_properties.pop_back();
        cl_command_queue_properties requested_bitfield = 0;
        cl_uint requested_size = 0;
        for (cl_uint i = 0; i < requested_properties.size(); i = i + 2)
        {
            if (requested_properties[i] == CL_QUEUE_PROPERTIES)
            {
                requested_bitfield = requested_properties[i + 1];
            }
            if (requested_properties[i] == CL_QUEUE_SIZE)
            {
                requested_size = requested_properties[i + 1];
            }
        }

        error = verify_if_properties_supported(deviceID, requested_bitfield,
                                               requested_size);
        if (error == TEST_SKIPPED_ITSELF)
        {
            log_info("TC result: skipped\n");
            return TEST_PASS;
        }
        test_error(error,
                   "Checking which queue properties supported failed.\n");
    }

    // continue testing if supported user properties
    error =
        create_queue_and_check_array_properties(context, deviceID, test_case);
    test_error(error, "create_queue_and_check_array_properties failed.\n");

    log_info("TC result: passed\n");
    return TEST_PASS;
}

int test_queue_properties_queries(cl_device_id deviceID, cl_context context,
                                  cl_command_queue queue, int num_elements)
{
    int error = TEST_PASS;
    std::vector<test_queue_array_properties_data> test_cases;

    test_cases.push_back({ {}, "host queue, NULL properties" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES, 0, 0 }, "host queue, zero properties" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0 },
          "host queue, CL_QUEUE_PROFILING_ENABLE" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0 },
          "host queue, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES,
            CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_PROFILING_ENABLE,
            0 },
          "host queue, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | "
          "CL_QUEUE_PROFILING_ENABLE" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES,
            CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE, 0 },
          "device queue, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | "
          "CL_QUEUE_ON_DEVICE" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES,
            CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE
                | CL_QUEUE_ON_DEVICE_DEFAULT | CL_QUEUE_PROFILING_ENABLE,
            CL_QUEUE_SIZE, 124, 0 },
          "device queue, all possible properties" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES,
            CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE
                | CL_QUEUE_PROFILING_ENABLE,
            CL_QUEUE_SIZE, 124, 0 },
          "device queue, all without CL_QUEUE_ON_DEVICE_DEFAULT" });

    test_cases.push_back(
        { { CL_QUEUE_PROPERTIES,
            CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE
                | CL_QUEUE_ON_DEVICE_DEFAULT | CL_QUEUE_PROFILING_ENABLE,
            0 },
          "device queue, all without CL_QUEUE_SIZE" });

    for (auto test_case : test_cases)
    {
        error |= run_test_queue_array_properties(context, deviceID, test_case);
    }
    return error;
}