use crate::gc::{Gc, Traverse};
use crate::vm::{Callable, RunError, Value};
use std::rc::Rc;

// I've already spent 2 months on this interpreter, and I'm tired, so I've cut a few corners...
/* See some of Lua's notes on this table: https://www.lua.org/source/5.5/ltable.c.html
This table uses an 'open-addressed' hashmap https://en.wikipedia.org/wiki/Open_addressing
where collisions are handled by 'linear-probing' and something I call 'displacement'.

Motivation:
Afaik, without having some mechanism that records or ensures known proximity between a displaced element
that collided with other(s) in the hashmap and it's original home (at element's hash's index),
the entire array may have to be checked just to see if an element is present. How can we fix this?

Solution:
Lua uses Brent's method, which I couldn't find a concrete explanation of, here I'm just recording
the maximum displacement that will need to be linearly-probed from the home entry to be certain of
any 'home' element's presence in the greater array.

Notes:
- If this value becomes large, the load factor is probably high and there would be a resize.
- Values would only need to be shuffled around closer to their 'home' during a resize.
- It is unlikely the displacement would large value without a resize amending that problem.
 */

type Displacement = u8;

#[cfg(feature = "bighash")]
pub type Hashed = u64;
#[cfg(not(feature = "bighash"))]
pub type Hashed = u32;

pub trait Equivalent<T>: Sized {
    fn matches(&self, other: &T) -> bool;
}

impl<T> Equivalent<T> for T
where
    T: PartialEq,
{
    fn matches(&self, other: &T) -> bool {
        self == other
    }
}

pub trait Hashes {
    fn hashed(&self) -> Hashed;
}

pub trait TableEntry: Equivalent<Self> + Hashes {
    fn new_vacant() -> Self;
    fn is_vacant(&self) -> bool;
}

#[derive(Debug, Clone)]
struct KeyValue {
    index: Value,
    value: Value,
}

impl Equivalent<Self> for KeyValue {
    fn matches(&self, other: &Self) -> bool {
        self.index == other.index
    }
}

impl Hashes for KeyValue {
    fn hashed(&self) -> Hashed {
        self.index.hashed()
    }
}

impl TableEntry for KeyValue {
    fn new_vacant() -> Self {
        KeyValue {
            index: Value::Nil,
            value: Value::Nil,
        }
    }
    fn is_vacant(&self) -> bool {
        matches!(
            self,
            KeyValue {
                index: Value::Nil,
                ..
            }
        )
    }
}

#[derive(Debug, Clone)]
struct Entry<E> {
    entry: E,
    home: usize,
    displacement: Displacement,
}

#[derive(Clone, Debug)]
pub struct Map<E: TableEntry + Clone> {
    // default representing vacancy!
    map: Vec<Entry<E>>,
    map_bounds: std::ops::Range<usize>,
    map_count: usize, // number of elements in table
}

impl<E: TableEntry + Clone> Map<E> {
    pub(crate) fn string_cache() { // todo: this isn't a clean way, maybe make a generic Map and use a specific one for the cache and the rest of the language
    }
    fn exchange_table(&mut self, len: usize) {
        let old = std::mem::replace(
            &mut self.map,
            vec![
                Entry {
                    entry: E::new_vacant(),
                    home: 0,
                    displacement: 0,
                };
                len
            ],
        );
        for Entry { entry, .. } in old {
            if entry.is_vacant() {
                self.set_table(entry)
            }
        }
    }
    pub fn resize_table(&mut self, len: usize) {
        self.exchange_table(len.max(self.map_count + (self.map_count / 3)));
        self.map_bounds = 0..self.table_upper();
    }
    fn table_upper(&self) -> usize {
        (self.map.len() / 4) * 3
    }
    fn table_lower(&self) -> usize {
        self.map.len() / 3
    }
    fn ensure_table(&mut self) {
        if self.map_count + 1 > self.table_upper() {
            // free space is short
            self.exchange_table((self.map.len() + 4) * 2);
        } else if self.map_count < self.table_lower() {
            // too much free space
            self.exchange_table(self.map.len() / 2)
        }
        self.map_bounds = self.table_lower()..self.table_upper()
    }
    pub(crate) fn set_table(&mut self, entry: E) {
        #[cfg(feature = "assertions")]
        assert!(!entry.is_vacant());
        if !self.map_bounds.contains(&(self.map_count + 1)) {
            // make sure the table is appropriately sized
            self.ensure_table();
        }
        let range = self.map.len();
        let home = entry.hashed() as usize % range;
        if self.map[home].entry.is_vacant() {
            // attempt to place it directly in an empty space
            // INSERT
            self.map[home].home = home;
            self.map[home].entry = entry;
            self.map[home].displacement = self.map[home].displacement.max(0);
            self.map_count += 1;
        } else if self.map[home].entry.matches(&entry) {
            // attempt to replace it directly
            // REPLACE
            self.map[home].entry = entry; // home.item.soft_drop()
        } else {
            // attempt to replace it in a collided neighbour location
            for i in 1..self.map[home].displacement + 1 {
                let neighbour = &mut self.map[(home + i as usize) % range]; // todo: is mod expensive?
                if neighbour.entry.matches(&entry) {
                    // found where it was displaced to
                    // REPLACE
                    neighbour.entry = entry;
                    return;
                }
            }
            // at this point it must be added, probe to place in an empty space
            for j in self.map[home].displacement + 1..Displacement::MAX - 1 {
                let neighbour = &mut self.map[(home + j as usize) % range];
                if neighbour.entry.is_vacant() {
                    // new empty slot hooray!
                    // INSERT
                    neighbour.entry = entry;
                    neighbour.home = home;
                    self.map[home].displacement = j;
                    self.map_count += 1;
                    return;
                }
            }
            // impossible but this still needs to be complete
            #[cfg(feature = "messages")]
            eprintln!("Large table collision, are the hashes ok?\n\tBrute-force probing...");
            let mut free: Option<usize> = None;
            for k in 0..self.map.len() {
                let neighbour = &mut self.map[k];
                if neighbour.entry.is_vacant() && free.is_none() {
                    free = Some(k);
                } else if neighbour.entry.matches(&entry) {
                    // REPLACE
                    neighbour.entry = entry;
                    return;
                }
            }
            if let Some(k) = free {
                // INSERT
                self.map[k].home = home;
                self.map[k].entry = entry;
                self.map[home].displacement = Displacement::MAX;
                self.map_count += 1;
                return;
            }
            // must resize
            #[cfg(feature = "messages")]
            eprintln!("\n\tResizing...");
            self.resize_table((self.map.len() + 4) * 2);
            self.set_table(entry);
        }
    }
    pub(crate) fn rem_table<K>(&mut self, index: K)
    where
        E: Equivalent<K>,
        K: Hashes,
    {
        if self.map.len() == 0 {
            return;
        }
        let range = self.map.len();
        let home = index.hashed() as usize % range;
        if self.map[home].entry.matches(&index) {
            self.map[home].entry = E::new_vacant();
            self.map_count -= 1;
        } else {
            if self.map[home].displacement != Displacement::MAX {
                let mut largest = 0;
                for i in 1..self.map[home].displacement {
                    let neighbour = &mut self.map[(home + i as usize) % range];
                    if neighbour.entry.matches(&index) {
                        neighbour.entry = E::new_vacant();
                        self.map_count -= 1;
                        if i == self.map[home].displacement {
                            self.map[home].displacement = largest
                        }
                        return;
                    } else if !neighbour.entry.is_vacant() && neighbour.home == home {
                        largest = i;
                    }
                }
            } else {
                let mut largest = 0;
                let mut finished = false; // what
                for k in 0..self.map.len() {
                    let neighbour = &mut self.map[k];
                    if neighbour.entry.matches(&index) {
                        neighbour.entry = E::new_vacant();
                        self.map_count -= 1;
                        #[cfg(feature = "assertions")]
                        assert!(!finished);
                        finished = true;
                    }
                    if neighbour.home == home && !neighbour.entry.is_vacant() {
                        largest = largest.max(if k < home {
                            k + self.map.len() - home - 1 // ?
                        } else {
                            k - home
                        })
                    }
                }
                self.map[home].displacement = if largest > Displacement::MAX as usize {
                    Displacement::MAX
                } else {
                    largest as Displacement
                }
            }
        }
    }
    pub(crate) fn get_table<K>(&mut self, index: K) -> Option<&E>
    where
        E: Equivalent<K>,
        K: Hashes,
    {
        if self.map.len() == 0 {
            return None;
        }
        let location = index.hashed() as usize % self.map.len();
        let home = &self.map[location];
        if home.entry.matches(&index) {
            Some(&home.entry)
        } else {
            for i in 1..home.displacement as usize {
                let neighbour = &self.map[location + i];
                if neighbour.entry.matches(&index) {
                    return Some(&neighbour.entry);
                }
            }
            None
        }
    }
    pub(crate) fn new() -> Map<E> {
        Map {
            map: Vec::new(),
            map_count: 0,
            map_bounds: (0..0).into(),
        }
    }
}

impl Hashes for Value {
    fn hashed(&self) -> Hashed {
        match self {
            Value::Nil => 0,
            Value::Bool(boolean) => {
                if *boolean {
                    1
                } else {
                    0
                }
            }
            Value::CachedString(cached) => cached.1,
            Value::String(_string, hash) => *hash,
            Value::Function(callable) => match callable {
                Callable::Rust(native) => Rc::as_ptr(native).addr() as Hashed,
                Callable::Mars(closure) => closure.addr() as Hashed,
            },
            Value::Integer(integer) => *integer as Hashed,
            Value::Number(number) => {
                if number.is_nan() {
                    0
                } else {
                    number.to_bits() as Hashed
                }
            }
            Value::Table(table) => table.addr() as Hashed,
            Value::Object(object) => object.addr() as Hashed,
            #[cfg(feature = "vector3")]
            Value::Vector(vec) => {
                let mut hasher = DefaultHasher::new();
                vec.as_u64vec3().hash(&mut hasher);
                hasher.finish() as usize
            }
        }
    }
}

// todo: displaced items don't ever get shuffled closer to their homes unless the table is resized
#[derive(Debug, Clone)]
pub struct Table {
    table: Map<KeyValue>,
    array: Vec<Value>,
    pub meta: Option<Gc<Table>>,
}

impl Traverse for Table {
    fn traverse(&self) {
        for Entry { entry, .. } in self.table.map.iter() {
            if !entry.is_vacant() {
                entry.index.traverse();
                entry.value.traverse();
            }
        }
        for item in self.array.iter() {
            item.traverse()
        }
    }
}

impl Equivalent<Value> for KeyValue {
    fn matches(&self, other: &Value) -> bool {
        self.index == *other
    }
}

impl Table {
    pub fn resize_array(&mut self, len: usize) {
        self.array.resize(len, Value::Nil)
    }
    pub fn set(&mut self, index: Value, value: Value) -> Result<(), RunError> {
        match index {
            Value::Integer(index) => {
                // This is an integer index, try the array first
                match value {
                    Value::Nil => {
                        if (0..self.array.len() + 1).contains(&(index as usize)) {
                            if self.array.len() == index as usize {
                                self.array.pop();
                            } else {
                                self.array[index as usize + 1] = Value::Nil
                            }
                        }
                        self.table.rem_table(Value::Integer(index));
                    }
                    item => {
                        if (0..self.array.len() + 1).contains(&(index as usize)) {
                            if self.array.len() == index as usize {
                                self.array.push(item)
                            } else {
                                self.array[index as usize + 1] = item;
                            }
                        } else {
                            self.table.set_table(KeyValue {
                                index: Value::Integer(index),
                                value: item,
                            })
                        }
                    }
                }
                Ok(())
            }
            Value::Nil => Err(RunError(
                "Attempt to set new index of table with key: nil".to_string(),
            )),
            index => Ok(self.table.set_table(KeyValue { index, value })),
        }
    }
    pub fn get(&mut self, index: Value) -> Result<Value, RunError> {
        match index {
            Value::Integer(index) => Ok(self
                .array
                .get(index as usize - 1)
                .unwrap_or(&Value::Nil)
                .clone()),
            Value::Nil => Err(RunError("Attempt to index table with key: nil".to_string())),
            index => {
                // todo: move this into the Map
                Ok(self
                    .table
                    .get_table(index)
                    .unwrap_or(&KeyValue {
                        index: Value::Nil,
                        value: Value::Nil,
                    })
                    .value
                    .clone())
            }
        }
    }
    pub fn append(&mut self, item: Value) {
        self.array.push(item)
    }
    pub fn new() -> Self {
        Table {
            table: Map::new(),
            array: Vec::new(),
            meta: None,
        }
    }
}