use std::fs;
use std::io;
use std::option::Option;
use std::path::{Path, PathBuf};
use std::ffi::OsStr;

use imgui;
use rlua::Lua;

#[derive(Default, PartialEq)]
pub struct Test {
    pub path: PathBuf,
}

#[derive(Default)]
pub struct Bench {
    lua: Lua,
    tests: Vec<Test>,
    selected_test: Option<usize>,
}

impl Bench {
    pub fn new() -> Bench {
        let mut b = Bench {
            lua: Lua::new(),
            tests: Vec::new(),
            selected_test: None,
        };

        // TODO: set graphically and use RV
        b.load_tests("lua");

        return b;
    }

    pub fn load_tests<P>(&mut self, path: P) -> io::Result<()>
    where
        P: AsRef<Path>,
    {
        let entries: Result<Vec<PathBuf>, io::Error> = fs::read_dir(path)?
            .into_iter()
            .map(|r| r.map(|f| f.path()))
            .collect();

        match entries {
            Ok(files) => {
                self.tests = files
                    .into_iter()
                    .filter(|f| f.is_file())
                    .filter(|f| f.extension().unwrap_or(OsStr::new("")) == "lua")
                    .map(|f| Test { path: f })
                    .collect();

                return Ok(());
            }
            Err(e) => return Err(e),
        }
    }

    pub fn draw(&mut self, _: &mut bool, ui: &mut imgui::Ui) {
        use imgui::*;

        let win = Window::new(im_str!("Testbench"))
            .size([400., 500.], Condition::Appearing)
            .position([20., 20.], Condition::Appearing);

        win.build(&ui, || {
            for (index, test) in self.tests.iter().enumerate() {
                if let Some(test_name) = test.path.to_str() {
                    let test_name: ImString = test_name.to_string().into();
                    let selected = matches!(self.selected_test, Some(i) if i == index);

                    if Selectable::new(&test_name).selected(selected).build(ui) {
                        self.selected_test = Some(index)
                    }
                }
            }

            ui.separator();
            if let Some(index) = self.selected_test {
                if let Some(test_name) = self.tests[index].path.to_str() {
                    let imstr: ImString =
                        format!("Selected Test: {}", test_name).to_string().into();
                    ui.text_wrapped(&imstr);
                    ui.same_line(0.);
                    if ui.button(im_str!("Run"), [0., 0.]) {
                    }
                    ui.same_line(0.);
                    if ui.button(im_str!("Show"), [0., 0.]) {}
                }
            }
        });
    }

    fn run_test(&self, index: usize) {
        self.lua.context(|context| {
            
        });
    }
}