use crate::PhpMixed;
use crate::php_to_string;
use indexmap::IndexMap;

pub fn array_values<V: Clone>(_array: &IndexMap<String, V>) -> Vec<V> {
    _array.values().cloned().collect()
}

pub fn array_keys<V>(_array: &IndexMap<String, V>) -> Vec<String> {
    _array.keys().cloned().collect()
}

pub fn array_push(_array: &mut Vec<String>, _value: String) -> i64 {
    _array.push(_value);
    _array.len() as i64
}

pub fn array_search_in_vec(_needle: &str, _haystack: &[String]) -> Option<usize> {
    _haystack.iter().position(|s| s.as_str() == _needle)
}

pub fn array_map_str_fn<F: Fn(&str) -> String>(_callback: F, _array: &[String]) -> Vec<String> {
    _array.iter().map(|s| _callback(s)).collect()
}

pub fn array_slice_mixed(value: &PhpMixed, offset: i64, length: Option<i64>) -> PhpMixed {
    match value {
        PhpMixed::List(items) => {
            let (start, end) = php_slice_bounds(items.len() as i64, offset, length);
            PhpMixed::List(items[start..end].to_vec())
        }
        PhpMixed::Array(map) => {
            let (start, end) = php_slice_bounds(map.len() as i64, offset, length);
            PhpMixed::Array(
                map.iter()
                    .skip(start)
                    .take(end - start)
                    .map(|(k, v)| (k.clone(), v.clone()))
                    .collect(),
            )
        }
        _ => panic!("array_slice(): Argument #1 ($array) must be of type array"),
    }
}

pub fn array_slice_strs(value: &[String], offset: i64, length: Option<i64>) -> Vec<String> {
    let (start, end) = php_slice_bounds(value.len() as i64, offset, length);
    value[start..end].to_vec()
}

pub fn array_fill_keys(keys: PhpMixed, value: PhpMixed) -> PhpMixed {
    let entries: Vec<&PhpMixed> = match &keys {
        PhpMixed::List(items) => items.iter().collect(),
        PhpMixed::Array(map) => map.values().collect(),
        _ => panic!("array_fill_keys(): Argument #1 ($keys) must be of type array"),
    };
    let mut result: IndexMap<String, PhpMixed> = IndexMap::new();
    for key in entries {
        result.insert(php_to_string(key), value.clone());
    }
    PhpMixed::Array(result)
}

/// PHP `array_merge`.
///
/// Must reproduce PHP's mixed integer/string key semantics:
/// - string keys: a later array's value overwrites an earlier one, keeping the
///   earlier key's position;
/// - integer-like keys ("0","1",...): values are appended and renumbered
///   sequentially across all inputs (they are NOT overwritten by key).
///
/// A naive per-entry `IndexMap::insert` is INCORRECT for inputs that mix string
/// and integer keys (e.g. an AliasPackage's provides/replaces, where
/// self.version expansion appends links under "0","1",... keys). See the typed
/// [`array_merge_map`] variant used by such call sites.
pub fn array_merge(array1: PhpMixed, array2: PhpMixed) -> PhpMixed {
    let mut result: IndexMap<String, PhpMixed> = IndexMap::new();
    let mut next_int: i64 = 0;
    for array in [array1, array2] {
        match array {
            PhpMixed::List(items) => {
                for value in items {
                    result.insert(next_int.to_string(), value);
                    next_int += 1;
                }
            }
            PhpMixed::Array(map) => {
                for (key, value) in map {
                    if let Ok(n) = key.parse::<i64>() {
                        if n.to_string() == key {
                            result.insert(next_int.to_string(), value);
                            next_int += 1;
                            continue;
                        }
                    }
                    result.insert(key, value);
                }
            }
            _ => panic!("array_merge(): Argument must be of type array"),
        }
    }
    let is_list = result.keys().enumerate().all(|(i, k)| *k == i.to_string());
    if is_list {
        PhpMixed::List(result.into_values().collect())
    } else {
        PhpMixed::Array(result)
    }
}

/// PHP `array_merge` for a string-keyed map that MAY also contain integer-like
/// keys. Typed counterpart of [`array_merge`] for `IndexMap<String, V>` values
/// (e.g. `Link` maps from `getProvides`/`getReplaces`).
///
/// Must reproduce the same mixed-key semantics as [`array_merge`]: string keys
/// overwrite in place (later wins), integer-like keys ("0","1",...) are appended
/// and renumbered sequentially across both inputs. A naive `IndexMap::insert`
/// per entry is INCORRECT because it would collide on shared integer keys.
pub fn array_merge_map<V>(
    array1: IndexMap<String, V>,
    array2: IndexMap<String, V>,
) -> IndexMap<String, V> {
    let mut result: IndexMap<String, V> = IndexMap::new();
    let mut next_int: i64 = 0;
    for array in [array1, array2] {
        for (key, value) in array {
            if let Ok(n) = key.parse::<i64>() {
                if n.to_string() == key {
                    result.insert(next_int.to_string(), value);
                    next_int += 1;
                    continue;
                }
            }
            result.insert(key, value);
        }
    }
    result
}

pub fn array_diff(_array1: &[String], _array2: &[String]) -> Vec<String> {
    _array1
        .iter()
        .filter(|&x| !_array2.contains(x))
        .cloned()
        .collect()
}

pub fn array_unique<T: Clone>(_array: &[T]) -> Vec<T> {
    todo!()
}

pub fn array_intersect_key(
    _array1: &IndexMap<String, PhpMixed>,
    _array2: &IndexMap<String, PhpMixed>,
) -> IndexMap<String, PhpMixed> {
    _array1
        .iter()
        .filter(|(k, _)| _array2.contains_key(k.as_str()))
        .map(|(k, v)| (k.clone(), v.clone()))
        .collect()
}

pub fn array_replace_recursive(
    mut base: IndexMap<String, PhpMixed>,
    replacement: IndexMap<String, PhpMixed>,
) -> IndexMap<String, PhpMixed> {
    for (key, replacement_value) in replacement {
        let merged = match base.get(&key) {
            Some(base_value) => {
                array_replace_recursive_value(base_value.clone(), replacement_value)
            }
            None => replacement_value,
        };
        base.insert(key, merged);
    }
    base
}

// PHP recurses only when both the existing and the replacing value are arrays;
// otherwise the replacing value wins outright.
fn array_replace_recursive_value(base: PhpMixed, replacement: PhpMixed) -> PhpMixed {
    match (base, replacement) {
        (PhpMixed::Array(base), PhpMixed::Array(replacement)) => {
            PhpMixed::Array(array_replace_recursive_assoc(base, replacement))
        }
        (PhpMixed::List(base), PhpMixed::List(replacement)) => {
            PhpMixed::List(array_replace_recursive_list(base, replacement))
        }
        (_, replacement) => replacement,
    }
}

fn array_replace_recursive_assoc(
    mut base: IndexMap<String, PhpMixed>,
    replacement: IndexMap<String, PhpMixed>,
) -> IndexMap<String, PhpMixed> {
    for (key, replacement_value) in replacement {
        let merged = match base.get(&key) {
            Some(base_value) => {
                array_replace_recursive_value(base_value.clone(), replacement_value)
            }
            None => replacement_value,
        };
        base.insert(key, merged);
    }
    base
}

fn array_replace_recursive_list(
    mut base: Vec<PhpMixed>,
    replacement: Vec<PhpMixed>,
) -> Vec<PhpMixed> {
    for (index, replacement_value) in replacement.into_iter().enumerate() {
        if index < base.len() {
            base[index] = array_replace_recursive_value(base[index].clone(), replacement_value);
        } else {
            base.push(replacement_value);
        }
    }
    base
}

pub fn array_search_mixed(
    needle: &PhpMixed,
    haystack: &PhpMixed,
    strict: bool,
) -> Option<PhpMixed> {
    if !strict {
        // TODO(phase-c): non-strict array_search needs PHP's loose `==` comparison
        // semantics. Only the strict path is implemented; loose comparison is
        // deferred rather than approximated.
        todo!("non-strict array_search (PHP loose comparison)");
    }
    match haystack {
        PhpMixed::List(items) => items
            .iter()
            .position(|value| value == needle)
            .map(|i| PhpMixed::Int(i as i64)),
        PhpMixed::Array(map) => map
            .iter()
            .find(|(_, value)| *value == needle)
            .map(|(key, _)| php_key_to_mixed(key)),
        _ => None,
    }
}

pub fn array_search(needle: &str, haystack: &IndexMap<String, String>) -> Option<String> {
    haystack
        .iter()
        .find(|(_, value)| value.as_str() == needle)
        .map(|(key, _)| key.clone())
}

pub fn array_shift<T>(_array: &mut Vec<T>) -> Option<T> {
    if _array.is_empty() {
        None
    } else {
        Some(_array.remove(0))
    }
}

pub fn array_pop<T>(_array: &mut Vec<T>) -> Option<T> {
    _array.pop()
}

pub fn array_unshift<T>(_array: &mut Vec<T>, _value: T) {
    _array.insert(0, _value);
}

pub fn array_reverse<T: Clone>(_array: &[T], _preserve_keys: bool) -> Vec<T> {
    _array.iter().rev().cloned().collect()
}

pub fn array_filter<T: Clone, F>(_array: &[T], _callback: F) -> Vec<T>
where
    F: Fn(&T) -> bool,
{
    _array.iter().filter(|&x| _callback(x)).cloned().collect()
}

pub fn array_filter_map<F>(
    _array: &IndexMap<String, PhpMixed>,
    _callback: F,
) -> IndexMap<String, PhpMixed>
where
    F: Fn(&PhpMixed) -> bool,
{
    _array
        .iter()
        .filter(|&(_, v)| _callback(v))
        .map(|(k, v)| (k.clone(), v.clone()))
        .collect()
}

pub fn array_all<T, F>(_array: &[T], _callback: F) -> bool
where
    F: Fn(&T) -> bool,
{
    _array.iter().all(_callback)
}

pub fn array_any<T, F>(_array: &[T], _callback: F) -> bool
where
    F: Fn(&T) -> bool,
{
    _array.iter().any(_callback)
}

pub fn array_reduce<T, U, F>(_array: &[T], _callback: F, _initial: U) -> U
where
    F: Fn(U, &T) -> U,
{
    _array.iter().fold(_initial, _callback)
}

pub fn array_intersect<T: Clone + PartialEq>(_array1: &[T], _array2: &[T]) -> Vec<T> {
    _array1
        .iter()
        .filter(|&x| _array2.contains(x))
        .cloned()
        .collect()
}

pub fn array_flip(array: &PhpMixed) -> PhpMixed {
    let mut result: IndexMap<String, PhpMixed> = IndexMap::new();
    match array {
        PhpMixed::List(items) => {
            for (i, value) in items.iter().enumerate() {
                match value {
                    PhpMixed::Int(n) => {
                        result.insert(n.to_string(), PhpMixed::Int(i as i64));
                    }
                    PhpMixed::String(s) => {
                        result.insert(s.clone(), PhpMixed::Int(i as i64));
                    }
                    // Non int/string values cannot be array keys and are skipped.
                    _ => {}
                }
            }
        }
        PhpMixed::Array(map) => {
            for (key, value) in map {
                match value {
                    PhpMixed::Int(n) => {
                        result.insert(n.to_string(), php_key_to_mixed(key));
                    }
                    PhpMixed::String(s) => {
                        result.insert(s.clone(), php_key_to_mixed(key));
                    }
                    _ => {}
                }
            }
        }
        _ => panic!("array_flip(): Argument #1 ($array) must be of type array"),
    }
    PhpMixed::Array(result)
}

pub fn array_flip_strings(_array: &[String]) -> IndexMap<String, PhpMixed> {
    _array
        .iter()
        .enumerate()
        .map(|(i, s)| (s.clone(), PhpMixed::Int(i as i64)))
        .collect()
}

pub fn array_key_exists<V>(_key: &str, _array: &IndexMap<String, V>) -> bool {
    _array.contains_key(_key)
}

pub fn array_is_list(array: &PhpMixed) -> bool {
    match array {
        PhpMixed::List(_) => true,
        PhpMixed::Array(map) => map.keys().enumerate().all(|(i, k)| *k == i.to_string()),
        _ => panic!("array_is_list(): Argument #1 ($array) must be of type array"),
    }
}

pub fn array_splice<T>(
    _array: &mut Vec<T>,
    _offset: i64,
    _length: Option<i64>,
    _replacement: Vec<T>,
) -> Vec<T> {
    todo!()
}

pub fn array_pop_first<T>(array: &mut Vec<T>) -> Option<T> {
    if array.is_empty() {
        None
    } else {
        Some(array.remove(0))
    }
}

pub fn array_merge_recursive(_arrays: Vec<PhpMixed>) -> PhpMixed {
    todo!()
}

pub fn array_slice<V: Clone>(
    array: &IndexMap<String, V>,
    offset: i64,
    length: Option<i64>,
) -> IndexMap<String, V> {
    let (start, end) = php_slice_bounds(array.len() as i64, offset, length);
    array
        .iter()
        .skip(start)
        .take(end - start)
        .map(|(k, v)| (k.clone(), v.clone()))
        .collect()
}

pub fn array_map<T, U, F>(_callback: F, _array: &[T]) -> Vec<U>
where
    F: Fn(&T) -> U,
{
    _array.iter().map(_callback).collect()
}

pub fn array_filter_use_key(
    _array: &IndexMap<String, PhpMixed>,
    _callback: Box<dyn Fn(&str) -> bool>,
) -> IndexMap<String, PhpMixed> {
    _array
        .iter()
        .filter(|(k, _)| _callback(k.as_str()))
        .map(|(k, v)| (k.clone(), v.clone()))
        .collect()
}

pub fn array_chunk<T: Clone>(_array: &[T], _size: i64, _preserve_keys: bool) -> Vec<Vec<T>> {
    _array.chunks(_size as usize).map(|c| c.to_vec()).collect()
}

pub fn array_diff_key(
    _array1: IndexMap<String, PhpMixed>,
    _array2: &IndexMap<String, PhpMixed>,
) -> IndexMap<String, PhpMixed> {
    _array1
        .into_iter()
        .filter(|(k, _)| !_array2.contains_key(k.as_str()))
        .collect()
}

pub fn array_key_last(_array: &IndexMap<String, PhpMixed>) -> usize {
    todo!()
}

pub fn array_splice_mixed(
    _array: &mut Vec<PhpMixed>,
    _offset: i64,
    _length: i64,
    _replacement: Vec<PhpMixed>,
) {
    todo!()
}

/// Map a PHP array key (always stored as a `String` here) back to its PHP value
/// type: an integer-like key becomes an int, anything else stays a string.
fn php_key_to_mixed(key: &str) -> PhpMixed {
    if let Ok(n) = key.parse::<i64>() {
        if n.to_string() == key {
            return PhpMixed::Int(n);
        }
    }
    PhpMixed::String(key.to_string())
}

/// Resolve PHP array_slice/substr-style (offset, length) into a `[start, end)`
/// pair of indices, honouring negative offsets and lengths.
fn php_slice_bounds(len: i64, offset: i64, length: Option<i64>) -> (usize, usize) {
    let start = if offset < 0 {
        (len + offset).max(0)
    } else {
        offset.min(len)
    };
    let end = match length {
        None => len,
        Some(l) if l < 0 => (len + l).max(start),
        Some(l) => (start + l).min(len),
    };
    (start as usize, end as usize)
}

pub fn in_array(needle: PhpMixed, haystack: &PhpMixed, strict: bool) -> bool {
    let values: Vec<&PhpMixed> = match haystack {
        PhpMixed::List(items) => items.iter().collect(),
        PhpMixed::Array(map) => map.values().collect(),
        _ => return false,
    };

    if !strict {
        // TODO(phase-c): non-strict in_array needs PHP's loose `==` comparison semantics. Only the
        // strict path is implemented; loose comparison is deferred rather than approximated.
        todo!("non-strict in_array (PHP loose comparison)");
    }

    values.iter().any(|value| **value == needle)
}

pub fn krsort<V>(_array: &mut IndexMap<i64, V>) {
    todo!()
}

pub fn uasort<T, F>(array: &mut Vec<T>, compare: F)
where
    F: FnMut(&T, &T) -> i64,
{
    let mut compare = compare;
    array.sort_by(|a, b| compare(a, b).cmp(&0));
}

pub fn uasort_map<K, V, F>(array: &mut IndexMap<K, V>, compare: F)
where
    F: FnMut(&V, &V) -> i64,
{
    let mut compare = compare;
    array.sort_by(|_, v1, _, v2| compare(v1, v2).cmp(&0));
}

pub fn sort<T: Ord>(_array: &mut Vec<T>) {
    _array.sort();
}

pub fn sort_with_flags<T: Ord>(_array: &mut Vec<T>, _flags: i64) {
    todo!()
}

pub const SORT_REGULAR: i64 = 0;
pub const SORT_NUMERIC: i64 = 1;
pub const SORT_STRING: i64 = 2;
pub const SORT_NATURAL: i64 = 6;
pub const SORT_FLAG_CASE: i64 = 8;

pub fn usort<T, F>(_array: &mut Vec<T>, _compare: F)
where
    F: FnMut(&T, &T) -> i64,
{
    let mut compare = _compare;
    _array.sort_by(|a, b| compare(a, b).cmp(&0));
}

pub fn ksort<V>(_array: &mut IndexMap<String, V>) {
    todo!()
}

pub fn asort<V: Ord>(_array: &mut IndexMap<String, V>) {
    todo!()
}

pub fn uksort<V, F>(array: &mut IndexMap<String, V>, callback: F)
where
    F: FnMut(&str, &str) -> i64,
{
    let mut callback = callback;
    array.sort_by(|k1, _, k2, _| callback(k1, k2).cmp(&0));
}

pub fn sort_natural_flag_case(_values: &mut Vec<String>) {
    todo!()
}

pub fn count_mixed(value: &PhpMixed) -> i64 {
    count(value) as i64
}

pub fn count(value: &PhpMixed) -> usize {
    match value {
        PhpMixed::List(items) => items.len(),
        PhpMixed::Array(entries) => entries.len(),
        PhpMixed::Object(object) => object.count(),
        // PHP 8 throws a `TypeError` for non-countable arguments.
        PhpMixed::Null
        | PhpMixed::Bool(_)
        | PhpMixed::Int(_)
        | PhpMixed::Float(_)
        | PhpMixed::String(_) => {
            panic!("count(): Argument #1 ($value) must be of type Countable|array")
        }
    }
}

pub fn current(_value: PhpMixed) -> PhpMixed {
    todo!()
}

pub fn key(_value: PhpMixed) -> Option<String> {
    todo!()
}

pub fn reset<T: Clone>(_array: &[T]) -> Option<T> {
    _array.first().cloned()
}

pub fn reset_first<T: Clone>(_array: &[T]) -> Option<T> {
    _array.first().cloned()
}

pub fn end_arr<V: Clone>(_array: &IndexMap<String, V>) -> Option<V> {
    _array.values().last().cloned()
}

pub fn iterator_to_array<I>(iter: I) -> Vec<I::Item>
where
    I: IntoIterator,
{
    iter.into_iter().collect()
}

pub fn end<V: Clone>(_array: &[V]) -> Option<V> {
    _array.last().cloned()
}