use crate::ffi::{ffi_arc_dyn_getter, BorrowedPtr, ExternPointer, IdentifiablePointer, NativeResult, OwnedPtr};
use crate::static_data::{
    EffectParameter, MoveCategory, MoveData, MoveDataImpl, MoveTarget, SecondaryEffect, SecondaryEffectImpl,
    TypeIdentifier,
};
use crate::StringKey;
use anyhow::anyhow;
use hashbrown::HashSet;
use std::ffi::{c_char, CStr, CString};
use std::ptr::drop_in_place;
use std::sync::Arc;

/// Instantiates a new move.
#[no_mangle]
unsafe extern "C" fn move_data_new(
    name: *const c_char,
    move_type: TypeIdentifier,
    category: MoveCategory,
    base_power: u8,
    accuracy: u8,
    base_usages: u8,
    target: MoveTarget,
    priority: i8,
    secondary_effect: *mut Box<dyn SecondaryEffect>,
    flags: *const *const c_char,
    flags_length: usize,
) -> NativeResult<IdentifiablePointer<Arc<dyn MoveData>>> {
    let flags = std::slice::from_raw_parts(flags, flags_length);
    let name: StringKey = match CStr::from_ptr(name).to_str() {
        Ok(name) => name.into(),
        Err(_) => return NativeResult::err_from_str("Unable to convert name to string"),
    };
    let mut flags_set: HashSet<StringKey> = HashSet::with_capacity(flags_length);
    for flag in flags {
        let flag = match CStr::from_ptr(*flag).to_str() {
            Ok(flag) => flag,
            Err(_) => return NativeResult::err_from_str("Unable to convert flag to string"),
        };
        flags_set.insert(flag.into());
    }
    let secondary_effect = if secondary_effect.is_null() {
        None
    } else {
        Some(*Box::from_raw(secondary_effect))
    };
    let a: Arc<dyn MoveData> = Arc::new(MoveDataImpl::new(
        &name,
        move_type,
        category,
        base_power,
        accuracy,
        base_usages,
        target,
        priority,
        secondary_effect,
        flags_set,
    ));
    NativeResult::ok(a.into())
}

/// Drops a reference counted move.
#[no_mangle]
unsafe extern "C" fn move_data_drop(ptr: OwnedPtr<Arc<dyn MoveData>>) {
    drop_in_place(ptr)
}

/// The name of the move.
#[no_mangle]
unsafe extern "C" fn move_data_name(ptr: ExternPointer<Arc<dyn MoveData>>) -> NativeResult<OwnedPtr<c_char>> {
    let name = ptr.as_ref().name();
    match CString::new(name.str()) {
        Ok(name) => NativeResult::ok(name.into_raw()),
        Err(_) => NativeResult::err_from_str("Unable to convert name to string"),
    }
}

ffi_arc_dyn_getter!(MoveData, move_type, TypeIdentifier);
ffi_arc_dyn_getter!(MoveData, category, MoveCategory);
ffi_arc_dyn_getter!(MoveData, base_power, u8);
ffi_arc_dyn_getter!(MoveData, accuracy, u8);
ffi_arc_dyn_getter!(MoveData, base_usages, u8);
ffi_arc_dyn_getter!(MoveData, target, MoveTarget);
ffi_arc_dyn_getter!(MoveData, priority, i8);

/// The optional secondary effect the move has.
#[no_mangle]
unsafe extern "C" fn move_data_secondary_effect(
    ptr: ExternPointer<Arc<dyn MoveData>>,
) -> IdentifiablePointer<Box<dyn SecondaryEffect>> {
    ptr.as_ref().secondary_effect().into()
}

/// Arbitrary flags that can be applied to the move.
#[no_mangle]
unsafe extern "C" fn move_data_has_flag(ptr: ExternPointer<Arc<dyn MoveData>>, flag: *const c_char) -> u8 {
    let flag = CStr::from_ptr(flag).into();
    u8::from(ptr.as_ref().has_flag(&flag))
}

/// Instantiates a new Secondary Effect.
#[no_mangle]
unsafe extern "C" fn secondary_effect_new(
    chance: f32,
    effect_name: BorrowedPtr<c_char>,
    parameters: *mut OwnedPtr<Arc<EffectParameter>>,
    parameters_length: usize,
) -> IdentifiablePointer<Box<dyn SecondaryEffect>> {
    let parameter_slice = std::slice::from_raw_parts(parameters, parameters_length);
    let mut parameters = Vec::with_capacity(parameters_length);
    for parameter in parameter_slice {
        parameters.push(*Box::from_raw(*parameter))
    }

    let b: Box<dyn SecondaryEffect> = Box::new(SecondaryEffectImpl::new(
        chance,
        CStr::from_ptr(effect_name).into(),
        parameters,
    ));
    b.into()
}

/// Drop a secondary effect.
#[no_mangle]
unsafe extern "C" fn secondary_effect_drop(ptr: OwnedPtr<Box<dyn SecondaryEffect>>) {
    drop_in_place(ptr)
}

/// The chance the effect triggers.
#[no_mangle]
unsafe extern "C" fn secondary_effect_chance(ptr: ExternPointer<Box<dyn SecondaryEffect>>) -> f32 {
    ptr.as_ref().chance()
}

/// The name of the effect.
#[no_mangle]
unsafe extern "C" fn secondary_effect_effect_name(
    ptr: ExternPointer<Box<dyn SecondaryEffect>>,
) -> NativeResult<OwnedPtr<c_char>> {
    match CString::new(ptr.as_ref().effect_name().str()) {
        Ok(name) => NativeResult::ok(name.into_raw()),
        Err(_) => NativeResult::err(anyhow!(
            "Unable to convert effect name '{}' to CString",
            ptr.as_ref().effect_name()
        )),
    }
}

/// The length of parameters of the effect.
#[no_mangle]
unsafe extern "C" fn secondary_effect_parameter_length(ptr: ExternPointer<Box<dyn SecondaryEffect>>) -> usize {
    ptr.as_ref().parameters().len()
}

/// Get a parameter of the effect.
#[no_mangle]
unsafe extern "C" fn secondary_effect_parameter_get(
    ptr: ExternPointer<Box<dyn SecondaryEffect>>,
    index: usize,
) -> IdentifiablePointer<Arc<EffectParameter>> {
    if let Some(v) = ptr.as_ref().parameters().get(index) {
        v.clone().into()
    } else {
        IdentifiablePointer::none()
    }
}