/*
 * Copyright (C) 2015, Samsung Electronics Co. LTD
 *
 * 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.
 */

#define LOG_TAG "ExynosVisionArray"
#include <cutils/log.h>

#include <VX/vx.h>

#include "ExynosVisionArray.h"

#include "ExynosVisionContext.h"
#include "ExynosVisionDelay.h"

namespace android {

static vx_size vxArrayItemSize(ExynosVisionContext *context, vx_enum item_type)
{
    vx_size res = ExynosVisionReference::sizeOfType(item_type);
    if (res == 0ul)
        res = context->getUserStructsSize(item_type);

    return res;
}

vx_status
ExynosVisionArray::checkValidCreateArray(ExynosVisionContext *context, vx_enum item_type, vx_size capacity)
{
    vx_status status = VX_SUCCESS;
    if (vxArrayItemSize(context, item_type) == 0) {
        VXLOGE("creating array's parameter is not valid, item_type(0x%X), capacity(%d)", item_type, capacity);
        status = VX_ERROR_INVALID_PARAMETERS;
    }

    return status;
}

ExynosVisionArray::ExynosVisionArray(ExynosVisionContext *context, ExynosVisionReference *scope, vx_bool is_virtual)
                                                               : ExynosVisionDataReference(context, VX_TYPE_ARRAY, scope, vx_true_e, is_virtual)
{
    m_res_mngr = NULL;
    m_cur_res = NULL;

    memset(&m_memory, 0x0, sizeof(m_memory));

    m_item_type = VX_TYPE_INVALID;
    m_item_size = 0;
    m_num_items = 0;
    m_capacity = 0;

#ifdef USE_OPENCL_KERNEL
    m_cl_memory.allocated = vx_false_e;
#endif
}

ExynosVisionArray::~ExynosVisionArray()
{

}

void
ExynosVisionArray::operator=(const ExynosVisionArray& src_array)
{
    m_item_type = src_array.m_item_type;
    m_item_size = src_array.m_item_size;
    m_capacity = src_array.m_capacity;
}

vx_status
ExynosVisionArray::init(vx_enum item_type, vx_size capacity)
{
    vx_status status = VX_SUCCESS;

    m_item_type = item_type;
    m_item_size = vxArrayItemSize(getContext(), item_type);
    m_capacity = capacity;

    return status;
}

vx_status
ExynosVisionArray::destroy(void)
{
    vx_status status = VX_SUCCESS;

    m_cur_res = NULL;

    memset(&m_memory, 0x0, sizeof(m_memory));

    m_item_type = VX_TYPE_INVALID;
    m_item_size = 0;
    m_num_items = 0;
    m_capacity = 0;

    status = freeMemory_T<default_resource_t>(&m_res_mngr, &m_res_list);
    if (status != VX_SUCCESS)
        VXLOGE("free memory fails at %s, err:%d", getName(), status);

    return status;
}

vx_status
ExynosVisionArray::queryArray(vx_enum attribute, void *ptr, vx_size size)
{
    vx_status status = VX_SUCCESS;

    switch (attribute) {
    case VX_ARRAY_ATTRIBUTE_ITEMTYPE:
        if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
            *(vx_enum *)ptr = m_item_type;
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;
    case VX_ARRAY_ATTRIBUTE_NUMITEMS:
        if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
            *(vx_size *)ptr = m_num_items;
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;
    case VX_ARRAY_ATTRIBUTE_CAPACITY:
        if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
            *(vx_size *)ptr = m_capacity;
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;
    case VX_ARRAY_ATTRIBUTE_ITEMSIZE:
        if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
            *(vx_size *)ptr = m_item_size;
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;
    case VX_ARRAY_ATTRIBUTE_STRIDE:
        if(m_memory.external_stride != 0)
            *(vx_size *)ptr = m_memory.external_stride;
        else
            *(vx_size *)ptr = m_item_size;
        break;
    default:
        status = VX_ERROR_NOT_SUPPORTED;
        break;
    }

    return status;
}

vx_status
ExynosVisionArray::truncateArray(vx_size new_num_items)
{
    vx_status status = VX_ERROR_INVALID_PARAMETERS;

    if (new_num_items <= m_num_items) {
        m_num_items = new_num_items;

        status = VX_SUCCESS;
    }

    return status;
}

vx_bool
ExynosVisionArray::initVirtualArray(vx_enum item_type, vx_size capacity)
{
    vx_bool res = vx_false_e;
    vx_size item_size = vxArrayItemSize(getContext(), item_type);
    if ((item_size != 0) &&
        ((m_capacity > 0 || capacity > 0) && (capacity <= m_capacity || m_capacity == 0))) {
        if ((m_item_type == VX_TYPE_INVALID) || (m_item_type == item_type)) {
            m_item_type = item_type;
            m_item_size = item_size;

            if (m_capacity == 0)
                m_capacity = capacity;

            res = vx_true_e;
        }
    }
    return res;
}

vx_bool
ExynosVisionArray::validateArray(vx_enum item_type, vx_size capacity)
{
    vx_bool res = vx_false_e;
    vx_size item_size = vxArrayItemSize(getContext(), item_type);
    if ((item_size != 0) && (m_item_type == item_type)) {
        /* if the required capacity is > 0 and the objects capacity is not sufficient */
        if ((capacity > 0) && (capacity > m_capacity)) {
            res = vx_false_e;
            VXLOGE("validating error, capacity:%d, m_capacity:%d", capacity, m_capacity);
        } else {
            res = vx_true_e;
        }
    } else {
        VXLOGE("validating error, item_size:%d, m_item_type:0x%x, item_type:0x%x", item_size, m_item_type, item_type);
    }

    return res;
}

vx_status
ExynosVisionArray::verifyMeta(ExynosVisionMeta *meta)
{
    vx_status status = VX_SUCCESS;

    vx_enum item_type;
    vx_size capacity;

    status |= meta->getMetaFormatAttribute(VX_ARRAY_ATTRIBUTE_ITEMTYPE, &item_type, sizeof(item_type));
    status |= meta->getMetaFormatAttribute(VX_ARRAY_ATTRIBUTE_CAPACITY, &capacity, sizeof(capacity));
    if (status != VX_SUCCESS) {
        VXLOGE("get meta fail, err:%d", status);
    }

    if (isVirtual()) {
        if (initVirtualArray(item_type, capacity) != vx_true_e) {
            status = VX_ERROR_INVALID_DIMENSION;
            getContext()->addLogEntry(this, VX_ERROR_INVALID_DIMENSION,
                "meta[%u] has an invalid item type 0x%08x or capacity %d\n", this, item_type, capacity);
            VXLOGE("meta[%u] has an invalid item type 0x%08x or capacity %d", this, item_type, capacity);
        }
    } else {
        if (validateArray(item_type, capacity) != vx_true_e) {
            status = VX_ERROR_INVALID_DIMENSION;
            getContext()->addLogEntry(this, VX_ERROR_INVALID_DIMENSION,
                "invalid item type 0x%08x or capacity %d\n", m_item_type, m_capacity);
            VXLOGE("invalid item type 0x%x or capacity %d", m_item_type, m_capacity);
        }
    }

    return status;
}

vx_status
ExynosVisionArray::addArrayItems(vx_size count, const void *ptr, vx_size stride)
{
    vx_status status = VX_FAILURE;

    if (m_is_allocated != vx_true_e) {
        status =  ((ExynosVisionDataReference*)this)->allocateMemory();
        if (status != VX_SUCCESS) {
            VXLOGE("allocating memory fails at %s, err:%d", getName(), status);
            goto EXIT;
        }
    }

    if ((count > 0) && (ptr != NULL) && (stride == 0 || stride >= m_item_size)) {
        if (m_num_items + count <= m_capacity) {
            vx_size offset = m_num_items * m_item_size;
            vx_uint8 *base_ptr = (vx_uint8 *)m_cur_res->getAddr();
            vx_uint8 *dst_ptr = (vx_uint8*)&base_ptr[offset];

            if (stride == 0 || stride == m_item_size) {
                memcpy(dst_ptr, ptr, count * m_item_size);
            } else {
                vx_size i;
                for (i = 0; i < count; ++i) {
                    vx_uint8 *tmp = (vx_uint8 *)ptr;
                    memcpy(&dst_ptr[i * m_item_size], &tmp[i * stride], m_item_size);
                }
            }

            m_num_items += count;

            status = VX_SUCCESS;
        } else {
            status = VX_FAILURE;
        }
    } else {
        status = VX_ERROR_INVALID_PARAMETERS;
        goto EXIT;
    }

EXIT:
    return status;
}

vx_status
ExynosVisionArray::addEmptyArrayItems(vx_size count)
{
    vx_status status = VX_FAILURE;

    if (m_is_allocated != vx_true_e) {
        status =  ((ExynosVisionDataReference*)this)->allocateMemory();
        if (status != VX_SUCCESS) {
            VXLOGE("allocating memory fails at %s, err:%d", getName(), status);
            goto EXIT;
        }
    }

    if (count > 0) {
        if (m_num_items + count <= m_capacity) {
            m_num_items += count;

            status = VX_SUCCESS;
        } else {
            VXLOGE("adding empty array fails, count:%d, m_num_items:%d, m_capacity:%d", count, m_num_items, m_capacity);
            status = VX_FAILURE;
        }
    } else {
        status = VX_ERROR_INVALID_PARAMETERS;
        goto EXIT;
    }

EXIT:
    return status;
}

vx_status
ExynosVisionArray::accessArrayRange(vx_size start, vx_size end, vx_size *stride, void **ptr, vx_enum usage)
{
    vx_status status = VX_FAILURE;

    /* bad parameters */
    if ((usage < VX_READ_ONLY) || (VX_READ_AND_WRITE < usage) ||
        (ptr == NULL) ||
        (stride == NULL) ||
        (start >= end) || (end > m_num_items)) {
        VXLOGE("invalid param of %s, start:%d, end:%d, num_items:%d, stride:%p, ptr:%p, usage:0x%x", getName(), start, end, m_num_items, stride, ptr, usage);

        return VX_ERROR_INVALID_PARAMETERS;
    }

    /* determine if virtual before checking for memory */
    if (m_is_virtual == vx_true_e) {
        if (m_kernel_count == 0) {
            /* User tried to access a "virtual" array. */
            VXLOGE("Can not access a virtual array");
            return VX_ERROR_OPTIMIZED_AWAY;
        }
        /* framework trying to access a virtual image, this is ok. */
    }

    /* verify has not run or will not run yet. this allows this API to "touch"
     * the array to create it.
     */
    if (m_is_allocated != vx_true_e) {
        status =  ((ExynosVisionDataReference*)this)->allocateMemory();
        if (status != VX_SUCCESS)
            return status;
    }

    m_memory.usage = usage;
    if (usage != VX_READ_ONLY) {
        m_memory_lock.lock();
    }

    /* POSSIBILITIES:
     * 1.) !*ptr && RO == COPY-ON-READ (make ptr=alloc)
     * 2.) !*ptr && WO == MAP
     * 3.) !*ptr && RW == MAP
     * 4.)  *ptr && RO||RW == COPY (UNLESS MAP)
     */

    /* MAP mode */
    if (*ptr == NULL) {
        m_memory.access_mode = ACCESS_MAP_MODE;
        m_memory.external_stride = 0;
        *stride = m_item_size;

        vx_size offset = start * m_item_size;

        vx_uint8 *base_ptr = (vx_uint8 *)m_cur_res->getAddr();
        *ptr = (void*)&base_ptr[offset];

        incrementReference(VX_REF_EXTERNAL);

        status = VX_SUCCESS;
    } else {
        m_memory.access_mode = ACCESS_COPY_MODE;
        m_memory.external_stride = *stride;

        /* COPY mode */
        vx_size size = ((end - start) * m_item_size);

        if (usage != VX_WRITE_ONLY) {
            vx_uint32 i;
            vx_uint8 *pSrc, *pDest;

            vx_uint8 *base_ptr = (vx_uint8 *)m_cur_res->getAddr();
            for (i = start, pDest = (vx_uint8*)*ptr, pSrc = (vx_uint8*)&base_ptr[start * m_item_size];
                i < end;
                i++, pDest += *stride, pSrc += m_item_size) {
                memcpy(pDest, pSrc, m_item_size);
            }
        }

        incrementReference(VX_REF_EXTERNAL);

        status = VX_SUCCESS;
    }

    return status;
}

vx_status
ExynosVisionArray::accessArrayHandle(vx_int32 *fd, vx_enum usage)
{
    vx_status status = VX_FAILURE;

    /* bad parameters */
    if ((usage < VX_READ_ONLY) || (VX_READ_AND_WRITE < usage) ||
        (fd == NULL)) {
        VXLOGE("invalid param of %s, num_items:%d, fd:%p, usage:0x%x", getName(), m_num_items, fd, usage);

        return VX_ERROR_INVALID_PARAMETERS;
    }

    /* determine if virtual before checking for memory */
    if (m_is_virtual == vx_true_e) {
        if (m_kernel_count == 0) {
            /* User tried to access a "virtual" array. */
            VXLOGE("Can not access a virtual array");
            return VX_ERROR_OPTIMIZED_AWAY;
        }
        /* framework trying to access a virtual image, this is ok. */
    }

    /* verify has not run or will not run yet. this allows this API to "touch"
     * the array to create it.
     */
    if (m_is_allocated != vx_true_e) {
        status =  ((ExynosVisionDataReference*)this)->allocateMemory();
        if (status != VX_SUCCESS)
            return status;
    }

    m_memory.usage = usage;
    if (usage != VX_READ_ONLY) {
        m_memory_lock.lock();
    }

    m_memory.access_mode = ACCESS_MAP_MODE;
    m_memory.external_stride = 0;

    *fd = m_cur_res->getFd();

    incrementReference(VX_REF_EXTERNAL);

    status = VX_SUCCESS;

    return status;
}

vx_status
ExynosVisionArray::commitArrayRange(vx_size start, vx_size end, const void *ptr)
{
    VXLOGD2("%s, start%d, end:%d, ptr:%p", getName(), start, end, ptr);

    vx_status status = VX_ERROR_INVALID_REFERENCE;

    vx_bool external = vx_true_e; // assume that it was an allocated buffer

    if ((ptr == NULL) ||
        (start > end) || (end > m_num_items)) {
        return VX_ERROR_INVALID_PARAMETERS;
    }

    /* determine if virtual before checking for memory */
    if (m_is_virtual == vx_true_e) {
        if (m_kernel_count == 0) {
            /* User tried to access a "virtual" array. */
            VXLOGE("Can not access a virtual array");
            return VX_ERROR_OPTIMIZED_AWAY;
        }
        /* framework trying to access a virtual image, this is ok. */
    }

    /* VARIABLES:
     * 1.) ZERO_AREA
     * 2.) CONSTANT - independant
     * 3.) INTERNAL - independant of area
     * 4.) EXTERNAL - dependant on area (do nothing on zero, determine on non-zero)
     * 5.) !INTERNAL && !EXTERNAL == MAPPED
     */

    /* check to see if the range is zero area */
    vx_bool zero_area = (end == 0) ? vx_true_e : vx_false_e;
    vx_uint32 index = UINT32_MAX; // out of bounds, if given to remove, won't do anything

    if (zero_area == vx_false_e) {
        /* this could be a write-back */
        if ((m_memory.usage != VX_READ_ONLY) && (m_memory.access_mode == ACCESS_COPY_MODE)) {
            vx_uint8 *beg_ptr = (vx_uint8 *)m_cur_res->getAddr();
            vx_uint8 *end_ptr = &beg_ptr[m_item_size * m_num_items];

            /* the pointer was not mapped, copy. */
            vx_size offset = start * m_item_size;
            vx_size len = (end - start) * m_item_size;

            if (m_memory.external_stride == 0) {
                VXLOGE("external stride information is empty at copy mode");
                status = VX_FAILURE;
                goto EXIT;
            }

            if (m_memory.external_stride != m_item_size) {
                vx_size stride = m_memory.external_stride;

                vx_uint32 i;
                const vx_uint8 *pSrc; vx_uint8 *pDest;

                for (i = start, pSrc = (vx_uint8*)ptr, pDest= &beg_ptr[offset];
                     i < end;
                     i++, pSrc += stride, pDest += m_item_size) {
                    memcpy(pDest, pSrc, m_item_size);
                }

            } else {
                memcpy(&beg_ptr[offset], ptr, len);
            }
        }

        status = VX_SUCCESS;
    }
    else {
        status = VX_SUCCESS;
    }

    if (m_memory.usage != VX_READ_ONLY)
        m_memory_lock.unlock();

    m_memory.access_mode = ACCESS_NONE;
    decrementReference(VX_REF_EXTERNAL);

EXIT:
    return status;
}

vx_status
ExynosVisionArray::commitArrayHandle(const vx_int32 fd)
{
    vx_status status = VX_ERROR_INVALID_REFERENCE;

    if (fd == 0) {
        return VX_ERROR_INVALID_PARAMETERS;
    }

    /* determine if virtual before checking for memory */
    if (m_is_virtual == vx_true_e) {
        if (m_kernel_count == 0) {
            /* User tried to access a "virtual" array. */
            VXLOGE("Can not access a virtual array");
            return VX_ERROR_OPTIMIZED_AWAY;
        }
        /* framework trying to access a virtual image, this is ok. */
    }

    status = VX_SUCCESS;

    if (m_memory.usage != VX_READ_ONLY)
        m_memory_lock.unlock();

    m_memory.access_mode = ACCESS_NONE;
    decrementReference(VX_REF_EXTERNAL);

    return status;
}

vx_status
ExynosVisionArray::allocateMemory(vx_enum res_type, struct resource_param *param)
{
    return allocateMemory_T(res_type, param, vx_true_e, &m_res_mngr, &m_res_list, &m_cur_res);
}

vx_status
ExynosVisionArray::allocateResource(default_resource_t **ret_resource)
{
    if (ret_resource == NULL) {
        VXLOGE("pointer is null at %s", getName());
        return VX_ERROR_INVALID_PARAMETERS;
    }

    vx_status status = VX_SUCCESS;
    default_resource_t *memory = new default_resource_t();

    vx_size size = m_item_size * m_capacity;
    status = memory->alloc(m_allocator, size);
    if (status != VX_SUCCESS)
        VXLOGE("memory allocation fails at %s", getName());

    *ret_resource = memory;

    return status;
}

vx_status
ExynosVisionArray::freeResource(default_resource_t *memory)
{
    vx_status status = VX_SUCCESS;

    status = memory->free(m_allocator);
    if (status != VX_SUCCESS)
        VXLOGE("memory free fail, err:%d", status);
    delete memory;

    return status;
}

ExynosVisionDataReference*
ExynosVisionArray::getInputShareRef(vx_uint32 frame_cnt, vx_bool *ret_data_valid)
{
    return getInputShareRef_T<default_resource_t>(m_res_mngr, frame_cnt, ret_data_valid);
}

vx_status
ExynosVisionArray::putInputShareRef(vx_uint32 frame_cnt)
{
    return putInputShareRef_T<default_resource_t>(m_res_mngr, frame_cnt);
}

ExynosVisionDataReference*
ExynosVisionArray::getOutputShareRef(vx_uint32 frame_cnt)
{
    return getOutputShareRef_T<default_resource_t>(m_res_mngr, frame_cnt);
}

vx_status
ExynosVisionArray::putOutputShareRef(vx_uint32 frame_cnt, vx_uint32 demand_num, vx_bool data_valid)
{
    return putOutputShareRef_T<default_resource_t>(m_res_mngr, frame_cnt, demand_num, data_valid);
}

void
ExynosVisionArray::displayInfo(vx_uint32 tab_num, vx_bool detail_info)
{
    vx_char tap[MAX_TAB_NUM];

    VXLOGI("%s[Array  ] %s(%p), type:0x%x, size:%d, num:%d, cappa:%d, virtual:%d, refCnt:%d/%d", MAKE_TAB(tap, tab_num), getName(), this,
                                                m_item_type, m_item_size, m_num_items, m_capacity, isVirtual(),
                                                getInternalCnt(), getExternalCnt());
    if (isDelayElement())
        VXLOGI("%s          delay element, %s, delay phy index:%d", MAKE_TAB(tap, tab_num), getDelay()->getName(), getDelaySlotIndex());

    LOG_FLUSH_TIME();

    if (detail_info)
        displayConn(tab_num);
}
#ifdef USE_OPENCL_KERNEL
vx_status
ExynosVisionArray::getClMemoryInfo(cl_context clContext, vxcl_mem_t **memory)
{
    vx_status status = VX_SUCCESS;
    cl_int err = 0;

    if (m_is_allocated != vx_true_e) {
        status =  ((ExynosVisionDataReference*)this)->allocateMemory();
        if (status != VX_SUCCESS) {
            VXLOGE("allocating memory fails at %s, err:%d", getName(), status);
            goto EXIT;
        }
    }

    m_cl_memory.cl_type = CL_MEM_OBJECT_BUFFER;
    m_cl_memory.nptrs = VX_NUM_DEFAULT_PLANES;
    m_cl_memory.ndims = VX_NUM_DEFAULT_DIMS;

    m_cl_memory.ptrs[VX_CL_PLANE_0] = (vx_uint8 *)m_cur_res->getAddr();
    m_cl_memory.sizes[VX_CL_PLANE_0] = (vx_size)(m_item_size * m_capacity);
    m_cl_memory.hdls[VX_CL_PLANE_0] = clCreateBuffer(clContext,
                                        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
                                        m_cl_memory.sizes[VX_CL_PLANE_0],
                                        m_cl_memory.ptrs[VX_CL_PLANE_0],
                                        &err);
    if (err != CL_SUCCESS) {
        VXLOGE("failed in clCreateBuffer : err(%d)", err);
        m_cl_memory.allocated = vx_false_e;
        *memory = NULL;
    } else {
        m_cl_memory.allocated = vx_true_e;
        *memory = &m_cl_memory;
    }

EXIT:
    return status;
}
#endif

}; /* namespace android */