use eframe::egui;
use std::{
    fmt,
    fs::File,
    io::{Read, Write},
    sync::{Arc, OnceLock},
};
use eframe::egui::{mutex::RwLock, Align2, Button, Color32, TextEdit, Vec2};
use egui_flex::{item, Flex, FlexInstance};
use serde::{Deserialize, Serialize};
pub mod activities;
pub mod classes;
pub mod classrooms;
pub mod generate;
pub mod generating;
pub mod lectures;
pub mod limitations;
pub mod print_pdf;
pub mod teachers;
#[derive(Default, Debug, Eq, PartialEq, Clone)]
pub enum SubPage {
    Teachers,
    #[default]
    Classes,
}
impl fmt::Display for SubPage {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SubPage::Teachers => write!(f, "Öğretmenler"),
            SubPage::Classes => write!(f, "Sınıflar"),
            // SubPage::Classrooms => write!(f, "Derslikler"),
        }
    }
}
pub fn get_page() -> &'static Arc<RwLock<SubPage>> {
    static PAGE: OnceLock<Arc<RwLock<SubPage>>> = OnceLock::new();
    PAGE.get_or_init(|| Arc::new(RwLock::new(SubPage::Classes)))
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct School {
    name: String,
    hour: usize,
}
// impl School {
//     fn get_name(self) -> String {
//         self.name
//     }
//     fn get_hour(&self) -> i32 {
//         self.hour
//     }
// }
pub fn school_page(ui: &mut eframe::egui::Ui) {
    ui.vertical_centered(|ui| {
        let name = &mut *school_name().write();
        let name_text = TextEdit::singleline(name).hint_text("Okulunuzun Adı");
        ui.add(name_text);
        let hour = &mut *school_hour().write();
        let hour_text = TextEdit::singleline(hour).hint_text("Günlük Ders Saati Sayısı");
        ui.add(hour_text);
        let button = Button::new("Kaydet");
        if ui
            .add_enabled(hour.parse::<usize>().is_ok(), button)
            .clicked()
        {
            save_school();
        };
    });
}
fn save_school() {
    std::thread::spawn(|| {
        let school = School {
            name: school_name().read().clone(),
            hour: school_hour().read().parse::<usize>().unwrap(),
        };
        let js = serde_json::to_string(&school);
        match js {
            Ok(j) => {
                let mut f = File::create("./db/school.json").unwrap();
                f.write_all(j.as_bytes()).unwrap();
            }
            Err(_) => {}
        }
    });
}
fn read_school() -> School {
    let f = File::open("./db/school.json");
    if let Ok(mut f) = f {
        let mut content: String = String::new();
        f.read_to_string(&mut content).unwrap();
        let cls: School = serde_json::from_str(content.as_str()).unwrap();
        return cls;
    }
    School::default()
}
fn get_school() -> &'static Arc<RwLock<School>> {
    static SCHOOL: OnceLock<Arc<RwLock<School>>> = OnceLock::new();
    SCHOOL.get_or_init(|| Arc::new(RwLock::new(read_school())))
}
fn school_name() -> &'static Arc<RwLock<String>> {
    let name = &*get_school().read().name;
    static SCHOOL: OnceLock<Arc<RwLock<String>>> = OnceLock::new();
    SCHOOL.get_or_init(|| Arc::new(RwLock::new(name.to_string())))
}
pub fn school_hour() -> &'static Arc<RwLock<String>> {
    let hour = get_school().read().hour;
    static SCHOOL: OnceLock<Arc<RwLock<String>>> = OnceLock::new();
    SCHOOL.get_or_init(|| Arc::new(RwLock::new(hour.to_string())))
}
pub fn panel_buttons(ui: &mut egui::Ui) {
    ui.layout().horizontal_justify();
    let panels = vec![SubPage::Classes, SubPage::Teachers];
    Flex::horizontal()
        .wrap(true)
        .justify(egui_flex::FlexJustify::Center)
        .width_percent(1.)
        .align_items_content(Align2::CENTER_TOP)
        .show(ui, |flex| panels.iter().for_each(|p| panel_frame(flex, p)));
}
fn panel_frame(flex: &mut FlexInstance, p: &SubPage) {
    let page = &*get_page().read();
    let f_color = if page == p {
        Color32::DARK_BLUE
    } else {
        Color32::default()
    };
    let resp = flex.add(
        item().grow(1.),
        Button::new(format!("{p}"))
            .min_size(Vec2::new(150., 40.))
            .fill(f_color),
    );
    if resp.clicked() {
        let p = p.clone();
        std::thread::spawn(move || {
            *get_page().write() = p.clone();
        });
    }
}

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
pub mod fonts;
pub mod tabs;
use eframe::egui;
use eframe::egui::ViewportBuilder;
use eframe::NativeOptions;
use egui_dock::{DockArea, DockState, Style};
fn main() -> eframe::Result<()> {
    let size = ViewportBuilder::default().with_maximized(true);
    let options = NativeOptions {
        viewport: size,
        ..Default::default()
    };
    eframe::run_native(
        "Lapis Ders Dağıtım",
        options,
        Box::new(|_cc| Ok(Box::<MyApp>::default())),
    )
}
static DAYS: &[&str] = &[
    "Pazartesi",
    "Salı",
    "Çarşamba",
    "Perşembe",
    "Cuma",
    "Cumartesi",
    "Pazar",
];
#[derive(Default, Debug)]
enum Page {
    #[default]
    Home,
    Signin,
    _Login,
}
#[derive(Default, Debug)]
enum HomeTab {
    #[default]
    Home,
    Classes,
    Teachers,
    Classrooms,
    Lectures,
    Limitations,
    Activities,
    Generate,
}
impl egui_dock::TabViewer for HomeTab {
    type Tab = HomeTab;
    fn title(&mut self, tab: &mut Self::Tab) -> egui_dock::egui::WidgetText {
        format!("{:?}", &*tab).into()
    }
    fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
        match tab {
            HomeTab::Home => {
                tabs::school_page(ui);
            }
            HomeTab::Classes => {
                tabs::classes::classes_page(ui);
            }
            HomeTab::Teachers => {
                tabs::teachers::teachers_page(ui);
            }
            HomeTab::Classrooms => {
                tabs::classrooms::classrooms_page(ui);
            }
            HomeTab::Lectures => {
                tabs::lectures::lectures_page(ui);
            }
            HomeTab::Limitations => {
                tabs::limitations::limitations(ui);
            }
            HomeTab::Activities => {
                tabs::activities::activities_ui(ui);
            }
            HomeTab::Generate => {
                tabs::generate::generate_ui(ui);
            }
        };
    }
}
struct MyApp {
    tree: DockState<HomeTab>,
    page: Page,
}
impl Default for MyApp {
    fn default() -> Self {
        let tree = DockState::new(vec![
            HomeTab::Home,
            HomeTab::Classes,
            HomeTab::Teachers,
            HomeTab::Lectures,
            HomeTab::Classrooms,
            HomeTab::Limitations,
            HomeTab::Activities,
            HomeTab::Generate,
        ]);
        let page = Page::Home;
        // You can modify the tree before constructing the dock
        // let [a, b] =
        //     tree.main_surface_mut()
        //         .split_left(NodeIndex::root(), 0.3, vec!["tab3".to_owned()]);
        // let [_, _] = tree
        //     .main_surface_mut()
        //     .split_below(a, 0.7, vec!["tab4".to_owned()]);
        // let [_, _] = tree
        //     .main_surface_mut()
        //     .split_below(b, 0.5, vec!["tab5".to_owned()]);
        Self { tree, page }
    }
}
impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // ctx.set_theme(ThemePreference::Light);
        // let mut fonts = FontDefinitions::default();
        // // Install my own font (maybe supporting non-latin characters):
        // fonts.font_data.insert(
        //     "my_font".to_owned(),
        //     std::sync::Arc::new(
        //         // .ttf and .otf supported
        //         FontData::from_static(include_bytes!("./fonts/FreeSansBold.otf")),
        //     ),
        // );
        // fonts
        //     .families
        //     .get_mut(&egui::FontFamily::Proportional)
        //     .unwrap()
        //     .insert(0, "my_font".to_owned());
        // ctx.set_fonts(fonts);
        match self.page {
            Page::Home => {
                DockArea::new(&mut self.tree)
                    .show_leaf_close_all_buttons(false)
                    .style(Style::from_egui(ctx.style().as_ref()))
                    .show_close_buttons(false)
                    .show_add_popup(true)
                    .show(ctx, &mut HomeTab::Home);
            }
            _ => {}
        }
    }
}
// pub struct TemplateApp {
//     run_once: bool,
//     my_theme: StateMachine,
// }
// impl Default for TemplateApp {
//     fn default() -> Self {
//         Self {
//             run_once: false,
//             my_theme: egui_themes::StateMachine::new(),
//         }
//     }
// }

use std::{fs::write, path::PathBuf};
use eframe::egui::{Color32, Frame, Stroke};
pub fn a(f: &dyn AsRef<[u8]>, path: PathBuf) {
    write(path, f).expect("");
}
pub fn frame(active: bool) -> eframe::egui::Frame {
    let s_width = if active { 2. } else { 1. };
    let color = if active {
        Color32::BLUE
    } else {
        Color32::BLACK
    };
    let stroke = Stroke::new(s_width, color);
    Frame::none()
        .stroke(stroke)
        .inner_margin(10.)
        .outer_margin(10.)
        .rounding(1.0)
}

pub fn font_family() -> genpdf::fonts::FontFamily<genpdf::fonts::FontData> {
    let font_bold = include_bytes!("./fonts/FreeSansBold.ttf");
    let font_bold_data = genpdf::fonts::FontData::new(font_bold.to_vec(), None)
        .expect("font data should be correct");
    let font_bold_italic = include_bytes!("./fonts/FreeSansBoldOblique.ttf");
    let font_bold_italic_data = genpdf::fonts::FontData::new(font_bold_italic.to_vec(), None)
        .expect("font data should be correct");
    let font_regular = include_bytes!("./fonts/FreeSans.ttf");
    let font_regular_data = genpdf::fonts::FontData::new(font_regular.to_vec(), None)
        .expect("font data should be correct");
    let font_regular_italic = include_bytes!("./fonts/FreeSansOblique.ttf");
    let font_regular_italic_data = genpdf::fonts::FontData::new(font_regular_italic.to_vec(), None)
        .expect("font data should be correct");
    let font_family = genpdf::fonts::FontFamily {
        regular: font_regular_data,
        bold: font_bold_data,
        italic: font_regular_italic_data,
        bold_italic: font_bold_italic_data,
    };
    font_family
}

[package]
name = "Lapis"
version = "0.1.0"
edition = "2021"
[lib]
name = "mylib"
path = "src/lib.rs"
[[bin]]
name = "lapis"
path = "src/main.rs"
[dependencies]
eframe = { version = "0.30", features = [
    "default",
    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
] }
env_logger = { version = "0.10", default-features = false, features = [
    "auto-color",
    "humantime",
] }
egui_extras ={ version ="*"}
egui_dock = {git = "https://github.com/bryceberger/egui_dock", branch ="egui-0.30"}
egui_flex ="*"
rfd = "*"
serde = {version ="*", features=["derive"]}
serde_json = "*"
rand = "*"
egui = "0.30"
# egui = {git="https://github.com/emilk/egui", branch="master"}
# egui-themes = "0.1.0"
genpdf = "*"
opener = "*"
chrono = "*"