use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

use futures::channel::mpsc::UnboundedReceiver;
use futures::StreamExt;
use glib::MainContext;
use gtk4::prelude::*;
use gtk4::ProgressBar;

use common_dir_traversal::CheckingMethod;
use czkawka_core::common_dir_traversal;
use czkawka_core::common_dir_traversal::ProgressData;

use crate::flg;
use crate::gui_structs::gui_data::GuiData;
use crate::localizer_core::generate_translation_hashmap;
use crate::taskbar_progress::tbp_flags::TBPF_INDETERMINATE;
use crate::taskbar_progress::TaskbarProgress;

#[allow(clippy::too_many_arguments)]
pub fn connect_progress_window(
    gui_data: &GuiData,
    futures_receiver_duplicate_files: UnboundedReceiver<ProgressData>,
    futures_receiver_empty_files: UnboundedReceiver<ProgressData>,
    futures_receiver_empty_folder: UnboundedReceiver<ProgressData>,
    futures_receiver_big_files: UnboundedReceiver<ProgressData>,
    futures_receiver_same_music: UnboundedReceiver<ProgressData>,
    futures_receiver_similar_images: UnboundedReceiver<ProgressData>,
    futures_receiver_similar_videos: UnboundedReceiver<ProgressData>,
    futures_receiver_temporary: UnboundedReceiver<ProgressData>,
    futures_receiver_invalid_symlinks: UnboundedReceiver<ProgressData>,
    futures_receiver_broken_files: UnboundedReceiver<ProgressData>,
    futures_receiver_bad_extensions: UnboundedReceiver<ProgressData>,
) {
    let main_context = MainContext::default();
    let _guard = main_context.acquire().unwrap();

    process_bar_duplicates(gui_data, &main_context, futures_receiver_duplicate_files);
    process_bar_empty_files(gui_data, &main_context, futures_receiver_empty_files);
    process_bar_empty_folder(gui_data, &main_context, futures_receiver_empty_folder);
    process_bar_big_files(gui_data, &main_context, futures_receiver_big_files);
    process_bar_same_music(gui_data, &main_context, futures_receiver_same_music);
    process_bar_similar_images(gui_data, &main_context, futures_receiver_similar_images);
    process_bar_similar_videos(gui_data, &main_context, futures_receiver_similar_videos);
    process_bar_temporary(gui_data, &main_context, futures_receiver_temporary);
    process_bar_invalid_symlinks(gui_data, &main_context, futures_receiver_invalid_symlinks);
    process_bar_broken_files(gui_data, &main_context, futures_receiver_broken_files);
    process_bar_bad_extensions(gui_data, &main_context, futures_receiver_bad_extensions);
}
fn process_bar_empty_files(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_empty_files: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_empty_files.next().await {
            label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
            taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_empty_folder(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_empty_folder: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_empty_folder.next().await {
            label_stage.set_text(&flg!(
                "progress_scanning_empty_folders",
                generate_translation_hashmap(vec![("folder_number", item.entries_checked.to_string())])
            ));
            taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_big_files(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_big_files: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_big_files.next().await {
            label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
            taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_same_music(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_same_music: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
    let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_same_music.next().await {
            match item.current_stage {
                0 => {
                    progress_bar_current_stage.hide();
                    label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                1 => {
                    progress_bar_current_stage.show();
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);

                    match item.checking_method {
                        CheckingMethod::AudioTags => label_stage.set_text(&flg!("progress_scanning_music_tags", progress_ratio_tm(&item))),
                        CheckingMethod::AudioContent => label_stage.set_text(&flg!("progress_scanning_music_content", progress_ratio_tm(&item))),
                        _ => panic!(),
                    }
                }
                2 => {
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);

                    match item.checking_method {
                        CheckingMethod::AudioTags => label_stage.set_text(&flg!("progress_scanning_music_tags_end", progress_ratio_tm(&item))),
                        CheckingMethod::AudioContent => label_stage.set_text(&flg!("progress_scanning_music_content_end", progress_ratio_tm(&item))),
                        _ => panic!(),
                    }
                }
                3 => {
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);

                    match item.checking_method {
                        CheckingMethod::AudioContent => label_stage.set_text(&flg!("progress_scanning_music_tags", progress_ratio_tm(&item))),
                        _ => panic!(),
                    }
                }
                _ => panic!(),
            }
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_similar_images(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_similar_images: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
    let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_similar_images.next().await {
            match item.current_stage {
                0 => {
                    progress_bar_current_stage.hide();
                    label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                1 => {
                    progress_bar_current_stage.show();
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);
                    label_stage.set_text(&flg!("progress_scanning_image", progress_ratio_tm(&item)));
                }
                2 => {
                    progress_bar_current_stage.show();
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);
                    label_stage.set_text(&flg!("progress_comparing_image_hashes", progress_ratio_tm(&item)));
                }
                _ => panic!(),
            }
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_similar_videos(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_similar_videos: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
    let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_similar_videos.next().await {
            match item.current_stage {
                0 => {
                    progress_bar_current_stage.hide();
                    label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                1 => {
                    progress_bar_current_stage.show();
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);
                    label_stage.set_text(&flg!("progress_scanning_video", progress_ratio_tm(&item)));
                }
                _ => panic!(),
            }
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_temporary(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_temporary: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_temporary.next().await {
            label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
            taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_invalid_symlinks(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_invalid_symlinks: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_invalid_symlinks.next().await {
            label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
            taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_broken_files(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_broken_files: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
    let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_broken_files.next().await {
            match item.current_stage {
                0 => {
                    progress_bar_current_stage.hide();
                    label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                1 => {
                    progress_bar_current_stage.show();
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);
                    label_stage.set_text(&flg!("progress_scanning_broken_files", progress_ratio_tm(&item)));
                }
                _ => panic!(),
            }
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_bad_extensions(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_bad_extensions: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
    let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_bad_extensions.next().await {
            match item.current_stage {
                0 => {
                    progress_bar_current_stage.hide();
                    label_stage.set_text(&flg!("progress_scanning_general_file", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                1 => {
                    progress_bar_current_stage.show();
                    common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);
                    label_stage.set_text(&flg!("progress_scanning_extension_of_files", progress_ratio_tm(&item)));
                }
                _ => panic!(),
            }
        }
    };
    main_context.spawn_local(future);
}
fn process_bar_duplicates(gui_data: &GuiData, main_context: &MainContext, mut futures_receiver_duplicate_files: UnboundedReceiver<ProgressData>) {
    let label_stage = gui_data.progress_window.label_stage.clone();
    let progress_bar_current_stage = gui_data.progress_window.progress_bar_current_stage.clone();
    let progress_bar_all_stages = gui_data.progress_window.progress_bar_all_stages.clone();
    let grid_progress_stages = gui_data.progress_window.grid_progress_stages.clone();
    let taskbar_state = gui_data.taskbar_state.clone();
    let future = async move {
        while let Some(item) = futures_receiver_duplicate_files.next().await {
            match item.checking_method {
                CheckingMethod::Hash => {
                    label_stage.show();
                    match item.current_stage {
                        // Checking Size
                        0 => {
                            progress_bar_current_stage.hide();
                            // progress_bar_all_stages.hide();
                            progress_bar_all_stages.set_fraction(0 as f64);
                            label_stage.set_text(&flg!("progress_scanning_size", file_number_tm(&item)));
                            taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                        }
                        // Hash - first 1KB file
                        1 => {
                            progress_bar_current_stage.show();
                            // progress_bar_all_stages.show();
                            common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);

                            label_stage.set_text(&flg!("progress_analyzed_partial_hash", progress_ratio_tm(&item)));
                        }
                        // Hash - normal hash
                        2 => {
                            common_set_data(&item, &progress_bar_all_stages, &progress_bar_current_stage, &taskbar_state);
                            label_stage.set_text(&flg!("progress_analyzed_full_hash", progress_ratio_tm(&item)));
                        }
                        _ => {
                            panic!("Not available current_stage");
                        }
                    }
                }
                CheckingMethod::Name => {
                    label_stage.show();
                    grid_progress_stages.hide();

                    label_stage.set_text(&flg!("progress_scanning_name", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                CheckingMethod::SizeName => {
                    label_stage.show();
                    grid_progress_stages.hide();

                    label_stage.set_text(&flg!("progress_scanning_size_name", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                CheckingMethod::Size => {
                    label_stage.show();
                    grid_progress_stages.hide();

                    label_stage.set_text(&flg!("progress_scanning_size", file_number_tm(&item)));
                    taskbar_state.borrow().set_progress_state(TBPF_INDETERMINATE);
                }
                _ => panic!(),
            };
        }
    };
    main_context.spawn_local(future);
}

fn common_set_data(item: &ProgressData, progress_bar_all_stages: &ProgressBar, progress_bar_current_stage: &ProgressBar, taskbar_state: &Rc<RefCell<TaskbarProgress>>) {
    if item.entries_to_check != 0 {
        progress_bar_all_stages.set_fraction((item.current_stage as f64 + (item.entries_checked) as f64 / item.entries_to_check as f64) / (item.max_stage + 1) as f64);
        progress_bar_current_stage.set_fraction((item.entries_checked) as f64 / item.entries_to_check as f64);
        taskbar_state.borrow().set_progress_value(
            ((item.current_stage as usize) * item.entries_to_check + item.entries_checked) as u64,
            item.entries_to_check as u64 * (item.max_stage + 1) as u64,
        );
    } else {
        progress_bar_all_stages.set_fraction((item.current_stage as f64) / (item.max_stage + 1) as f64);
        progress_bar_current_stage.set_fraction(0f64);
        taskbar_state.borrow().set_progress_value(item.current_stage as u64, 1 + item.max_stage as u64);
    }
}

fn file_number_tm(item: &ProgressData) -> HashMap<&'static str, String> {
    generate_translation_hashmap(vec![("file_number", item.entries_checked.to_string())])
}
fn progress_ratio_tm(item: &ProgressData) -> HashMap<&'static str, String> {
    generate_translation_hashmap(vec![("file_checked", item.entries_checked.to_string()), ("all_files", item.entries_to_check.to_string())])
}