//! z_rs implements a directory jumping command line utility
//!
//! The original is a 200 line shell classic
//! https://github.com/rupa/z/blob/master/z.sh
//!
//! This is an **opinionated** rewrite instead of being 1:1
//! with the original. Most notably, this does not override
//! `cd` in any way, and needs to be used instead of `cd` to
//! build the cache.
//!
//! This provides a `z_rs` binary, which can be invoked
//! for configuration and lookup.
//!
//! ## Installation
//!
//! Currently unpublished, do
//!
//! ```sh
//! cargo install https://github.com/suyash/z-rs
//! ```
//!
//! ## Configuration
//!
//! add
//!
//! ```sh
//! eval "$(z_rs init --cmd z --cache $HOME/.z_rs)"
//! ```
//!
//! in your shell configuration file.
//!
//! The `--cmd` option is the name of the command that will
//! be added to the shell. For example, in this case, a `z`
//! command will be created.
//!
//! ## Usage
//!
//! If configured with the command name `z`, then simply do
//!
//! ```sh
//! z foo bar
//! ```
//!
//! will try to match `foo` and `bar` and if a match is found
//! in the cache, will `cd` to it, otherwise error out.
//!
//! Matches occur based on "frecency". The rank of a path is
//! how many times it has been accessed. The command will return
//! the highest ranked matching record. If there are multiple,
//! it will return the most recently accessed one.

#![deny(missing_docs)]

use std::collections::HashMap;

use bstr::ByteSlice;
use serde::{Deserialize, Serialize};

#[cfg(test)]
mod tests;

#[derive(Serialize, Deserialize, Debug)]
/// Records contains a record of all stored values
pub struct Records {
    map: HashMap<Vec<u8>, (f64, u64)>,
    sum: f64,
}

impl Records {
    /// new creates a new Records instance
    pub fn new() -> Records {
        Self::default()
    }

    /// update increments the rank of the provided path
    /// and updates its timestamp
    pub fn update<T>(&mut self, path: T, ts: u64)
    where
        T: AsRef<[u8]>,
    {
        let v = self.map.entry(path.as_ref().to_owned()).or_insert((0.0, 0));
        v.0 += 1.0;
        v.1 = ts;

        self.sum += 1.0;

        // TODO: implement pruning and reorging
    }

    /// query matches a record from the saved records from the given
    /// arguments. The rank of a record is how many times it has been used.
    /// The match is returned based on "frecency", i.e.
    /// the highest ranked matching record is given priority,
    /// if there are multiple then the most recently accessed record
    /// with the same rank is returned.
    pub fn query<T>(&self, arguments: &[T]) -> Option<Vec<u8>>
    where
        T: AsRef<[u8]>,
    {
        let mut ans = None;

        // NOTE: since rust hash maps are swiss tables now,
        // assuming straight up iteration is a feasible op
        for (path, (score, timestamp)) in self.map.iter() {
            let mut index = 0;

            for argument in arguments {
                match path[index..].find(argument) {
                    None => {
                        index = path.len() + 1;
                        break;
                    }
                    Some(fix) => {
                        index += fix + argument.as_ref().len();
                    }
                }
            }

            if index <= path.len() {
                ans = match ans {
                    None => Some((path, (score, timestamp))),
                    Some((ppath, (pscore, ptimestamp))) => {
                        if score > pscore
                            || ((score - pscore).abs() < std::f64::EPSILON
                                && timestamp > ptimestamp)
                        {
                            Some((path, (score, timestamp)))
                        } else {
                            Some((ppath, (pscore, ptimestamp)))
                        }
                    }
                };
            }
        }

        match ans {
            None => None,
            Some((path, _)) => Some(path.clone()),
        }
    }

    /// query_and_update runs a query followed by an update
    /// with the result of the query.
    pub fn query_and_update<T>(&mut self, arguments: &[T], ts: u64) -> Option<Vec<u8>>
    where
        T: AsRef<[u8]>,
    {
        match self.query(arguments) {
            None => None,
            Some(v) => {
                self.update(&v, ts);
                Some(v)
            }
        }
    }
}

impl Default for Records {
    fn default() -> Self {
        Records {
            map: HashMap::new(),
            sum: 0.0,
        }
    }
}