use std::{collections::HashMap, str::Split};

#[derive(Debug, Clone)]
pub struct HeaderMap {
    map: HashMap<String, usize>,
    headers: Vec<Header> 
}

impl HeaderMap {
    
    #[allow(dead_code)]
    pub fn get(&self, key: &str) -> Option<&Header> {
        let Some(index) = self.map.get(key) else {
            return None;
        };
        return Some(&self.headers[index.to_owned()]);
    }

    pub fn put(&mut self, header: Header) {
        if let Some(index) = self.map.get(&header.key) {
            self.headers[index.to_owned()] = header;
            return
        }

        let index = self.headers.len();
        self.map.insert(header.key.clone(), index);
        self.headers.push(header);
    }

    #[allow(dead_code)]
    pub fn del(&mut self, key: &str) -> Option<Header> {
        let Some(index) = self.map.get(key) else {
            return None
        };

        let removed = self.headers.remove(index.to_owned());
        for i in (index.to_owned())..self.headers.len() {
            let key = &self.headers[i].key;

            let Some(index) = self.map.get(key) else {
                continue;
            };

            self.map.insert(key.clone(), index - 1);
        }

        Some(removed)
    }

    pub fn deserialize(&self) -> String {
        let mut string = String::new();

        for header in &self.headers {
            string += &format!("{}: {}\n", header.key, header.value);             
        }

        string
    }

    pub fn serialize(lines: &mut Split<char>) -> Self {

        let mut headers = Self::new();

        loop {
            let Some(header) = lines.next() else { break };
            if header.trim().len() < 1 { break }

            let mut parts = header.split(": ").into_iter();
            let Some(key) = parts.next() else { continue };
            let Some(value) = parts.next() else { continue };
       
            headers.put(Header::new(key.trim(), value.trim()));
        }

        headers
    }

    pub fn new() -> Self {
        Self {
            map: HashMap::new(),
            headers: Vec::new()
        }
    }
}

#[derive(Debug, Clone)]
pub struct Header {
    pub key: String,
    pub value: String
}

impl Header {
    pub fn new(key: &str, value: &str) -> Self {
        return Self {key: key.to_owned(), value: value.to_owned()}
    }
}