use std::ops::{Deref, DerefMut};
use std::rc::Rc;
use std::sync::mpsc::{channel, Receiver, RecvError, SendError, Sender, TryRecvError};
use std::sync::{Mutex, PoisonError};
use std::thread::JoinHandle;

/// A store is a thing that manages mutations for a given state based on actions.
///
/// If you know redux: This is like redux but without middleware (yet).
///
/// # Types
/// A: The Action of the Store
/// S: The State of the Store
///
/// # Examples
/// ```rust
///
/// #[macro_use]
/// extern crate lazy_static;
///
///
/// use std::rc::Rc;
/// use std::sync::Mutex;
///
/// use gstore::store::{ combine_reducers, Store, LifecycleAction };
///
///
/// #[derive(Debug, Clone)]
/// struct State {
///    count: u32,
/// }
///
/// #[derive(Debug, Clone, Eq, PartialEq)]
/// enum Action {
///     Increment,
///     Decrement,
///     Startup,
///     Shutdown,
/// }
///
/// impl LifecycleAction for Action {
///     fn is_stop(&self) -> bool {
///         self == &Action::Shutdown
///     }
///     fn is_start(&self) -> bool {
///         self == &Action::Startup
///     }
/// }
///
/// lazy_static! {
///     static ref STATE: Mutex<State> = Mutex::new(State { count: 0 });
/// }
///
/// fn main() {
///     let mutex = Mutex::new(State { count: 0 });
///     let store: Rc<Store<Action, State>> = Rc::new(Store::new(&STATE));
///     let join = combine_reducers(store.clone(), &STATE, |action, state| match action {
///         Action::Increment => State {
///             count: state.count + 1,
///         },
///         Action::Decrement => State {
///          count: state.count - 1,
///         },
///         _ => state,
///     });
///     store.send(Action::Increment);
///     store.send(Action::Increment);
///     store.send(Action::Increment);
///     store.send(Action::Decrement);
///     store.send(Action::Shutdown);
///     join.join().unwrap().expect("Error during Store handling.");
///     assert_eq!(STATE.lock().unwrap().count, 2);
/// }
/// ```
///
pub struct Store<A, S>
where
    A: LifecycleAction + Send + Clone + Eq + PartialEq + 'static,
    S: Send + Clone + 'static,
{
    sender: Sender<A>,
    // Sender for ui actions
    receiver: Receiver<A>,
    // receiver of ui actions
    send_to_background: std::cell::Cell<Option<Sender<A>>>,
    // Sender for background actions
    state: &'static Mutex<S>,
    callbacks: Mutex<Vec<Box<dyn Fn(A, &S) + 'static>>>,
}

impl<A, S> Store<A, S>
where
    A: LifecycleAction + Send + Clone + Eq + PartialEq + 'static,
    S: Send + Clone + 'static,
{
    /// Creates a new state.
    ///
    /// Creates a new state with the reference to the static State mutex.
    pub fn new(state: &'static Mutex<S>) -> Self {
        let (sender, receiver) = channel();
        Store {
            sender,
            receiver,
            state,
            send_to_background: std::cell::Cell::new(None),
            callbacks: Mutex::new(Vec::new()),
        }
    }

    /// Sends the given `Action` to the store.
    ///
    /// This will trigger the reducers as well as notify all receivers (after the reducers) to
    /// handle the state change.
    pub fn send(&self, action: A) {
        if let Some(sender) = self.send_to_background.take() {
            match sender.send(action) {
                Ok(_) => self.send_to_background.set(Some(sender)),
                Err(e) => eprintln!("Could not send event: {:?}", e),
            }
        } else {
            eprintln!("Could not send event to background thread. No backgroun thread has been connected.")
        }
    }

    /// Registers the callback in the store.
    ///
    /// # Arguments
    /// callback: A closure which receives a sent `Action` and the `State` **after** the reducers
    /// were applied.
    pub fn receive(&self, callback: impl Fn(A, &S) + 'static) {
        match self.callbacks.lock() {
            Ok(mut cb) => {
                cb.deref_mut().push(Box::new(callback));
            }
            Err(_) => {}
        }
    }

    /// Send the given action from the ui thread.
    ///
    /// May only be used in the connected UI thread handler.
    pub fn ui_send(&self, action: A) {
        match self.callbacks.lock() {
            Ok(callbacks_lock) => match self.state.lock() {
                Ok(state) => {
                    for callback in callbacks_lock.deref() {
                        callback(action.clone(), state.deref());
                    }
                }
                Err(_) => {}
            },
            Err(_) => {}
        }
    }

    /// Tries to receive an Action from the Store.
    ///
    /// May only be used in the connected UI thread handler.
    pub fn ui_try_receive(&self) -> Result<A, TryRecvError> {
        self.receiver.try_recv()
    }

    // Returns a sender to the store (ui thread) and a receiver for the background thread.
    // Saves a sender to the background thread in self.connection
    fn connect(&self) -> (Sender<A>, Receiver<A>) {
        let (s, r) = channel();
        self.send_to_background.set(Some(s.clone()));
        (self.sender.clone(), r)
    }
}

/// Actions need to implement this trait so gstore can determine whether to notify, when the
/// application was started or stopped.
pub trait LifecycleAction {
    // return true for the action indicating that the application may be stopped.
    fn is_stop(&self) -> bool;
    // return true for the action indicating that the application was started.
    fn is_start(&self) -> bool;
}

/// Represents all possible runtime errors of the Store.
///
/// Those are either: RecvErrors or SendErrors of the internally used channel or PoisonErrors when
/// accessing the State mutex fails.
#[derive(Debug)]
pub struct StoreError {
    message: String,
    cause: String,
}

impl StoreError {
    pub fn message(&self) -> &str {
        &self.message
    }
    pub fn cause(&self) -> &str {
        &self.cause
    }
}

impl From<RecvError> for StoreError {
    fn from(re: RecvError) -> Self {
        StoreError {
            message: "Error in gstores channel communication.".to_string(),
            cause: format!("RecvError: {}", re),
        }
    }
}

impl<T> From<SendError<T>> for StoreError {
    fn from(re: SendError<T>) -> Self {
        StoreError {
            message: "Error in gstores channel communication.".to_string(),
            cause: format!("SendError: {}", re),
        }
    }
}

impl<T> From<PoisonError<T>> for StoreError {
    fn from(e: PoisonError<T>) -> Self {
        StoreError {
            message: "".to_string(),
            cause: format!("{:?}", e),
        }
    }
}

/// Applies the given reducer to the store.
pub fn combine_reducers<A, S>(
    store: Rc<Store<A, S>>,
    state: &'static Mutex<S>,
    reducer: impl Fn(A, S) -> S + Send + 'static,
) -> JoinHandle<Result<(), StoreError>>
where
    A: LifecycleAction + Send + Clone + Eq + PartialEq + 'static,
    S: Send + Clone + 'static,
{
    let (send_to_ui, receiver_in_background_thread) = store.connect();
    return std::thread::spawn(move || {
        loop {
            let action = receiver_in_background_thread.recv()?;
            let mut state = state.lock()?;
            *state = reducer(action.clone(), state.clone());
            send_to_ui.send(action.clone())?;
            if action.is_stop() {
                break;
            }
        }
        return Ok(());
    });
}

#[cfg(test)]
mod tests {
    use std::rc::Rc;
    use std::sync::Mutex;

    use crate::store::{combine_reducers, LifecycleAction, Store};

    #[derive(Debug, Clone)]
    struct State {
        count: u32,
    }

    #[derive(Debug, Clone, Eq, PartialEq)]
    enum Action {
        Increment,
        Decrement,
        Startup,
        Shutdown,
    }

    impl LifecycleAction for Action {
        fn is_stop(&self) -> bool {
            self == &Action::Shutdown
        }

        fn is_start(&self) -> bool {
            self == &Action::Shutdown
        }
    }

    lazy_static! {
        static ref STATE: Mutex<State> = Mutex::new(State { count: 0 });
    }

    #[test]
    fn test_counter() {
        let store: Rc<Store<Action, State>> = Rc::new(Store::new(&STATE));
        let handle = combine_reducers(store.clone(), &STATE, |action, state| match action {
            Action::Increment => State {
                count: state.count + 1,
            },
            Action::Decrement => State {
                count: state.count - 1,
            },
            Action::Shutdown => state,
            Action::Startup => state,
        });

        store.send(Action::Startup);
        store.send(Action::Increment);
        store.send(Action::Increment);
        store.send(Action::Increment);
        store.send(Action::Decrement);

        store.send(Action::Shutdown);
        handle.join().unwrap().expect("Could not join thread.");

        assert_eq!(STATE.lock().unwrap().count, 2);
    }
}