/*
 * 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 "ExynosVisionKernel"
#include <cutils/log.h>

#include "ExynosVisionKernel.h"

#include "ExynosVisionNode.h"

namespace android {

using namespace std;

ExynosVisionKernel::ExynosVisionKernel(ExynosVisionContext *context)
                                                                    : ExynosVisionReference(context, VX_TYPE_KERNEL, (ExynosVisionReference*)context, vx_true_e)
{
    memset(m_kernel_name, 0x0, sizeof(m_kernel_name));
    m_enumeration = 0;
    m_function = 0;
    memset(&m_signature, 0x0, sizeof(m_signature));

    m_enabled = vx_false_e;

    m_validate_input = 0;
    m_validate_output = 0;
    m_initialize = 0;
    m_deinitialize = 0;
    memset(&m_attributes, 0x0, sizeof(m_attributes));
}

ExynosVisionKernel::~ExynosVisionKernel()
{

}

vx_status
ExynosVisionKernel::destroy(void)
{
    return VX_SUCCESS;
}

vx_status
ExynosVisionKernel::assignFunc(const vx_char name[VX_MAX_KERNEL_NAME],
                                     vx_enum enumeration,
                                     vx_kernel_f func_ptr,
                                     vx_uint32 numParams,
                                     vx_kernel_input_validate_f input,
                                     vx_kernel_output_validate_f output,
                                     vx_kernel_initialize_f init,
                                     vx_kernel_deinitialize_f deinit)
{
    strncpy(m_kernel_name, name, VX_MAX_KERNEL_NAME);
    m_enumeration = enumeration;
    m_function = func_ptr;
    m_signature.num_parameters = numParams;
    m_validate_input = input;
    m_validate_output = output;
    m_initialize = init;
    m_deinitialize = deinit;
    m_attributes.borders.mode = VX_BORDER_MODE_UNDEFINED;
    m_attributes.borders.constant_value = 0;

    return VX_SUCCESS;
}

vx_status
ExynosVisionKernel::setKernelAttribute(vx_enum attribute, const void *ptr, vx_size size)
{
    vx_status status = VX_SUCCESS;

    if (m_enabled == vx_true_e)
        return VX_ERROR_NOT_SUPPORTED;

    switch (attribute) {
    case VX_KERNEL_ATTRIBUTE_LOCAL_DATA_SIZE:
        if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3)) {
            m_attributes.localDataSize = *(vx_size *)ptr;
            VXLOGD("Set Local Data Size to %d bytes", m_attributes.localDataSize);
        } else  {
            status = VX_ERROR_INVALID_PARAMETERS;
        }
        break;
    case VX_KERNEL_ATTRIBUTE_LOCAL_DATA_PTR:
        if (VX_CHECK_PARAM(ptr, size, vx_ptr_t, 0x1))
            m_attributes.localDataPtr = *(vx_ptr_t *)ptr;
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;

    default:
        status = VX_ERROR_NOT_SUPPORTED;
        break;
    }

    return status;
}

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

    switch (attribute) {
    case VX_KERNEL_ATTRIBUTE_PARAMETERS:
        if (VX_CHECK_PARAM(ptr, size, vx_uint32, 0x3))
            *(vx_uint32 *)ptr = getNumParams();
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;
    case VX_KERNEL_ATTRIBUTE_NAME:
        if (ptr != NULL && size == VX_MAX_KERNEL_NAME) {
            vx_char kname[VX_MAX_KERNEL_NAME];
            vx_char *k;
            strncpy(kname, m_kernel_name, VX_MAX_KERNEL_NAME);
            k = strtok(kname, ":");
            strncpy((char*)ptr, k, VX_MAX_KERNEL_NAME);
        } else {
            status = VX_ERROR_INVALID_PARAMETERS;
        }
        break;
    case VX_KERNEL_ATTRIBUTE_ENUM:
        if (VX_CHECK_PARAM(ptr, size, vx_enum, 0x3))
            *(vx_enum *)ptr = m_enumeration;
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;
    case VX_KERNEL_ATTRIBUTE_LOCAL_DATA_SIZE:
        if (VX_CHECK_PARAM(ptr, size, vx_size, 0x3))
            *(vx_size *)ptr = m_attributes.localDataSize;
        else
            status = VX_ERROR_INVALID_PARAMETERS;
        break;
    default:
        status = VX_ERROR_NOT_SUPPORTED;
        break;
    }

    return status;
}

vx_status
ExynosVisionKernel::addParameterToKernel(vx_uint32 index, vx_enum dir, vx_enum data_type, vx_enum state)
{
    EXYNOS_VISION_SYSTEM_IN();

    vx_status status = VX_ERROR_INVALID_PARAMETERS;

    VXLOGD2("INFO: %s, Adding index %u, data_type 0x%X, dir:%d state:0x%X\n", getKernelName(), index, data_type, dir, state);

    if (index < m_signature.num_parameters) {
        if ((vxIsValidType(data_type) == vx_false_e) ||
            (vxIsValidDirection(dir) == vx_false_e) ||
            (vxIsValidState(state) == vx_false_e)) {
            status = VX_ERROR_INVALID_PARAMETERS;
            VXLOGE("%s, Invalid parameter, type:%p, direction:%p, state:%p", getKernelName(), data_type, dir, state);
        } else {
            m_signature.directions[index] = dir;
            m_signature.types[index] = data_type;
            m_signature.states[index] = state;
            status = VX_SUCCESS;
        }
    }
    else
    {
        status = VX_ERROR_INVALID_PARAMETERS;
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return status;
}

ExynosVisionParameter*
ExynosVisionKernel::getKernelParameterByIndex(vx_uint32 index)
{
    EXYNOS_VISION_SYSTEM_IN();
    ExynosVisionParameter *param = NULL;

    if (index < VX_INT_MAX_PARAMS && index < getNumParams()) {
        param = new ExynosVisionParameter(getContext(), getContext());
        param->init(index, NULL, this);
    } else {
        getContext()->addLogEntry(this, VX_ERROR_INVALID_PARAMETERS, "Index %u out of range for kernel %s (numparams = %u)!\n",
                index, m_kernel_name, getNumParams());
        VXLOGE("index:%d is out of bound at %s", getName());
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return param;
}

vx_status
ExynosVisionKernel::finalizeKernel(void)
{
    EXYNOS_VISION_SYSTEM_IN();

    vx_status status = VX_SUCCESS;

    vx_uint32 p = 0;
    for (p = 0; p < VX_INT_MAX_PARAMS; p++)
    {
        if (p >= m_signature.num_parameters)
        {
            break;
        }
        if ((m_signature.directions[p] < VX_INPUT) ||
            (m_signature.directions[p] > VX_BIDIRECTIONAL))
        {
            status = VX_ERROR_INVALID_PARAMETERS;
            VXLOGE("invalid parameter");
            break;
        }
        if (vxIsValidType(m_signature.types[p]) == vx_false_e)
        {
            status = VX_ERROR_INVALID_PARAMETERS;
            VXLOGE("invalid type");
            break;
        }
    }

    if (p == m_signature.num_parameters)
    {
        m_enabled = vx_true_e;
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return status;
}

vx_status
ExynosVisionKernel::validateInput(ExynosVisionNode *node, vx_uint32 index)
{
    EXYNOS_VISION_SYSTEM_IN();
    vx_status status;

    status = m_validate_input((vx_node)node, index);
    if (status != VX_SUCCESS) {
        VXLOGE("input validation fail at kernel(%s) from index_%d of %s, err:%d", m_kernel_name, index, node->getName(), status);
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return status;
}

vx_status
ExynosVisionKernel::validateOutput(ExynosVisionNode *node, vx_uint32 index, ExynosVisionMeta *meta)
{
    EXYNOS_VISION_SYSTEM_IN();
    vx_status status;
    status = m_validate_output((vx_node)node, index, (vx_meta_format)meta);
    if (status != VX_SUCCESS) {
        VXLOGE("output validation fail at kernel(%s) from index_%d of %s, err:%d", m_kernel_name, index, node->getName(), status);
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return status;
}

vx_status
ExynosVisionKernel::initialize(ExynosVisionNode *node, const ExynosVisionDataReference **parameters, vx_uint32 num)
{
    EXYNOS_VISION_SYSTEM_IN();
    vx_status status;

    if (m_initialize) {
        status = m_initialize((vx_node)node, (vx_reference*)parameters, num);
        if (status != VX_SUCCESS) {
            VXLOGE("initialization fail at kernel(%s) from %s, err:%d", m_kernel_name, node->getName(), status);
        }
    } else {
        status = VX_SUCCESS;
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return status;
}

vx_status
ExynosVisionKernel::deinitialize(ExynosVisionNode *node, const ExynosVisionDataReference **parameters, vx_uint32 num)
{
    EXYNOS_VISION_SYSTEM_IN();
    vx_status status;

    if (m_deinitialize) {
        status = m_deinitialize((vx_node)node, (vx_reference*)parameters, num);
        if (status != VX_SUCCESS) {
            VXLOGE("deinitialization fail at kernel(%s) from %s, err:%d", m_kernel_name, node->getName(), status);
        }
    } else {
        status = VX_SUCCESS;
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return status;
}

vx_status
ExynosVisionKernel::kernelFunction(ExynosVisionNode *node, const ExynosVisionDataReference **parameters, vx_uint32 num) const
{
    EXYNOS_VISION_SYSTEM_IN();
    vx_status status;

    if (m_function) {
        status = m_function((vx_node)node, (vx_reference*)parameters, num);
        if (status != VX_SUCCESS) {
            VXLOGE("main function fail at kernel(%s) from %s, err:%d", m_kernel_name, node->getName(), status);
        }
    } else {
        VXLOGE("kernel function is not implemented");
        status = VX_ERROR_NOT_IMPLEMENTED;
    }

    EXYNOS_VISION_SYSTEM_OUT();

    return status;
}

void
ExynosVisionKernel::fiiledAttr(vx_kernel_attr_t *attributes)
{
    Mutex::Autolock lock(m_internal_lock);
    memcpy(attributes, &m_attributes, sizeof(vx_kernel_attr_t));
}

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

    VXLOGI("%s[Kernel ][%d] %s, name:%s, enum:0x%X, refCnt:%d/%d", MAKE_TAB(tap, tab_num), detail_info, getName(), m_kernel_name, m_enumeration, getInternalCnt(), getExternalCnt());
}

}; /* namespace android */