/**
 * welcum to the cache zone
 * Notes about data model here
 * Basically none of the ever gets written to disk so its mutability is
 * 
 * Memory Model things
 *  The cache should always own its own data and nothing else
 *  On calls where the cache system needs to take data it should actually 
 *  make its own copy to not disturb the render side of things as it too requires
 *  ownership of its own data. For this reason all parts of this are basically 
 *  going to be really selfish about its own data
 *
 */

use crate::config::ServerMeta;
use crate::api_types::{Channel, Message};
use crate::command::Command;
use crate::config::ConfigFile;

use std::collections::HashMap;
use hyper::Request;

struct ChannelCache {
    meta: Channel,
    messages: Vec<Message>
}

struct ServerCache {
    meta: ServerMeta,
    channels: Vec<ChannelCache>
}

pub struct Cache {
    // url -> Cache
    servers: HashMap<String, ServerCache>,
    active_server: Option<ServerMeta>
}

impl ServerCache {
    pub fn from(meta: ServerMeta, channels: Vec<ChannelCache>) -> Self {
        ServerCache { meta, channels }
    }
}

impl Cache {
    pub fn from(config: &ConfigFile) -> Cache {
        let mut servers = HashMap::new();
        for cfg in &config.servers {
            let i_server_cache = ServerCache::from(cfg.server.clone(), Vec::new());
            let url = i_server_cache.meta.url.clone();
            servers.insert(url, i_server_cache);
        }

        Cache {
            servers,
            active_server: None
        }
    }
}

impl Cache {
    pub async fn switch_channel(&mut self, id: u64) -> Command {
        if let Some(host) = self.active_server.as_ref() {
            Command::Failure(format!("Not implemented yet!"))
        } else {
            Command::Failure(format!("No server selected yet"))
        }
    }
    pub async fn switch_server(&mut self, host: &str) -> Command {
        if let Some(srv_cache) = self.servers.get(host) {
            Command::Failure(format!("Not implemented yet!"))
        } else {
            Command::Failure(format!("Host {{ {} }} not found", host))
        }
    }

    pub async fn send_message(&mut self, id: &str) -> Command {
        use hyper::body::HttpBody as _;
        use hyper::Client;

        if let Some(server) = self.active_server.as_ref() {
            let url = format!("{}/message/send", server.url);
            let request = Request::builder()
                .method("POST")
                .uri(url).body(()).unwrap();

            Command::Failure(format!("Not implemented yet!"))
        } else {
            Command::Failure(format!("No active server+channel to send message to"))
        }
    }

    pub fn list_hosts(&self) -> Command {
        let mut hosts = String::from("Hosts: ");
        for (host, _)  in self.servers.iter() {
            hosts.push_str(format!("{}, ", host).as_str());
        }
        Command::Text(hosts)
    }
}