//
// Copyright (c) 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.
//
#ifndef test_conformance_check_mem_host_read_only_h
#define test_conformance_check_mem_host_read_only_h

#include "checker.h"

template <class T>
class cBuffer_check_mem_host_read_only : public cBuffer_checker<T> {
public:
    cBuffer_check_mem_host_read_only(cl_device_id deviceID, cl_context context,
                                     cl_command_queue queue)
        : cBuffer_checker<T>(deviceID, context, queue){};

    ~cBuffer_check_mem_host_read_only(){};

    virtual cl_int Check_GetMemObjectInfo(cl_mem_flags buffer_mem_flag);
    virtual cl_int SetupBuffer();
    virtual cl_int SetupASSubBuffer(cl_mem_flags flag_p);
    virtual cl_int Setup_Test_Environment();

    cl_int verifyData(cl_int err, cl_event &event);
    cl_int verify_RW_Buffer();
    cl_int verify_RW_Buffer_rect();
    cl_int verify_RW_Buffer_mapping();
};

template <class T> cl_int cBuffer_check_mem_host_read_only<T>::SetupBuffer()
{
    this->m_buffer_type = _BUFFER;

    this->m_nNumber_elements = 888;
    T vv1 = TEST_VALUE;
    this->host_m_1.Init(this->m_nNumber_elements, vv1);
    this->host_m_0.Init(this->m_nNumber_elements, vv1);

    cl_int err = CL_SUCCESS;
    int block_size_in_byte = (int)(this->m_nNumber_elements * sizeof(T));
    this->m_buffer =
        clCreateBuffer(this->m_context, this->buffer_mem_flag,
                       block_size_in_byte, this->host_m_1.pData, &err);
    test_error(err, "clCreateBuffer error");

    if (this->buffer_mem_flag & CL_MEM_USE_HOST_PTR)
    {
        this->pHost_ptr = (void *)this->host_m_1.pData;
    }

    return err;
}

template <class T>
cl_int
cBuffer_check_mem_host_read_only<T>::SetupASSubBuffer(cl_mem_flags flag_p)
{
    return cBuffer_checker<T>::SetupASSubBuffer(flag_p);
}

template <class T>
cl_int cBuffer_check_mem_host_read_only<T>::Setup_Test_Environment()
{
    cBuffer_checker<T>::Setup_Test_Environment();
    T vv2 = 0;
    this->host_m_2.Init(this->m_nNumber_elements, vv2);

    return CL_SUCCESS;
}

template <class T>
cl_int cBuffer_check_mem_host_read_only<T>::Check_GetMemObjectInfo(
    cl_mem_flags buffer_mem_flag)
{
    cl_int err = CL_SUCCESS;
    cBuffer_checker<T>::Check_GetMemObjectInfo(buffer_mem_flag);

    if (buffer_mem_flag & CL_MEM_ALLOC_HOST_PTR)
    {
        size_t size = 0;
        err = clGetMemObjectInfo(this->m_buffer, CL_MEM_SIZE, sizeof(size),
                                 &size, NULL);
        void *pp = NULL;
        err = clGetMemObjectInfo(this->m_buffer, CL_MEM_HOST_PTR, sizeof(pp),
                                 &pp, NULL);

        if (!this->host_m_1.Equal((T *)(this->pData), this->m_nNumber_elements))
        {
            log_error("Buffer data difference found\n");
            return FAILURE;
        }
    }

    return err;
}

template <class T>
cl_int cBuffer_check_mem_host_read_only<T>::verifyData(cl_int err,
                                                       cl_event &event)
{
    if (err != CL_SUCCESS)
    {
        err = this->m_nERROR_RETURN_CODE;
        test_error(err, "clEnqueueReadBuffer error");
    }

    if (!this->host_m_1.Equal(this->host_m_2))
    {
        err = this->m_nERROR_RETURN_CODE;
        test_error(err, "clEnqueueReadBuffer data difference found");
    }

    return err;
}

template <class T>
cl_int cBuffer_check_mem_host_read_only<T>::verify_RW_Buffer()
{
    cl_event event;
    cl_int err = CL_SUCCESS;

    err = clEnqueueReadBuffer(this->m_queue, this->m_buffer, this->m_blocking,
                              0, this->get_block_size_bytes(),
                              this->host_m_2.pData, 0, NULL, &event);
    test_error(err, "clEnqueueReadBuffer error");

    if (!this->m_blocking)
    {
        err = clWaitForEvents(1, &event);
        test_error(err, "clWaitForEvents error");
    }

    if (!this->host_m_1.Equal(this->host_m_2))
    {
        log_error("Buffer data difference found\n");
        return FAILURE;
    }
    err = clReleaseEvent(event);
    test_error(err, "clReleaseEvent error");

    // test write
    err = clEnqueueWriteBuffer(this->m_queue, this->m_buffer, this->m_blocking,
                               0, this->get_block_size_bytes(),
                               this->host_m_2.pData, 0, NULL, &event);

    if (err == CL_SUCCESS)
    {
        log_error(
            "Calling clEnqueueWriteBuffer on a memory object created with the "
            "CL_MEM_HOST_READ_ONLY flag should not return CL_SUCCESS\n");
        err = FAILURE;
        return FAILURE;
    }
    else
    {
        log_info("Test succeeded\n\n");
        err = CL_SUCCESS;
    }

    return err;
}

template <class T>
cl_int cBuffer_check_mem_host_read_only<T>::verify_RW_Buffer_rect()
{
    this->Init_rect();

    T vv2 = 0;
    this->host_m_2.Set_to(vv2);
    cl_event event;
    cl_int err = CL_SUCCESS;

    err = clEnqueueReadBufferRect(
        this->m_queue, this->m_buffer, this->m_blocking,
        this->buffer_origin_bytes, this->host_origin_bytes, this->region_bytes,
        this->buffer_row_pitch_bytes, this->buffer_slice_pitch_bytes,
        this->host_row_pitch_bytes, this->host_slice_pitch_bytes,
        this->host_m_2.pData, 0, NULL, &event);
    test_error(err, "clEnqueueReadBufferRect error");

    if (!this->m_blocking)
    {
        err = clWaitForEvents(1, &event);
        test_error(err, "clWaitForEvents error");
    }

    if (!this->host_m_1.Equal_rect(this->host_m_2, this->host_origin,
                                   this->region, this->host_row_pitch,
                                   this->host_slice_pitch))
    {
        log_error("Buffer data diffeence found\n");
        return FAILURE;
    }
    err = clReleaseEvent(event);
    test_error(err, "clReleaseEvent error");

    // test blocking write rect
    err = clEnqueueWriteBufferRect(
        this->m_queue, this->m_buffer, this->m_blocking,
        this->buffer_origin_bytes, this->host_origin_bytes, this->region_bytes,
        this->buffer_row_pitch_bytes, this->buffer_slice_pitch_bytes,
        this->host_row_pitch_bytes, this->host_slice_pitch_bytes,
        this->host_m_2.pData, 0, NULL, &event);

    if (err == CL_SUCCESS)
    {
        log_error(
            "Calling clEnqueueWriteBufferRect on a memory object created with "
            "the CL_MEM_HOST_READ_ONLY flag should not return CL_SUCCESS\n");
        err = FAILURE;
        return FAILURE;
    }
    else
    {
        log_info("Test succeeded\n\n");
        err = CL_SUCCESS;
    }

    return err;
}

template <class T>
cl_int cBuffer_check_mem_host_read_only<T>::verify_RW_Buffer_mapping()
{
    cl_int err = CL_SUCCESS;
    cl_event event;
    void *dataPtr;
    dataPtr = clEnqueueMapBuffer(
        this->m_queue, this->m_buffer, this->m_blocking, CL_MAP_READ, 0,
        this->get_block_size_bytes(), 0, NULL, &event, &err);
    test_error(err, "clEnqueueMapBuffer error");

    if (!this->m_blocking)
    {
        err = clWaitForEvents(1, &event);
        test_error(err, "clWaitForEvents error");
    }

    if ((this->buffer_mem_flag & CL_MEM_USE_HOST_PTR)
        && dataPtr != this->pHost_ptr)
    {
        log_error("Mapped host pointer difference found\n");
        return FAILURE;
    }

    if (!this->host_m_1.Equal((T *)dataPtr, this->m_nNumber_elements))
    {
        log_error("Buffer content difference found\n");
        return FAILURE;
    }

    err = clReleaseEvent(event);
    test_error(err, "clReleaseEvent error");

    err = clEnqueueUnmapMemObject(this->m_queue, this->m_buffer, dataPtr, 0,
                                  nullptr, nullptr);
    test_error(err, "clEnqueueUnmapMemObject error");

    //  test blocking map read
    clEnqueueMapBuffer(this->m_queue, this->m_buffer, this->m_blocking,
                       CL_MAP_WRITE, 0, this->get_block_size_bytes(), 0, NULL,
                       &event, &err);

    if (err == CL_SUCCESS)
    {
        log_error("Calling clEnqueueMapBuffer (CL_MAP_WRITE) on a memory "
                  "object created with the CL_MEM_HOST_READ_ONLY flag should "
                  "not return CL_SUCCESS\n");
        err = FAILURE;
        return FAILURE;
    }
    else
    {
        log_info("Test succeeded\n\n");
        err = CL_SUCCESS;
    }

    return err;
}

#endif