#[macro_use]
extern crate conrod;
extern crate find_folder;

use conrod::{widget, color, Colorable, Borderable, Sizeable, Positionable, Labelable, Widget};
use conrod::backend::glium::glium;
use conrod::backend::glium::glium::{DisplayBuild, Surface};

// 사용하는 id 리스트
widget_ids!(
    struct Ids {
        canvas,
        num_lbl,
        button,
    });

fn main() {
  // 설정 값
    const TITLE: &'static str = "카운트 업";
    let width = 400;
    let height = 300;

    // window 만들기
    let display = glium::glutin::WindowBuilder::new()
        .with_dimensions(width, height)
        .with_title(TITLE)
        .build_glium()  // window 구축
        .unwrap();

    // Ui 작성
    let mut ui = conrod::UiBuilder::new([width as f64, height as f64]).build();

    // Ui에서 사용하는 Font를 assets 아래의 파일에서 font::Map에 추가
    let assets = find_folder::Search::KidsThenParents(3, 5)
        .for_folder("assets")
        .unwrap();
    let font_path = assets.join("fonts/NotoSans/NotoSans-Regular.ttf");
    ui.fonts.insert_from_file(font_path).unwrap();

    // id를 관리하기 위해 관리자 작성
    let ids = &mut Ids::new(ui.widget_id_generator());

    // glium으로 렌더링 하기위해 renderer 준비
    let mut renderer = conrod::backend::glium::Renderer::new(&display).unwrap();

    // The widget과 image를 연결 시켜서 관리하는 mapping
    let image_map = conrod::image::Map::<glium::texture::Texture2d>::new();


    let mut num = "0".to_string();

    let mut event_loop = EventLoop::new();
    // window 이벤트 루프
    'main: loop {
        for event in event_loop.next(&display) {
            // window 이벤트의 핸들러를 ui에 세트시킨다
            if let Some(event) = conrod::backend::winit::convert(event.clone(), &display) {
                ui.handle_event(event);
                event_loop.needs_update();
            }

            match event {
                // Escape는 window 삭제 용으로
                glium::glutin::Event::KeyboardInput(
                    _,
                    _,
                    Some(glium::glutin::VirtualKeyCode::Escape),
                ) |
                glium::glutin::Event::Closed => break 'main,
                _ => {}
            }
        }


        set_widgets(ui.set_widgets(), ids, &mut num);

        // Ui 렌더와 표시
        if let Some(primitives) = ui.draw_if_changed() {
            renderer.fill(&display, primitives, &image_map);
            let mut target = display.draw();
            target.clear_color(0.0, 0.0, 0.0, 1.0);
            renderer.draw(&display, &mut target, &image_map).unwrap();
            target.finish().unwrap();
        }
    }
}

// 배치하는 widget 배치 방법 지정 함수
fn set_widgets(ref mut ui: conrod::UiCell, ids: &mut Ids, num: &mut String) {
  // 배경(canvas)
    widget::Canvas::new()
        .pad(0.0)
        .color(conrod::color::rgb(0.2, 0.35, 0.45))
        .set(ids.canvas, ui);

    // canvas의 id를 사용하여  지정하는 것으로 ui에서 canvas의 종과 횡 배열을 얻는다
    let canvas_wh = ui.wh_of(ids.canvas).unwrap();


    // 수치 표시
    widget::Text::new(num)
        .middle_of(ids.canvas)
        .font_size(140)  // 폰트 사이즈 지정！！
        .color(color::WHITE)  // 색 지정도 간단하게 할 수 있다
        .set(ids.num_lbl, ui);

    // 카운트 버튼
    if widget::Button::new()
        .w_h(canvas_wh[0] - 10.0, 40.0)  // 횡
        .mid_bottom_with_margin_on(ids.canvas, 5.0)// 위치
        .rgb(0.4, 0.75, 0.6)  // 색
        .border(2.0)  // 경계
        .label("count +1")
        .set(ids.button, ui)
        .was_clicked()
    {  // if 식 실행 부분
        if let Ok(count) = num.parse::<u32>() {
            *num = (count+1).to_string();
        } else {
            println!("invalid number");
        }
    }

}

// 이벤트 관리용 구조체
struct EventLoop {
    ui_needs_update: bool,
    last_update: std::time::Instant,
}

impl EventLoop {
    pub fn new() -> Self {
        EventLoop {
            last_update: std::time::Instant::now(),
            ui_needs_update: true,
        }
    }

    /// 모든 갱신 대상이 되는 이벤트를 위한 순차 취득용 함수
    pub fn next(&mut self, display: &glium::Display) -> Vec<glium::glutin::Event> {
        // 60FPS 보다 빠르게 되지 않게 하기 위해 바로 앞의 갱신 대상에서 적어도 16ms 기다리도록 한다
        let last_update = self.last_update;
        let sixteen_ms = std::time::Duration::from_millis(16);
        let duration_since_last_update = std::time::Instant::now().duration_since(last_update);  // 전 회의 갱신 시와 지금 시간 차를 취득
        if duration_since_last_update < sixteen_ms {
            std::thread::sleep(sixteen_ms - duration_since_last_update);
        }

        // 이벤트 전체 취득
        let mut events = Vec::new();
        events.extend(display.poll_events());  // display에 있어서 이벤트 취득

        // display에서 갱신이 있으면 Ui에서 이벤트 갱신은 다음 대기를 넘는다
        if events.is_empty() && !self.ui_needs_update {
            events.extend(display.wait_events().next());
        }

        // 이벤트 갱신 후의 처리
        self.ui_needs_update = false;
        self.last_update = std::time::Instant::now();

        events
    }

    // Ui에서 다른 이벤트 갱신이 있는지 없는지를 요구하는 것을 event 루프에서는 확인해 둔다

    // 이것은 몇개의 Ui를 렌더링 하는 최초의 타이밍이나 갱신을 요구하는 타이밍에서 사용된다.
    pub fn needs_update(&mut self) {
        self.ui_needs_update = true;
    }
}

widget_ids!(
    struct Ids {
        canvas,
        num_lbl,
        button,
    });