use core::fmt;
use std::collections::HashMap;
use std::fs::create_dir;
use std::thread::JoinHandle;
use std::{thread, vec};
use crossbeam::channel::{self, Receiver, Sender};
use std::sync::{Arc, Mutex};
use tracing::{trace, debug, info, warn, error};
use uuid::Uuid;
use std::fs::File;
use colored::Colorize;
use std::path::Path;
use interner::shared::{VecStringPool, StringPool};


use crate::error::{MizeError, MizeResult, IntoMizeResult, MizeResultTrait};
use crate::instance::store::Store;
use crate::instance::updater::updater_thread;
use crate::id::{IntoMizeId, MizeId, Namespace};
use crate::instance::subscription::Subscription;
use crate::item::{Item, ItemData};
use crate::memstore::MemStore;
use crate::instance::updater::Operation;
use crate::mize_err;
use crate::proto::MizeMessage;

use self::connection::{ConnListener, Connection};

#[cfg(feature = "async")]
use tokio::runtime::Runtime;
use core::future::Future;

pub mod connection;
pub mod store;
pub mod subscription;
pub mod updater;
pub mod msg_thread;

static MSG_CHANNEL_SIZE: usize = 200;

/// The Instance type is the heart of the mize system
#[derive(Clone)]
pub struct Instance {
    // question vec of stores???
    // would mean replication logic and such things is handeled by the instance
    // i think it would be better thogh to then implement a ReplicatedStore
    pub store: Box<dyn Store>,
    connections: Arc<Mutex<Vec<Connection>>>,
    next_con_id: Arc<Mutex<u64>>,
    subs: Arc<Mutex<HashMap<MizeId, Subscription>>>,
    pub id_pool: Arc<Mutex<VecStringPool>>,
    pub namespace_pool: Arc<Mutex<StringPool>>,
    pub namespace: Namespace,
    op_tx: channel::Sender<Operation>,
    context: Vec<MizeId>,
    threads: Vec<String>,
    #[cfg(feature = "async")]
    pub runtime: Arc<Mutex<Runtime>>,
    give_msg_wait: Arc<Mutex<HashMap<MizeId, (Sender<ItemData>, Receiver<ItemData>)>>>,
}

pub struct InstanceRef {
    inner: Arc<Mutex<Instance>>,
}

pub struct InstanceAsync {
    inner: Arc<Mutex<Instance>>,
}


impl Instance {
    pub fn empty() -> MizeResult<Instance> {
        let store = MemStore::new();
        let id_pool = Arc::new(Mutex::new(VecStringPool::default()));
        let namespace_pool_raw = StringPool::default();
        let connections = Arc::new(Mutex::new(Vec::new()));
        let subs = Arc::new(Mutex::new(HashMap::new()));
        let namespace = Namespace ( namespace_pool_raw.get("mize.default.namespace") );
        let (op_tx, op_rx) = channel::unbounded();
        let give_msg_wait = Arc::new(Mutex::new(HashMap::new()));

        let mut instance = Instance { 
            store: Box::new(store), 
            connections, subs, id_pool,
            namespace, op_tx,
            namespace_pool: Arc::new(Mutex::new(namespace_pool_raw)),
            context: vec![],
            threads: vec![],
            next_con_id: Arc::new(Mutex::new(1)),
            give_msg_wait,

            #[cfg(feature = "async")]
            runtime: Arc::new(Mutex::new(Runtime::new().mize_result_msg("Could not create async runtime")?)),
        };

        let instance_clone = instance.clone();
        let closure = move || updater_thread(op_rx, instance_clone);
        instance.spawn("updater_thread", closure)?;

        // will probably move the msg stuff into it's own thread
        //let msg_instance_clone = instance.clone();
        //let msg_closure = move || msg_thread(op_rx, instance_clone);
        //instance.spawn("msg_thread", closure)?;


        return Ok(instance);
    }

    pub fn new() -> MizeResult<Instance> {
        trace!("[ {} ] Instance::new()", "CALL".yellow());

        let mut instance = Instance::empty()?;

        instance.init();

        debug!("instance inited with config: {}", instance.get("0/config")?.as_data_full()?);

        return Ok(instance);
    }

    fn init(&mut self) -> MizeResult<()> {

        // platform specific init code
        if cfg!(feature = "os-target") { // on os platforms
            crate::platform::os::os_instance_init(self)?
        }

        // end of platform specific init code

        Ok(())
    }

    pub fn with_config(config: ItemData) -> MizeResult<Instance> {
        trace!("[ {} ] Instance::with_config()", "CALL".yellow());
        trace!("config: {}", config);
        let mut instance = Instance::empty()?;
        instance.set("0", config.clone());
        instance.init()?;

        // set it again, so that the passed config data has presidence over anything the init would set
        debug!("overwriting instance config again with the one passed to Instance::with_config()");
        instance.set("0", config);

        debug!("instance inited with conifg: {}", instance.get("0/config")?);

        Ok(instance)
    }

    pub fn migrate_to_store(&mut self, new_store: Box<dyn Store>) -> MizeResult<()> {
        println!("MIGRATING");
        let old_store = &self.store;

        let id = self.id_from_string("0".to_owned())?;
        let inst_data = self.store.get_value_data_full(id.clone())?;
        new_store.set(id, inst_data.to_owned())?;

        for id in old_store.id_iter()? {
            let data = self.store.get_value_data_full(self.id_from_string(id?)?)?;

            let id_of_new_store = new_store.new_id()?;
            new_store.set(self.id_from_string(id_of_new_store)?, data.to_owned())?;
        };

        self.store = new_store;

        Ok(())
    }

    pub fn new_item(&self) -> MizeResult<Item> {
        let id = self.id_from_string(self.store.new_id()?)?;
        return Ok(Item::new(id, &self));
    }

    pub fn get<I: IntoMizeId>(&self, id: I) -> MizeResult<Item> {
        let id = id.to_mize_id(self)?;
        return Ok(Item::new(id, &self));
    }

    pub fn set<I: IntoMizeId, V: Into<ItemData>>(&mut self, id: I, value: V) -> MizeResult<()> {
        let id = id.to_mize_id(self)?;
        self.op_tx.send(Operation::Set(id, value.into()));
        Ok(())
    }

    pub fn new_id<T: IntoMizeId>(&self, value: T) -> MizeResult<MizeId> {
        value.to_mize_id(self)
    }

    pub fn id_from_string(&self, string: String) -> MizeResult<MizeId> {
        let vec_string: Vec<String> = string.split("/").map(|v| v.to_owned()).collect();
        let id_pool_inner = self.id_pool.lock()?;

        let id = MizeId { path: id_pool_inner.get(vec_string), namespace: self.namespace.clone() };

        Ok(id)
    }

    pub fn id_from_vec_string(&self, vec_string: Vec<String>) -> MizeResult<MizeId> {
        let id_pool_inner = self.id_pool.lock()?;
        let id = MizeId { path: id_pool_inner.get(vec_string), namespace: self.namespace.clone() };
        Ok(id)
    }

    pub fn namespace_from_string(&self, ns_str: String) -> MizeResult<Namespace> {
        let namespace_pool_inner = self.namespace_pool.lock()?;
        let namespace = Namespace ( namespace_pool_inner.get(ns_str) );
        Ok(namespace)
    }

    pub fn add_listener<T: ConnListener +'static>(&mut self, listener: T) -> MizeResult<()> {
        let mut instance_clone = self.clone();
        self.spawn("some_listener", move || listener.listen(instance_clone));
        Ok(())
    }

    pub fn new_connection(&mut self, rx: Receiver<MizeMessage>, tx: Sender<MizeMessage>) -> MizeResult<u64> {
        let mut conn_inner = self.connections.lock()?;
        let mut next_con_id = self.next_con_id.lock()?;

        let connection = Connection { id: next_con_id.to_owned(), rx, tx, ns: None};
        conn_inner.push(connection);
        *next_con_id += 1;
        Ok(next_con_id.to_owned())
    }

    pub fn connection_set_namespace(&mut self, conn_id: u64, namespace: Namespace) -> MizeResult<()> {
        let mut connection = self.get_connection(conn_id)?;
        connection.ns = Some(namespace);
        self.set_connection(conn_id, connection);
        Ok(())
    }

    fn set_connection(&mut self, conn_id: u64, new_connection: Connection) -> MizeResult<()> {
        let mut conn_inner = self.connections.lock()?;

        for connection in conn_inner.iter_mut() {
            if connection.id == conn_id {
                *connection = new_connection;
                return Ok(());
            }
        }

        return Err(mize_err!("Connection with id {} not known to instance", conn_id));
        Ok(())
    }

    pub fn get_connection(&self, conn_id: u64) -> MizeResult<Connection> {
        let mut conn_inner = self.connections.lock()?;

        for connection in conn_inner.iter() {
            if connection.id == conn_id {
                return Ok(connection.clone());
            }
        }

        return Err(mize_err!("Connection with id {} not known to instance", conn_id));
    }

    pub fn spawn(&mut self, name: &str, func: impl FnOnce() -> MizeResult<()> + Send + 'static) -> MizeResult<()> {
        self.threads.push(name.to_owned());
        thread::spawn(move || func());
        Ok(())
    }

    pub fn give_msg_wait(&self, id: MizeId) -> MizeResult<ItemData> {

        let mut give_msg_wait_inner = self.give_msg_wait.lock()?;

        let rx = match give_msg_wait_inner.get(&id) {
            // if this id is already in the process of being requested, just use the rx already there
            Some((tx, rx)) => rx.to_owned(),

            None => {
                let (tx, rx) = crossbeam::channel::bounded::<ItemData>(1);
                give_msg_wait_inner.insert(id, (tx, rx.clone()));
                rx
            },
        };

        // so that another thread can also give_msg_wait(), while we wait in the recv() of rx
        drop(give_msg_wait_inner);

        let data = rx.recv()?;

        return Ok(data);
    }

    #[cfg(feature = "async")]
    pub fn spawn_async<F: Future<Output = impl Send + Sync + 'static> + Send + Sync + 'static>(&mut self, name: &str, func: F) {
        self.threads.push(name.to_owned());
        let runtime_inner = self.runtime.lock().unwrap();
        runtime_inner.spawn(func);
    }

    pub fn wait(&self) {
        loop {
            thread::sleep_ms(10000000)
        }
    }
}

impl fmt::Debug for Instance {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Mize Instance with subs: {:?}", self.subs,)
    }
}