use std::{collections::{BTreeMap, HashMap}, sync::Mutex};
use serde::Serialize;
use strum::{EnumIter, IntoEnumIterator};
use strum_macros::IntoStaticStr; 

use esp_idf_svc::systime::EspSystemTime;
use once_cell::sync::Lazy;
use ringbuffer::{ConstGenericRingBuffer, RingBuffer};
use text_template::Template;

const TXT_SHORT_LENGTH:usize = 8;
const TXT_LONG_LENGTH:usize = 32;

const BUFFER_SIZE:usize = 210;

#[link_section = ".rtc.data"]
static mut BUFFER:ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE> = ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>::new();
#[allow(static_mut_refs)]
static BUFFER_ACCESS: Lazy<Mutex<&mut ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>>> = Lazy::new(|| unsafe { Mutex::new(&mut BUFFER) });


#[derive(Serialize, Debug, Clone)]
pub struct LogEntry {
    pub timestamp: u64,
    pub message_id: u32,
    pub a: u32,
    pub b: u32,
    pub txt_short: heapless::String<TXT_SHORT_LENGTH>,
    pub txt_long: heapless::String<TXT_LONG_LENGTH>
}

pub fn init(){
    unsafe { 
        BUFFER = ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>::new();
    };
    let mut access = BUFFER_ACCESS.lock().unwrap();
    access.drain().for_each(|_| {});
}

fn limit_length <const LIMIT:usize> (input: &str, target: &mut heapless::String<LIMIT>){
    for char in input.chars() {
        match target.push(char) {
            Ok(_) => {}, //continue adding chars
            Err(_) => {
                //clear space for two asci chars
                while target.len()+2 >= LIMIT {
                    target.pop().unwrap();
                }
                //add .. to shortened strings
                target.push('.').unwrap();
                target.push('.').unwrap();
                return;
            },
        }
    }
}

pub fn get_log() -> Vec<LogEntry>{
    let buffer = BUFFER_ACCESS.lock().unwrap();
    let mut read_copy = Vec::new();
    for entry in buffer.iter() {
        let copy = entry.clone();
        read_copy.push(copy);
    }
    drop(buffer);
    return read_copy;
}

pub fn log(message_key: LogMessage, number_a: u32, number_b: u32, txt_short:&str, txt_long:&str){
    let mut txt_short_stack:heapless::String<TXT_SHORT_LENGTH> = heapless::String::new();
    let mut txt_long_stack:heapless::String<TXT_LONG_LENGTH> = heapless::String::new();
    
    limit_length(txt_short, &mut txt_short_stack);
    limit_length(txt_long, &mut txt_long_stack);
    
    let time = EspSystemTime {}.now().as_millis() as u64;

    let template_string:&str = message_key.into();


    let mut values: HashMap<&str, &str> = HashMap::new();
    let number_a_str = number_a.to_string();
    let number_b_str = number_b.to_string();

    values.insert("number_a", &number_a_str);
    values.insert("number_b", &number_b_str);
    values.insert("txt_short", txt_short);
    values.insert("txt_long", txt_long);

    let template = Template::from(template_string);
    let serial_entry = template.fill_in(&values);
   
    println!("{serial_entry}");


    let entry = LogEntry{
        timestamp: time,
        message_id: 1,
        a: number_a,
        b: number_b,
        txt_short: txt_short_stack,
        txt_long: txt_long_stack,
    };


    let mut buffer = BUFFER_ACCESS.lock().unwrap();    
    buffer.push(entry);
}




#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn within_limit() {
        let test = "12345678";
        
        let mut txt_short_stack:heapless::String<TXT_SHORT_LENGTH> = heapless::String::new();
        let mut txt_long_stack:heapless::String<TXT_LONG_LENGTH> = heapless::String::new();
        limit_length(test, &mut txt_short_stack);
        limit_length(test, &mut txt_long_stack);

        assert_eq!(txt_short_stack.as_str(), test);
        assert_eq!(txt_long_stack.as_str(), test);
    }
}



#[derive(IntoStaticStr, EnumIter, Serialize, PartialEq, Eq, PartialOrd, Ord, Clone)]
pub enum LogMessage {
    #[strum(serialize = "Reset due to {{txt_long}} requires rtc clear {{a}} and force config mode {{b}}")]   
    ResetReason,
    #[strum(serialize = "Current restart to conf mode {{a}}")]   
    RestartToConfig,
    #[strum(serialize = "Current low voltage detection is {{a}}")]   
    LowVoltage,
    #[strum(serialize = "Error communicating with battery!! {{txt_long}}")]   
    BatteryCommunicationError,
    #[strum(serialize = "Tank sensor raw {{a}} percent {{b}}")]   
    SensorTankRaw,
    #[strum(serialize = "raw measure unscaled {{a}} hz {{b}}, plant {{txt_short}} sensor {{txt_long}}")]   
    RawMeasure,
    #[strum(serialize = "IP info: {{txt_long}}")]   
    WifiInfo,
    #[strum(serialize = "Plant:{{txt_short}} a:{{a}} b:{{b}}")]   
    TestSensor,
    #[strum(serialize = "Stay alive topic is {{txt_long}}")]   
    StayAlive,
    #[strum(serialize = "Connecting mqtt {{txt_short}} with id {{txt_long}}")]   
    MqttInfo,
    #[strum(serialize = "Received stay alive with value {{txt_short}}")]   
    MqttStayAliveRec,
    #[strum(serialize = "Unknown topic recieved {{txt_long}}")]   
    UnknownTopic,
    #[strum(serialize = "Partition state is {{txt_long}}")]   
    PartitionState,
    #[strum(serialize = "Mounted Filesystem free {{a}} total {{b}} use {{txt_short}}")]
    FilesystemMount,
    #[strum(serialize = "Mounting Filesystem, this will format the first time and needs quite some time!")]
    MountingFilesystem,
    #[strum(serialize = "Year inplausible, force config mode")]
    YearInplausibleForceConfig,
    #[strum(serialize = "Going to config mode, due to request from prior run")]
    ConfigModeSoftwareOverride,
    #[strum(serialize = "Going to config mode, due to request via config mode button")]
    ConfigModeButtonOverride,
    #[strum(serialize = "Going to normal mode")]
    NormalRun,
    #[strum(serialize = "Missing normal config, entering config mode {{txt_long}}")]
    ConfigModeMissingConfig,
    #[strum(serialize = "startup state wifi {{a}} sntp {{b}} mqtt {{txt_short}}")]
    StartupInfo,
    #[strum(serialize = "Trying to pump for {{b}}s with pump {{a}} now dryrun: {{txt_short}}")]
    PumpPlant,
    #[strum(serialize = "Enable main power dryrun: {{a}}")]
    EnableMain,
    #[strum(serialize = "Pumped multiple times, but plant is still to try attempt: {{a}} limit :: {{b}} plant: {{txt_short}}")]
    ConsecutivePumpCountLimit
}

impl LogMessage {
    pub fn to_log_localisation_config() -> BTreeMap<LogMessage,&'static str> {
        let mut data = BTreeMap::new();
        for msg_type in LogMessage::iter() {
            let s: &'static str = msg_type.clone().into();
            data.insert(msg_type, s);
        }
        data
    }
}