//
// 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.
//
#include "harness/compat.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>


#include "procs.h"
#include "harness/conversions.h"
#include "harness/typeWrappers.h"

const cl_mem_flags flag_set[] = {
  CL_MEM_ALLOC_HOST_PTR,
  CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR,
  CL_MEM_USE_HOST_PTR,
  CL_MEM_COPY_HOST_PTR,
  0
};
const char* flag_set_names[] = {
  "CL_MEM_ALLOC_HOST_PTR",
  "CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR",
  "CL_MEM_USE_HOST_PTR",
  "CL_MEM_COPY_HOST_PTR",
  "0"
};

int test_enqueue_map_buffer(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
    int error;
    const size_t bufferSize = 256*256;
    MTdataHolder d{gRandomSeed};
    BufferOwningPtr<cl_char> hostPtrData{ malloc(bufferSize) };
    BufferOwningPtr<cl_char> referenceData{ malloc(bufferSize) };
    BufferOwningPtr<cl_char> finalData{malloc(bufferSize)};

    for (int src_flag_id=0; src_flag_id < ARRAY_SIZE(flag_set); src_flag_id++)
    {
        clMemWrapper memObject;
        log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]);

        generate_random_data(kChar, (unsigned int)bufferSize, d, hostPtrData);
        memcpy(referenceData, hostPtrData, bufferSize);

        void *hostPtr = nullptr;
        cl_mem_flags flags = flag_set[src_flag_id];
        bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR);
        if (hasHostPtr) hostPtr = hostPtrData;
        memObject = clCreateBuffer(context, flags,  bufferSize, hostPtr, &error);
        test_error( error, "Unable to create testing buffer" );

        if (!hasHostPtr)
        {
            error =
            clEnqueueWriteBuffer(queue, memObject, CL_TRUE, 0, bufferSize,
                                 hostPtrData, 0, NULL, NULL);
            test_error( error, "clEnqueueWriteBuffer failed");
        }

        for( int i = 0; i < 128; i++ )
        {

          size_t offset = (size_t)random_in_range( 0, (int)bufferSize - 1, d );
          size_t length = (size_t)random_in_range( 1, (int)( bufferSize - offset ), d );

          cl_char *mappedRegion = (cl_char *)clEnqueueMapBuffer( queue, memObject, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE,
                                                                offset, length, 0, NULL, NULL, &error );
          if( error != CL_SUCCESS )
          {
            print_error( error, "clEnqueueMapBuffer call failed" );
            log_error( "\tOffset: %d  Length: %d\n", (int)offset, (int)length );
            return -1;
          }

          // Write into the region
          for( size_t j = 0; j < length; j++ )
          {
            cl_char spin = (cl_char)genrand_int32( d );

            // Test read AND write in one swipe
            cl_char value = mappedRegion[ j ];
            value = spin - value;
            mappedRegion[ j ] = value;

            // Also update the initial data array
            value = referenceData[offset + j];
            value = spin - value;
            referenceData[offset + j] = value;
          }

          // Unmap
          error = clEnqueueUnmapMemObject( queue, memObject, mappedRegion, 0, NULL, NULL );
          test_error( error, "Unable to unmap buffer" );
        }

        // Final validation: read actual values of buffer and compare against our reference
        error = clEnqueueReadBuffer( queue, memObject, CL_TRUE, 0, bufferSize, finalData, 0, NULL, NULL );
        test_error( error, "Unable to read results" );

        for( size_t q = 0; q < bufferSize; q++ )
        {
            if (referenceData[q] != finalData[q])
            {
                log_error(
                "ERROR: Sample %d did not validate! Got %d, expected %d\n",
                (int)q, (int)finalData[q], (int)referenceData[q]);
                return -1;
            }
        }
    } // cl_mem flags

    return 0;
}

int test_enqueue_map_image(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
    int error;
    cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT32 };
    const size_t imageSize = 256;
    const size_t imageDataSize = imageSize * imageSize * 4 * sizeof(cl_uint);

    PASSIVE_REQUIRE_IMAGE_SUPPORT( deviceID )

    BufferOwningPtr<cl_uint> hostPtrData{ malloc(imageDataSize) };
    BufferOwningPtr<cl_uint> referenceData{ malloc(imageDataSize) };
    BufferOwningPtr<cl_uint> finalData{malloc(imageDataSize)};

    MTdataHolder d{gRandomSeed};
  for (int src_flag_id=0; src_flag_id < ARRAY_SIZE(flag_set); src_flag_id++) {
    clMemWrapper memObject;
    log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]);

    generate_random_data(kUInt, (unsigned int)(imageSize * imageSize), d,
                         hostPtrData);
    memcpy(referenceData, hostPtrData, imageDataSize);

    cl_mem_flags flags = flag_set[src_flag_id];
    bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR);
    void *hostPtr = nullptr;
    if (hasHostPtr) hostPtr = hostPtrData;
    memObject = create_image_2d(context, CL_MEM_READ_WRITE | flags, &format,
                                imageSize, imageSize, 0, hostPtr, &error );
    test_error( error, "Unable to create testing buffer" );

    if (!hasHostPtr) {
      size_t write_origin[3]={0,0,0}, write_region[3]={imageSize, imageSize, 1};
      error =
      clEnqueueWriteImage(queue, memObject, CL_TRUE, write_origin, write_region,
                          0, 0, hostPtrData, 0, NULL, NULL);
      test_error( error, "Unable to write to testing buffer" );
    }

    for( int i = 0; i < 128; i++ )
    {

      size_t offset[3], region[3];
      size_t rowPitch;

      offset[ 0 ] = (size_t)random_in_range( 0, (int)imageSize - 1, d );
      region[ 0 ] = (size_t)random_in_range( 1, (int)( imageSize - offset[ 0 ] - 1), d );
      offset[ 1 ] = (size_t)random_in_range( 0, (int)imageSize - 1, d );
      region[ 1 ] = (size_t)random_in_range( 1, (int)( imageSize - offset[ 1 ] - 1), d );
      offset[ 2 ] = 0;
      region[ 2 ] = 1;
      cl_uint *mappedRegion = (cl_uint *)clEnqueueMapImage( queue, memObject, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE,
                                                           offset, region, &rowPitch, NULL, 0, NULL, NULL, &error );
      if( error != CL_SUCCESS )
      {
        print_error( error, "clEnqueueMapImage call failed" );
        log_error( "\tOffset: %d,%d  Region: %d,%d\n", (int)offset[0], (int)offset[1], (int)region[0], (int)region[1] );
        return -1;
      }

      // Write into the region
      cl_uint *mappedPtr = mappedRegion;
      for( size_t y = 0; y < region[ 1 ]; y++ )
      {
        for( size_t x = 0; x < region[ 0 ] * 4; x++ )
        {
          cl_int spin = (cl_int)random_in_range( 16, 1024, d );

          cl_int value;
          // Test read AND write in one swipe
          value = mappedPtr[ ( y * rowPitch/sizeof(cl_uint) ) + x ];
          value = spin - value;
          mappedPtr[ ( y * rowPitch/sizeof(cl_uint) ) + x ] = value;

          // Also update the initial data array
          value =
          referenceData[((offset[1] + y) * imageSize + offset[0]) * 4 + x];
          value = spin - value;
          referenceData[((offset[1] + y) * imageSize + offset[0]) * 4 + x] =
          value;
        }
      }

      // Unmap
      error = clEnqueueUnmapMemObject( queue, memObject, mappedRegion, 0, NULL, NULL );
      test_error( error, "Unable to unmap buffer" );
    }

    // Final validation: read actual values of buffer and compare against our reference
    size_t finalOrigin[3] = { 0, 0, 0 }, finalRegion[3] = { imageSize, imageSize, 1 };
    error = clEnqueueReadImage( queue, memObject, CL_TRUE, finalOrigin, finalRegion, 0, 0, finalData, 0, NULL, NULL );
    test_error( error, "Unable to read results" );

    for( size_t q = 0; q < imageSize * imageSize * 4; q++ )
    {
        if (referenceData[q] != finalData[q])
        {
            log_error("ERROR: Sample %d (coord %d,%d) did not validate! Got "
                      "%d, expected %d\n",
                      (int)q, (int)((q / 4) % imageSize),
                      (int)((q / 4) / imageSize), (int)finalData[q],
                      (int)referenceData[q]);
            return -1;
        }
    }
  } // cl_mem_flags

    return 0;
}