use std::sync::{ Arc, RwLock, RwLockReadGuard, RwLockWriteGuard };
use std::fmt::Display;

use linked_hash_set::LinkedHashSet;

use pest::error::Error as PestError;
use pest::RuleType;

#[derive(Debug, Clone)]
pub struct TaskHandle {
    inner: Arc<RwLock<HandlerInner>>,
    task_index: usize
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct HandlerInner {
    tasks: Vec<TaskRecord>,
    total_warnings: usize,
    total_errors: usize
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct TaskRecord {
    parent_task_index: usize,

    task_name: &'static str,
    file_name: Option<String>,

    errors:   LinkedHashSet<String>,
    warnings: LinkedHashSet<String>
}

impl HandlerInner {
    fn add_warning(&mut self, task_index: usize, warning: String) {
        self.tasks[task_index].warnings.insert(warning);
        self.total_warnings += 1;
    }

    fn add_error(&mut self, task_index: usize, error: String) {
        self.tasks[task_index].errors.insert(error);
        self.total_errors += 1;
    }

    fn get_label(&self, task_index: usize) -> String {
        let mut task_indices = Vec::new();

        let mut current_index = task_index;
        let mut last_index = None;

        while last_index != Some(current_index) {
            task_indices.push(current_index);
            last_index = Some(current_index);
            current_index = self.tasks[current_index].parent_task_index;
        }

        task_indices.iter().rev()
            .map(|i| self.tasks[*i].task_name)
            .collect::<Vec<&str>>()
            .join(".")
    }

    fn get_file(&self, task_index: usize) -> Option<&str> {
        let mut current_index = task_index;
        let mut last_index = None;

        while last_index != Some(current_index) {
            if let Some(fname) = &self.tasks[current_index].file_name {
                return Some(fname);
            }
            last_index = Some(current_index);
            current_index = self.tasks[current_index].parent_task_index;
        }
        None
    }
}

impl TaskHandle {
    pub fn new(root_task_name: &'static str) -> Self {
        let warnings = LinkedHashSet::new();
        let errors = LinkedHashSet::new();

        let root_task = TaskRecord {
            parent_task_index: 0,
            task_name: root_task_name,
            file_name: None,
            errors,
            warnings
        };

        let tasks = vec![root_task];

        TaskHandle {
            inner: Arc::new(RwLock::new(HandlerInner {
                tasks,
                total_errors: 0,
                total_warnings: 0
            })),
            task_index: 0
        }
    }

    pub fn sub_task(&self, task_name: &'static str, file_name: Option<String>) -> Self {
        let sub_task = TaskRecord {
            parent_task_index: self.task_index,
            task_name, file_name,
            errors: LinkedHashSet::new(),
            warnings: LinkedHashSet::new()
        };

        let mut inner = self.get_inner_ref_mut();

        let sub_task_index = inner.tasks.len();
        inner.tasks.push(sub_task);

        TaskHandle {
            inner: self.inner.clone(),
            task_index: sub_task_index
        }
    }

    #[inline]
    fn get_inner_ref(&self) -> RwLockReadGuard<HandlerInner> {
        self.inner.as_ref().read().unwrap()
    }

    #[inline]
    fn get_inner_ref_mut(&self) -> RwLockWriteGuard<HandlerInner> {
        self.inner.as_ref().write().unwrap()
    }

    /// Handle a warning
    pub fn warning<W: Display>(&self, warning: W) {
        self.get_inner_ref_mut()
            .add_warning(self.task_index, format!("{}", warning));
    }
    
    /// Convert a Result to an Option by handling the Err case as a warning
    pub fn res_warning<T, W: Display>(&self, res: Result<T, W>) -> Option<T> {
        match res {
            Ok(value) => Some(value),
            Err(warning) => {
                self.warning(warning);
                None
            }
        }
    }

    /// Handle an error
    pub fn error<E: Display>(&self, error: E) {
        self.get_inner_ref_mut()
            .add_error(self.task_index, format!("{}", error));
    }

    pub fn pest_error<R: RuleType>(&self, error: PestError<R>) {
        let mut inner = self.get_inner_ref_mut();

        let fname_opt = inner.get_file(self.task_index);
        
        let error = match fname_opt {
            Some(fname) => error.with_path(fname),
            None => error
        };

        inner.add_error(self.task_index, format!("{}", error));
    }

    /// Convert a Result to an Option by handling the Err case as an error
    pub fn res_error<T, E: Display>(&self, res: Result<T, E>) -> Option<T> {
        match res {
            Ok(value) => Some(value),
            Err(error) => {
                self.error(error);
                None
            }
        }
    }

    pub fn none_error<T, E: Display>(&self, opt: Option<T>, error: E) -> Option<T> {
        if opt.is_none() {
            self.error(error);
        }
        opt
    }

    pub fn print_starting(&self) {
        let inner = self.get_inner_ref();
        println!("Starting {}...", inner.get_label(self.task_index));
    }

    pub fn print_finished(&self) {
        let inner = self.get_inner_ref();
        println!("Finished {}\n", inner.get_label(self.task_index));
    }

    pub fn report_results(&self) {
        let inner = self.get_inner_ref();
        let root_task = inner.tasks[0].task_name;

        for (i, task) in inner.tasks.iter().enumerate() {
            if task.errors.len() > 0 || task.warnings.len() > 0 {
                println!("{}:", inner.get_label(i));

                for error in task.errors.iter() {
                    println!("{}\n", error);
                }

                for warning in task.warnings.iter() {
                    println!("{}\n", warning);
                }
            }
        }

        if inner.total_errors == 0 {
            println!("{} Succeeded!", root_task);
        } else {
            println!("{} Failed!", root_task);
        }
        
        println!("Errors: {}",   inner.total_errors);
        println!("Warnings: {}", inner.total_warnings);
    }
}