# Run tests for view changes. The `kind` can be set to "compare" or "accept".
view kind="preview":
    TEST_KIND="{{kind}}" \
        cargo run --bin inflorescence-view-test-setup && \
        cargo test --package inflorescence-view -- view

# Watch tests for view changes. The `kind` can be set to "compare" or "accept".
watch_view kind="preview":
    TEST_KIND="{{kind}}" \
        cargo watch \
        --exec "run --bin inflorescence-view-test-setup" \
        --exec "test --package inflorescence-view -- view" \
        --ignore "screenshots" \
        --ignore "preview"

use iced::{window, Element, Theme};
use iced_test::Simulator;
use std::{env, path::PathBuf, str::FromStr};
/// This env var can be set to one of [`TestKind`] cases.
pub const TEST_KIND_ENV_VAR: &str = "TEST_KIND";
pub const SCREENSHOTS_DIR: &str = "screenshots";
pub const PREVIEW_DIR: &str = "preview";
#[derive(Debug, Default, strum::EnumString)]
#[strum(ascii_case_insensitive)]
pub enum TestKind {
    /// (default): Compare new screenshot against the stored ones. The tests with any difference will fail
    #[default]
    Compare,
    /// Preview the new screenshots in single resolution without comparing against the stored ones.
    Preview,
    /// Delete the old screenshots and save the new ones.
    Accept,
}
#[derive(Debug)]
pub struct TestViewResult<'a> {
    pub name: &'a str,
    pub succeeded: bool,
}
#[derive(Debug, Clone, Copy)]
pub enum Size {
    Fullscreen,
    Specific { width: f32, height: f32 },
}
/// The name of the test calling this function MUST start with "view".
pub fn test_view<'a, 'b, Message, Renderer>(
    results: &mut Vec<TestViewResult<'b>>,
    uniq_name: &'b str,
    element: impl Into<Element<'a, Message, Theme, Renderer>>,
    size: Size,
) where
    Renderer: iced::advanced::Renderer + iced::advanced::renderer::Headless,
{
    let test_kind = test_kind();
    let size = match size {
        Size::Fullscreen => iced::Size::new(512., 384.),
        Size::Specific { width, height } => iced::Size { width, height },
    };
    let mut sim =
        Simulator::with_size(iced::Settings::default(), size, element);
    let snapshot = sim.snapshot(&theme()).unwrap();
    let file_name = format!("{uniq_name}.png");
    match test_kind {
        TestKind::Compare => {
            let dir = PathBuf::from(PREVIEW_DIR);
            let matched = snapshot.matches_image(dir.join(&file_name)).unwrap();
            // Return result to collect all runs first
            results.push(TestViewResult {
                name: uniq_name,
                succeeded: matched,
            })
        }
        TestKind::Preview => {
            let dir = PathBuf::from(PREVIEW_DIR);
            let matched = snapshot.matches_image(dir.join(&file_name)).unwrap();
            assert!(matched, "The view {uniq_name} doesn't have a unique name");
            // Preview mode doesn't need a result
        }
        TestKind::Accept => {
            let dir = PathBuf::from(SCREENSHOTS_DIR);
            let matched = snapshot.matches_image(dir.join(&file_name)).unwrap();
            assert!(matched, "The view {uniq_name} doesn't have a unique name");
            // Accept mode doesn't need a result
        }
    }
}
pub fn test_kind() -> TestKind {
    if let Ok(val) = env::var(TEST_KIND_ENV_VAR) {
        let val = val.trim();
        if !val.is_empty() {
            return TestKind::from_str(val).unwrap_or_else(|err| {
                panic!("Unexpected test kind: {val}, failed parsing with {err}")
            });
        }
    }
    TestKind::default()
}
pub fn report_results(results: Vec<TestViewResult<'_>>) {
    if results.iter().any(|result| !result.succeeded) {
        panic!(
            "Changed views: {:#?}",
            results.into_iter().filter_map(
                |TestViewResult { name, succeeded }| if succeeded {
                    None
                } else {
                    Some(name)
                }
            )
        );
    }
}
fn theme() -> Theme {
    crate::theme(&(), window::Id::unique())
}

pub mod testing;

use iced::{window, Theme};

use iced::{window, Theme};

#[cfg(test)]
mod test;

use super::{cursor, file, view, State};
use crate::testing::{report_results, test_view, Size};
use libflorescence::{prelude::pijul::HashMap, repo};
use iced::window;
use std::{
    collections::{BTreeMap, BTreeSet},
    path::PathBuf,
};
#[test]
fn view_app() {
    let window_id = window::Id::unique();
    let size = Size::Fullscreen;
    let mut results = vec![];
    // _________________________________________________________________________
    //
    let uniq_name = "app_loading_repo";
    let repo_path = PathBuf::from("test/repo/path");
    let repo = None;
    let cursor = cursor::State { selection: None };
    let record_msg = None;
    let diffs_state = HashMap::new();
    let diff = file::Diff::Loading;
    let state = State {
        repo_path: &repo_path,
        repo: repo.as_ref(),
        cursor: &cursor,
        record_msg: record_msg.as_ref(),
        diffs_state: &diffs_state,
    };
    test_view(
        &mut results,
        uniq_name,
        view(state, window_id, |_id| Some(&diff)),
        size,
    );
    // _________________________________________________________________________
    //
    let uniq_name = "app_loaded_empty_repo";
    let repo = Some(repo::State {
        dir_name: "path".to_string(),
        channel: "some_channel".to_string(),
        untracked_files: BTreeSet::new(),
        changed_files: BTreeMap::new(),
        log: vec![],
    });
    let state = State {
        repo_path: &repo_path,
        repo: repo.as_ref(),
        cursor: &cursor,
        record_msg: record_msg.as_ref(),
        diffs_state: &diffs_state,
    };
    test_view(
        &mut results,
        uniq_name,
        view(state, window_id, |_id| Some(&diff)),
        size,
    );
    // _________________________________________________________________________
    //
    report_results(results);
}

use inflorescence_view::testing::{
    test_kind, TestKind, PREVIEW_DIR, SCREENSHOTS_DIR,
};
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
use std::io::Write;
use std::path::Path;
use std::{fs, path::PathBuf};
const CRATE_DIR: &str = "inflorescence_view";
fn main() {
    match test_kind() {
        TestKind::Compare => {
            // Copy stored screenshots into the preview dir to use for comparison
            let dir = PathBuf::from(CRATE_DIR).join(PREVIEW_DIR);
            let _res = fs::remove_dir_all(&dir);
            fs::create_dir_all(&dir).unwrap();
            for entry in fs::read_dir(&dir).unwrap() {
                let entry = entry.unwrap();
                let ty = entry.file_type().unwrap();
                if ty.is_dir() {
                    panic!("Unexpectedly found dir {} inside screenshots dir {SCREENSHOTS_DIR}", entry.path().to_string_lossy());
                } else {
                    fs::copy(entry.path(), dir.join(entry.file_name()))
                        .unwrap();
                }
            }
            print_screenshot_target(&dir);
        }
        TestKind::Preview => {
            // Clear the preview dir to store new ones
            let dir = PathBuf::from(CRATE_DIR).join(PREVIEW_DIR);
            if let Ok(entries) = fs::read_dir(&dir) {
                for entry in entries {
                    let entry = entry.unwrap();
                    let ty = entry.file_type().unwrap();
                    if ty.is_dir() {
                        panic!("Unexpectedly found dir {} inside screenshots dir {PREVIEW_DIR}", entry.path().to_string_lossy());
                    } else {
                        fs::remove_file(entry.path()).unwrap();
                    }
                }
            } else {
                fs::create_dir_all(&dir).unwrap();
            }
            print_screenshot_target(&dir);
        }
        TestKind::Accept => {
            // Clear the screenshots dir to store new ones
            let dir = PathBuf::from(CRATE_DIR).join(SCREENSHOTS_DIR);
            if let Ok(entries) = fs::read_dir(&dir) {
                for entry in entries {
                    let entry = entry.unwrap();
                    let ty = entry.file_type().unwrap();
                    if ty.is_dir() {
                        panic!("Unexpectedly found dir {} inside screenshots dir {PREVIEW_DIR}", entry.path().to_string_lossy());
                    } else {
                        fs::remove_file(entry.path()).unwrap();
                    }
                }
            } else {
                fs::create_dir_all(&dir).unwrap();
            }
            print_screenshot_target(&dir);
        }
    }
}
fn print_screenshot_target(path: &Path) {
    let mut stdout = StandardStream::stdout(ColorChoice::Always);
    writeln!(&mut stdout, "").unwrap();
    stdout
        .set_color(ColorSpec::new().set_bg(Some(Color::Magenta)))
        .unwrap();
    write!(&mut stdout, "Screenshots will be saved in:").unwrap();
    stdout.reset().unwrap();
    writeln!(&mut stdout, " \"{}\"", path.to_string_lossy()).unwrap();
    writeln!(&mut stdout, "").unwrap();
}

[lib]
name = "inflorescence_view"
path = "src/lib.rs"
[[bin]]
name = "inflorescence-view-test-setup"
path = "bin/view_test_setup.rs"

workspace = true
[dependencies.strum]

[dependencies.termcolor]
workspace = true

[workspace.dependencies.termcolor]
version = "1"

 "strum 0.27.1",
 "termcolor",

/inflorescence_view/preview