/*
    Copyright (c) 2014-2016 Intel Corporation.  All Rights Reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of Intel Corporation nor the names of its
        contributors may be used to endorse or promote products derived
        from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/


#include <stdio.h>
#include <stdarg.h>
#ifndef va_copy
#define va_copy(dst, src) ((dst) = (src))
#endif

#include "liboffload_msg.h"

#include "liboffload_error_codes.h"

/***********************************************/
/* error-handling function, liboffload_error_support */
/***********************************************/

void __liboffload_error_support(error_types input_tag, ...)
{
    va_list args;
    va_start(args, input_tag);

    switch (input_tag) {
        case c_device_is_not_available:
            write_message(stderr, msg_c_device_is_not_available, args);
            break;
        case c_invalid_device_number:
            write_message(stderr, msg_c_invalid_device_number, args);
            break;
        case c_send_func_ptr:
            write_message(stderr, msg_c_send_func_ptr, args);
            break;
        case c_receive_func_ptr:
            write_message(stderr, msg_c_receive_func_ptr, args);
            break;
        case c_malloc:
            write_message(stderr, msg_c_malloc, args);
            break;
        case c_unknown_mic_device_type:
            write_message(stderr, msg_c_unknown_mic_device_type, args);
            break;
        case c_offload_malloc:
            write_message(stderr, msg_c_offload_malloc, args);
            break;
        case c_offload1:
            write_message(stderr, msg_c_offload1, args);
            break;
        case c_unknown_var_type:
            write_message(stderr, msg_c_unknown_var_type, args);
            break;
        case c_invalid_env_var_value:
            write_message(stderr, msg_c_invalid_env_var_value, args);
            break;
        case c_invalid_env_var_int_value:
            write_message(stderr, msg_c_invalid_env_var_int_value, args);
            break;
        case c_invalid_env_report_value:
            write_message(stderr, msg_c_invalid_env_report_value, args);
            break;
        case c_offload_signaled1:
            write_message(stderr, msg_c_offload_signaled1, args);
            break;
        case c_offload_signaled2:
            write_message(stderr, msg_c_offload_signaled2, args);
            break;
        case c_myowrapper_checkresult:
            write_message(stderr, msg_c_myowrapper_checkresult, args);
            break;
        case c_myotarget_checkresult:
            write_message(stderr, msg_c_myotarget_checkresult, args);
            break;
        case c_offload_descriptor_offload:
            write_message(stderr, msg_c_offload_descriptor_offload, args);
            break;
        case c_merge_var_descs1:
            write_message(stderr, msg_c_merge_var_descs1, args);
            break;
        case c_merge_var_descs2:
            write_message(stderr, msg_c_merge_var_descs2, args);
            break;
        case c_mic_parse_env_var_list1:
            write_message(stderr, msg_c_mic_parse_env_var_list1, args);
            break;
        case c_mic_parse_env_var_list2:
            write_message(stderr, msg_c_mic_parse_env_var_list2, args);
            break;
        case c_mic_process_exit_ret:
            write_message(stderr, msg_c_mic_process_exit_ret, args);
            break;
        case c_mic_process_exit_sig:
            write_message(stderr, msg_c_mic_process_exit_sig, args);
            break;
        case c_mic_process_exit:
            write_message(stderr, msg_c_mic_process_exit, args);
            break;
        case c_mic_init3:
            write_message(stderr, msg_c_mic_init3, args);
            break;
        case c_mic_init4:
            write_message(stderr, msg_c_mic_init4, args);
            break;
        case c_mic_init5:
            write_message(stderr, msg_c_mic_init5, args);
            break;
        case c_mic_init6:
            write_message(stderr, msg_c_mic_init6, args);
            break;
        case c_mic_init7:
            write_message(stderr, msg_c_mic_init7, args);
            break;
        case c_mic_init8:
            write_message(stderr, msg_c_mic_init8, args);
            break;
        case c_mic_init9:
            write_message(stderr, msg_c_mic_init9, args);
            break;
        case c_mic_init10:
            write_message(stderr, msg_c_mic_init10, args);
            break;
        case c_mic_init11:
            write_message(stderr, msg_c_mic_init11, args);
            break;
        case c_no_static_var_data:
            write_message(stderr, msg_c_no_static_var_data, args);
            break;
        case c_no_ptr_data:
            write_message(stderr, msg_c_no_ptr_data, args);
            break;
        case c_get_engine_handle:
            write_message(stderr, msg_c_get_engine_handle, args);
            break;
        case c_get_engine_index:
            write_message(stderr, msg_c_get_engine_index, args);
            break;
        case c_process_create:
            write_message(stderr, msg_c_process_create, args);
            break;
        case c_process_set_cache_size:
            write_message(stderr, msg_c_process_set_cache_size, args);
            break;
        case c_process_wait_shutdown:
            write_message(stderr, msg_c_process_wait_shutdown, args);
            break;
        case c_process_proxy_flush:
            write_message(stderr, msg_c_process_proxy_flush, args);
            break;
        case c_process_get_func_handles:
            write_message(stderr, msg_c_process_get_func_handles, args);
            break;
        case c_load_library:
            write_message(stderr, msg_c_load_library, args);
            break;
        case c_coipipe_max_number:
            write_message(stderr, msg_c_coi_pipeline_max_number, args);
            break;
        case c_pipeline_create:
            write_message(stderr, msg_c_pipeline_create, args);
            break;
        case c_pipeline_run_func:
            write_message(stderr, msg_c_pipeline_run_func, args);
            break;
        case c_pipeline_start_run_funcs:
            write_message(stderr, msg_c_pipeline_start_run_funcs, args);
            break;
        case c_buf_create:
            write_message(stderr, msg_c_buf_create, args);
            break;
        case c_buf_create_out_of_mem:
            write_message(stderr, msg_c_buf_create_out_of_mem, args);
            break;
        case c_buf_create_from_mem:
            write_message(stderr, msg_c_buf_create_from_mem, args);
            break;
        case c_buf_destroy:
            write_message(stderr, msg_c_buf_destroy, args);
            break;
        case c_buf_map:
            write_message(stderr, msg_c_buf_map, args);
            break;
        case c_buf_unmap:
            write_message(stderr, msg_c_buf_unmap, args);
            break;
        case c_buf_read:
            write_message(stderr, msg_c_buf_read, args);
            break;
        case c_buf_write:
            write_message(stderr, msg_c_buf_write, args);
            break;
        case c_buf_copy:
            write_message(stderr, msg_c_buf_copy, args);
            break;
        case c_buf_get_address:
            write_message(stderr, msg_c_buf_get_address, args);
            break;
        case c_buf_add_ref:
            write_message(stderr, msg_c_buf_add_ref, args);
            break;
        case c_buf_release_ref:
            write_message(stderr, msg_c_buf_release_ref, args);
            break;
        case c_buf_set_state:
            write_message(stderr, msg_c_buf_set_state, args);
            break;
        case c_event_wait:
            write_message(stderr, msg_c_event_wait, args);
            break;
        case c_zero_or_neg_ptr_len:
            write_message(stderr, msg_c_zero_or_neg_ptr_len, args);
            break;
        case c_zero_or_neg_transfer_size:
            write_message(stderr, msg_c_zero_or_neg_transfer_size, args);
            break;
        case c_bad_ptr_mem_alloc:
            write_message(stderr, msg_c_bad_ptr_mem_alloc, args);
            break;
        case c_bad_ptr_mem_range:
            write_message(stderr, msg_c_bad_ptr_mem_range, args);
            break;
        case c_different_src_and_dstn_sizes:
            write_message(stderr, msg_c_different_src_and_dstn_sizes, args);
            break;
        case c_ranges_dont_match:
            write_message(stderr, msg_c_ranges_dont_match, args);
            break;
        case c_destination_is_over:
            write_message(stderr, msg_c_destination_is_over, args);
            break;
        case c_slice_of_noncont_array:
            write_message(stderr, msg_c_slice_of_noncont_array, args);
            break;
        case c_non_contiguous_dope_vector:
            write_message(stderr, msg_c_non_contiguous_dope_vector, args);
            break;
        case c_pointer_array_mismatch:
            write_message(stderr, msg_c_pointer_array_mismatch, args);
            break;
        case c_omp_invalid_device_num_env:
            write_message(stderr, msg_c_omp_invalid_device_num_env, args);
            break;
        case c_omp_invalid_device_num:
            write_message(stderr, msg_c_omp_invalid_device_num, args);
            break;
        case c_unknown_binary_type:
            write_message(stderr, msg_c_unknown_binary_type, args);
            break;
        case c_multiple_target_exes:
            write_message(stderr, msg_c_multiple_target_exes, args);
            break;
        case c_no_target_exe:
            write_message(stderr, msg_c_no_target_exe, args);
            break;
        case c_report_unknown_timer_node:
            write_message(stderr, msg_c_report_unknown_timer_node, args);
            break;
        case c_report_unknown_trace_node:
            write_message(stderr, msg_c_report_unknown_trace_node, args);
            break;
        case c_incorrect_affinity:
            write_message(stderr, msg_c_incorrect_affinity, args);
            break;
        case c_cannot_set_affinity:
            write_message(stderr, msg_c_cannot_set_affinity, args);
            break;
        case c_mixed_versions:
            write_message(stderr, msg_c_mixed_versions, args);
            break;
        case c_in_with_preallocated:
            write_message(stderr, msg_c_in_with_preallocated, args);
            break;
        case c_report_no_host_exe:
            write_message(stderr, msg_c_report_no_host_exe, args);
            break;
        case c_report_no_target_exe:
            write_message(stderr, msg_c_report_no_target_exe, args);
            break;
        case c_report_path_buff_overflow:
            write_message(stderr, msg_c_report_path_buff_overflow, args);
            break;
        case c_create_pipeline_for_stream:
            write_message(stderr, msg_c_create_pipeline_for_stream, args);
            break;
        case c_offload_streams_are_absent:
            write_message(stderr, msg_c_offload_streams_are_absent, args);
            break;
        case c_offload_no_stream:
            write_message(stderr, msg_c_offload_no_stream, args);
            break;
         case c_offload_device_doesnt_match_to_stream:
            write_message(stderr,
                          msg_c_offload_device_doesnt_match_to_stream, args);
            break;
        case c_get_engine_info:
            write_message(stderr, msg_c_get_engine_info, args);
            break;
        case c_clear_cpu_mask:
            write_message(stderr, msg_c_clear_cpu_mask, args);
            break;
        case c_set_cpu_mask:
            write_message(stderr, msg_c_set_cpu_mask, args);
            break;
        case c_unload_library:
            write_message(stderr, msg_c_unload_library, args);
            break;
        case c_target_myo_library:
            write_message(stderr, msg_c_target_myo_library, args);
            break;
        case c_myo_dl_sym:
            write_message(stderr, msg_c_myo_dl_sym, args);
            break;
        case c_bad_myo_free:
            write_message(stderr, msg_c_bad_myo_free, args);
            break;
    }
    va_end(args);
}

char const * report_get_message_str(error_types input_tag)
{
    switch (input_tag) {
        case c_report_title:
            return (offload_get_message_str(msg_c_report_title));
        case c_report_from_file:
            return (offload_get_message_str(msg_c_report_from_file));
        case c_report_offload:
            return (offload_get_message_str(msg_c_report_offload));
        case c_report_mic:
            return (offload_get_message_str(msg_c_report_mic));
        case c_report_file:
            return (offload_get_message_str(msg_c_report_file));
        case c_report_line:
            return (offload_get_message_str(msg_c_report_line));
        case c_report_host:
            return (offload_get_message_str(msg_c_report_host));
        case c_report_tag:
            return (offload_get_message_str(msg_c_report_tag));
        case c_report_cpu_time:
            return (offload_get_message_str(msg_c_report_cpu_time));
        case c_report_seconds:
            return (offload_get_message_str(msg_c_report_seconds));
        case c_report_cpu_to_mic_data:
            return (offload_get_message_str(msg_c_report_cpu_to_mic_data));
        case c_report_bytes:
            return (offload_get_message_str(msg_c_report_bytes));
        case c_report_mic_time:
            return (offload_get_message_str(msg_c_report_mic_time));
        case c_report_mic_to_cpu_data:
            return (offload_get_message_str(msg_c_report_mic_to_cpu_data));
        case c_report_compute:
            return (offload_get_message_str(msg_c_report_compute));
        case c_report_copyin_data:
            return (offload_get_message_str(msg_c_report_copyin_data));
        case c_report_copyout_data:
            return (offload_get_message_str(msg_c_report_copyout_data));
        case c_report_create_buf_host:
            return (offload_get_message_str(c_report_create_buf_host));
        case c_report_create_buf_mic:
            return (offload_get_message_str(msg_c_report_create_buf_mic));
        case c_report_destroy:
            return (offload_get_message_str(msg_c_report_destroy));
        case c_report_gather_copyin_data:
            return (offload_get_message_str(msg_c_report_gather_copyin_data));
        case c_report_gather_copyout_data:
            return (offload_get_message_str(msg_c_report_gather_copyout_data));
        case c_report_state_signal:
            return (offload_get_message_str(msg_c_report_state_signal));
        case c_report_signal:
            return (offload_get_message_str(msg_c_report_signal));
        case c_report_wait:
            return (offload_get_message_str(msg_c_report_wait));
        case c_report_init:
            return (offload_get_message_str(msg_c_report_init));
        case c_report_init_func:
            return (offload_get_message_str(msg_c_report_init_func));
        case c_report_logical_card:
            return (offload_get_message_str(msg_c_report_logical_card));
        case c_report_mic_myo_fptr:
            return (offload_get_message_str(msg_c_report_mic_myo_fptr));
        case c_report_mic_myo_shared:
            return (offload_get_message_str(msg_c_report_mic_myo_shared));
        case c_report_myoacquire:
            return (offload_get_message_str(msg_c_report_myoacquire));
        case c_report_myofini:
            return (offload_get_message_str(msg_c_report_myofini));
        case c_report_myoinit:
            return (offload_get_message_str(msg_c_report_myoinit));
        case c_report_myoregister:
            return (offload_get_message_str(msg_c_report_myoregister));
        case c_report_myorelease:
            return (offload_get_message_str(msg_c_report_myorelease));
        case c_report_myosharedalignedfree:
            return (
                offload_get_message_str(msg_c_report_myosharedalignedfree));
        case c_report_myosharedalignedmalloc:
            return (
                offload_get_message_str(msg_c_report_myosharedalignedmalloc));
        case c_report_myosharedfree:
            return (offload_get_message_str(msg_c_report_myosharedfree));
        case c_report_myosharedmalloc:
            return (offload_get_message_str(msg_c_report_myosharedmalloc));
        case c_report_physical_card:
            return (offload_get_message_str(msg_c_report_physical_card));
        case c_report_receive_pointer_data:
            return (
                offload_get_message_str(msg_c_report_receive_pointer_data));
        case c_report_received_pointer_data:
            return (
                offload_get_message_str(msg_c_report_received_pointer_data));
        case c_report_register:
            return (offload_get_message_str(msg_c_report_register));
        case c_report_scatter_copyin_data:
            return (offload_get_message_str(msg_c_report_scatter_copyin_data));
        case c_report_scatter_copyout_data:
            return (
                offload_get_message_str(msg_c_report_scatter_copyout_data));
        case c_report_send_pointer_data:
            return (offload_get_message_str(msg_c_report_send_pointer_data));
        case c_report_sent_pointer_data:
            return (offload_get_message_str(msg_c_report_sent_pointer_data));
        case c_report_start:
            return (offload_get_message_str(msg_c_report_start));
        case c_report_start_target_func:
            return (offload_get_message_str(msg_c_report_start_target_func));
        case c_report_state:
            return (offload_get_message_str(msg_c_report_state));
        case c_report_unregister:
            return (offload_get_message_str(msg_c_report_unregister));
        case c_report_var:
            return (offload_get_message_str(msg_c_report_var));
        case c_report_stream:
            return (offload_get_message_str(msg_c_report_stream));
        case c_report_state_stream:
            return (offload_get_message_str(msg_c_report_state_stream));

        default:
            LIBOFFLOAD_ERROR(c_report_unknown_trace_node);
            abort();
    }
    return 0;
}

char const * report_get_host_stage_str(int i)
{
    switch (i) {
        case c_offload_host_total_offload:
            return (
               offload_get_message_str(msg_c_report_host_total_offload_time));
        case c_offload_host_initialize:
            return (offload_get_message_str(msg_c_report_host_initialize));
        case c_offload_host_target_acquire:
            return (
                offload_get_message_str(msg_c_report_host_target_acquire));
        case c_offload_host_wait_deps:
            return (offload_get_message_str(msg_c_report_host_wait_deps));
        case c_offload_host_setup_buffers:
            return (offload_get_message_str(msg_c_report_host_setup_buffers));
        case c_offload_host_alloc_buffers:
            return (offload_get_message_str(msg_c_report_host_alloc_buffers));
        case c_offload_host_setup_misc_data:
            return (
                offload_get_message_str(msg_c_report_host_setup_misc_data));
        case c_offload_host_alloc_data_buffer:
            return (
                offload_get_message_str(msg_c_report_host_alloc_data_buffer));
        case c_offload_host_send_pointers:
            return (offload_get_message_str(msg_c_report_host_send_pointers));
        case c_offload_host_gather_inputs:
            return (offload_get_message_str(msg_c_report_host_gather_inputs));
        case c_offload_host_map_in_data_buffer:
            return (
                offload_get_message_str(msg_c_report_host_map_in_data_buffer));
        case c_offload_host_unmap_in_data_buffer:
            return (offload_get_message_str(
                msg_c_report_host_unmap_in_data_buffer));
        case c_offload_host_start_compute:
            return (offload_get_message_str(msg_c_report_host_start_compute));
        case c_offload_host_wait_compute:
            return (offload_get_message_str(msg_c_report_host_wait_compute));
        case c_offload_host_start_buffers_reads:
            return (offload_get_message_str(
                msg_c_report_host_start_buffers_reads));
        case c_offload_host_scatter_outputs:
            return (
                offload_get_message_str(msg_c_report_host_scatter_outputs));
        case c_offload_host_map_out_data_buffer:
            return (offload_get_message_str(
                msg_c_report_host_map_out_data_buffer));
        case c_offload_host_unmap_out_data_buffer:
            return (offload_get_message_str(
                msg_c_report_host_unmap_out_data_buffer));
        case c_offload_host_wait_buffers_reads:
            return (
                offload_get_message_str(msg_c_report_host_wait_buffers_reads));
        case c_offload_host_destroy_buffers:
            return (
                offload_get_message_str(msg_c_report_host_destroy_buffers));
        default:
            LIBOFFLOAD_ERROR(c_report_unknown_timer_node);
            abort();
    }
    return 0;
}

char const * report_get_target_stage_str(int i)
{
    switch (i) {
        case c_offload_target_total_time:
            return (offload_get_message_str(msg_c_report_target_total_time));
        case c_offload_target_descriptor_setup:
            return (
                offload_get_message_str(msg_c_report_target_descriptor_setup));
        case c_offload_target_func_lookup:
            return (offload_get_message_str(msg_c_report_target_func_lookup));
        case c_offload_target_func_time:
            return (offload_get_message_str(msg_c_report_target_func_time));
        case c_offload_target_scatter_inputs:
            return (
                offload_get_message_str(msg_c_report_target_scatter_inputs));
        case c_offload_target_add_buffer_refs:
            return (
                offload_get_message_str(msg_c_report_target_add_buffer_refs));
        case c_offload_target_compute:
            return (offload_get_message_str(msg_c_report_target_compute));
        case c_offload_target_gather_outputs:
            return (offload_get_message_str
                (msg_c_report_target_gather_outputs));
        case c_offload_target_release_buffer_refs:
            return (offload_get_message_str(
                msg_c_report_target_release_buffer_refs));
        default:
            LIBOFFLOAD_ERROR(c_report_unknown_timer_node);
            abort();
    }
    return 0;
}
