pub mod view_module{

    use gtk4 as gtk;

    use gtk::{*, prelude::*};

    use crate::{
        model::model::model_module::*,
        view::{
            properties::properties_module::*,
            components::{
                *,
                tabs::tabs_module::*,
                switch::switch_module::*,
                wrapper::wrapper_module::*,
            }
        },
        controller::{
            controller::*,
            view_utils::input_utils::input_utils_module::*,
            event_handlers::{
                button_event_handlers::button_event_handlers_module::*,
                switch_event_handlers::switch_event_handlers_module::*,
            },
        }
    };

    pub fn laboratory_work_first_section(wrapper: &Box) -> (){

        // input

        let hamming_text_view_input_label = Label::builder()
            .halign(Align::Start)
            .set_margin(MarginData::MultipleMargin((10, 5, 0, 0)))
            .label(String::from("Поле ввода для кода:"))
            .build();

        let hamming_text_view_input = TextView::builder()
            .monospace(true)
            .set_text_view_margin(MarginData::EqualsMargin(6))
            .wrap_mode(WrapMode::Word)
            .build();

        let hamming_text_view_input_frame = Frame::builder()
            .child(&hamming_text_view_input)
            .height_request(64)
            .set_margin(MarginData::MultipleMargin((0, 5, 0, 5)))
            .build();

        // output

        let hamming_text_view_output_label = Label::builder()
            .halign(Align::Start)
            .set_margin(MarginData::MultipleMargin((10, 5, 0, 0)))
            .label(String::from("Результат:"))
            .build();

        let hamming_text_view_output = TextView::builder()
            .monospace(true)
            .editable(false)
            .set_text_view_margin(MarginData::EqualsMargin(6))
            .wrap_mode(WrapMode::Word)
            .build();

        let hamming_text_view_output_frame = Frame::builder()
            .child(&hamming_text_view_output)
            .height_request(64)
            .set_margin(MarginData::MultipleMargin((0, 5, 0, 5)))
            .build();

        // interactive panel

        let clear_input_button =
            Button::builder()
                .set_align(Alignment::new(Align::Fill, Align::Fill))
                .label("Очистка полей")
                .build();

        let hamming_crypt_button = Button::builder()
            .set_align(Alignment::new(Align::Fill, Align::Fill))
            .label("Выполнить")
            .build();

        let crypt_mode_switch = Switch::new();

        let crypt_mode_label = Label::builder()
            .label("Режим: кодирование")
            .build();

        // references for binding actions

        let clear_input_button_to_handle = clear_input_button.clone();

        let crypt_mode_label_to_handle = crypt_mode_label.clone();
        let crypt_mode_switch_to_handle = crypt_mode_switch.clone();

        let text_view_input_for_parse = hamming_text_view_input.clone();
        let text_view_output_for_output = hamming_text_view_output.clone();

        let text_view_input_for_clearing = hamming_text_view_input.clone();
        let text_view_output_for_clearing = hamming_text_view_input.clone();

        // actions

        EventHandler::new(
            clear_input_button_to_handle,
            move |_| {
                clearing(&text_view_input_for_clearing, &text_view_output_for_clearing);
            }
        ).on_click();

        EventHandler::new(
            hamming_crypt_button.clone(),
            move |button: &Button| {
                parse_input(
                    &text_view_input_for_parse,
                    &text_view_output_for_output,
                    crypt_mode_switch_to_handle.state()
                )
            }).on_click();

        EventHandler::new(
            crypt_mode_switch.clone(),
            move |s : &Switch| {
                state_controller(s, &crypt_mode_label_to_handle);
            }).on_toggle();

        // wrappers

        let crypt_mode_wrapper = Wrapper::col_builder()
            .set_align(Alignment::new(Align::Fill, Align::Center))
            .hexpand(true)
            .spacing(10)
            .build();

        let interactive_components_wrapper = Wrapper::col_builder()
            .set_align(Alignment::new(Align::Fill, Align::Fill))
            .set_margin(MarginData::MultipleMargin((0, 5, 0, 5)))
            .spacing(10)
            .build();

        crypt_mode_wrapper.append(&crypt_mode_switch);
        crypt_mode_wrapper.append(&crypt_mode_label);

        interactive_components_wrapper.append(&clear_input_button);
        interactive_components_wrapper.append(&crypt_mode_wrapper);
        interactive_components_wrapper.append(&hamming_crypt_button);

        wrapper.append(&hamming_text_view_input_label);
        wrapper.append(&hamming_text_view_input_frame);
        wrapper.append(&interactive_components_wrapper);
        wrapper.append(&hamming_text_view_output_label);
        wrapper.append(&hamming_text_view_output_frame);

    }

    pub fn ui(application: &Application) {

        let mutual_wrapper = Wrapper::row_builder()
            .set_align(Alignment::new(Align::Fill, Align::Fill))
            .set_margin(MarginData::EqualsMargin(15))
            .spacing(10)
            .build();

        laboratory_work_first_section(&mutual_wrapper);

        let second_wrapper = Wrapper::row_builder()
            .set_align(Alignment::new(Align::Fill, Align::Fill))
            .set_margin(MarginData::EqualsMargin(15))
            .spacing(10)
            .build();

        second_wrapper.append(&Label::new(Some("Код Хафмана")));

        let notebook = Tabs::builder()
            .add_tabs(
                vec!["Код Хэмминга", "Код Хафмана"],
                vec![mutual_wrapper, second_wrapper]
            )
            .build("Tabs")
            .get();

        let window = ApplicationWindow::builder()
            .title("Комплексная программа для лаб. работ")
            .width_request(650)
            .height_request(400)
            .application(application)
            .child(&notebook)
            .build();

        window.show();
    }

}