// Copyright (C) 2023 Huawei Device 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.

//! Rust macros defined in crate hisysevent.

/// As macro __FUNC__ defined in C/C++.
///
/// # Example
///
/// ```
/// extern crate hisysevent;
///
/// let func_name = hisysevent::function!();
/// ```
#[macro_export]
macro_rules! function {
    () => {{
        fn hook() {}
        fn type_name_of<T>(_: T) -> &'static str {
            std::any::type_name::<T>()
        }
        let name = type_name_of(hook);
        let off_set: usize = 6; // ::hook
        &name[..name.len() - off_set]
    }};
}

/// Build HiSysEventParamType with different type.
#[macro_export]
macro_rules! build_param_type {
    ($param_type:expr, $param_len:expr) => {
        match $param_type as &str {
            "bool" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::BoolArray
                } else {
                    hisysevent::HiSysEventParamType::Bool
                }
            }
            "i8" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Int8Array
                } else {
                    hisysevent::HiSysEventParamType::Int8
                }
            }
            "u8" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Uint8Array
                } else {
                    hisysevent::HiSysEventParamType::Uint8
                }
            }
            "i16" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Int16Array
                } else {
                    hisysevent::HiSysEventParamType::Int16
                }
            }
            "u16" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Uint16Array
                } else {
                    hisysevent::HiSysEventParamType::Uint16
                }
            }
            "i32" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Int32Array
                } else {
                    hisysevent::HiSysEventParamType::Int32
                }
            }
            "u32" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Uint32Array
                } else {
                    hisysevent::HiSysEventParamType::Uint32
                }
            }
            "i64" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Int64Array
                } else {
                    hisysevent::HiSysEventParamType::Int64
                }
            }
            "u64" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::Uint64Array
                } else {
                    hisysevent::HiSysEventParamType::Uint64
                }
            }
            "f32" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::FloatArray
                } else {
                    hisysevent::HiSysEventParamType::Float
                }
            }
            "f64" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::DoubleArray
                } else {
                    hisysevent::HiSysEventParamType::Double
                }
            }
            "str" => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::ParamTypeStringArray
                } else {
                    hisysevent::HiSysEventParamType::ParamTypeString
                }
            }
            _ => {
                if $param_len > 0 {
                    hisysevent::HiSysEventParamType::BoolArray
                } else {
                    hisysevent::HiSysEventParamType::Bool
                }
            }
        }
    };
}

/// Build array consist of HiSysEventParamValue with different type except
/// string.
#[macro_export]
macro_rules! build_array_params {
    ($param_name_:expr, $param_value_:expr) => {{
        let (param_type, param_len) = hisysevent::parse_type_len($param_value_);
        hisysevent::HiSysEventParam {
            param_name: $param_name_,
            param_type: $crate::build_param_type!(param_type, param_len),
            param_value: hisysevent::HiSysEventParamValue {
                void_ptr_: $param_value_.as_ptr() as *const std::ffi::c_int as *const (),
            },
            array_size: param_len,
        }
    }};
}

/// Build array consist of HiSysEventParamValue with string type.
#[macro_export]
macro_rules! build_string_array_params {
    ($param_name_:expr, $param_value_:expr) => {
        hisysevent::build_string_arrays($param_name_, $param_value_)
    };
}

/// Build HiSysEventParamValue with different type except string and bool.
#[macro_export]
macro_rules! build_param_value {
    ($param_type:expr, $val:expr) => {
        match $param_type as &str {
            "i8" => hisysevent::HiSysEventParamValue { i8_: $val as i8 },
            "u8" => hisysevent::HiSysEventParamValue { u8_: $val as u8 },
            "i16" => hisysevent::HiSysEventParamValue { i16_: $val as i16 },
            "u16" => hisysevent::HiSysEventParamValue { u16_: $val as u16 },
            "i32" => hisysevent::HiSysEventParamValue { i32_: $val as i32 },
            "u32" => hisysevent::HiSysEventParamValue { u32_: $val as u32 },
            "i64" => hisysevent::HiSysEventParamValue { i64_: $val as i64 },
            "u64" => hisysevent::HiSysEventParamValue { u64_: $val as u64 },
            "f32" => hisysevent::HiSysEventParamValue { f32_: $val as f32 },
            "f64" => hisysevent::HiSysEventParamValue { f64_: $val as f64 },
            _ => hisysevent::HiSysEventParamValue { b_: false },
        }
    };
}

/// Build HiSysEventParamValue with any number type.
#[macro_export]
macro_rules! build_number_param {
    ($param_name_:expr, $param_value:expr) => {{
        let (param_type, param_len) = hisysevent::parse_type_len($param_value);
        hisysevent::HiSysEventParam {
            param_name: $param_name_,
            param_type: $crate::build_param_type!(param_type, param_len),
            param_value: $crate::build_param_value!(param_type, $param_value),
            array_size: param_len,
        }
    }};
}

/// Build HiSysEventParamValue with bool type.
#[macro_export]
macro_rules! build_bool_param {
    ($param_name_:expr, $param_value:expr) => {{
        let (param_type, param_len) = hisysevent::parse_type_len($param_value);
        hisysevent::HiSysEventParam {
            param_name: $param_name_,
            param_type: hisysevent::HiSysEventParamType::Bool,
            param_value: hisysevent::HiSysEventParamValue { b_: $param_value },
            array_size: param_len,
        }
    }};
}

/// Build HiSysEventParamValue with string type.
#[macro_export]
macro_rules! build_str_param {
    ($param_name_:expr, $param_value_:expr) => {{
        let (param_type, param_len) = hisysevent::parse_type_len($param_value_);
        hisysevent::HiSysEventParam {
            param_name: $param_name_,
            param_type: hisysevent::HiSysEventParamType::ParamTypeString,
            param_value: {
                let str_wrapper = std::ffi::CString::new($param_value_).unwrap();
                hisysevent::HiSysEventParamValue {
                    char_ptr_: str_wrapper.into_raw() as *const std::ffi::c_char,
                }
            },
            array_size: param_len,
        }
    }};
}