extern crate num_traits;

use arrayvec::ArrayString;
use core::fmt::Write;
use embedded_graphics::{
    drawable::Drawable, fonts::Text, pixelcolor::Rgb565, prelude::*, primitive_style,
    primitives::rectangle::Rectangle, primitives::Line, style::PrimitiveStyle,
    style::PrimitiveStyleBuilder, style::TextStyleBuilder,
};
use embedded_hal::digital::v2::OutputPin;
use num_traits::float::FloatCore;
use rtt_target::rprintln;
use stm32f1xx_hal::{
    delay::Delay,
    gpio::{gpioa, gpiob, gpioc, Alternate, Floating, Input, Output, PushPull},
    pac,
    prelude::*,
    qei, rcc,
    spi::{Mode, Phase, Polarity, Spi, Spi1NoRemap},
    stm32,
    timer::{Tim3PartialRemap, Timer},
};

use crate::application::App;
use crate::profiles;

impl App {
    pub fn run_profile(&mut self) {
        let mut disp = self.get_display();

        let rect = Rectangle::new(Point::new(0, 0), Point::new(160, 128))
            .into_styled(self.styles.fill_black);
        rect.draw(&mut disp).unwrap();

        for x in (0..160).step_by(30) {
            Line::new(Point::new(x, 20), Point::new(x, 127))
                .into_styled(self.styles.grid)
                .draw(&mut disp)
                .unwrap();
        }

        for y in (0..110).step_by(10) {
            Line::new(Point::new(0, 127 - y), Point::new(159, 127 - y))
                .into_styled(self.styles.grid)
                .draw(&mut disp)
                .unwrap();
        }

        for t in 0..320 {
            let y = 148
                - (profiles::REFLOW_PROFILES[self.selected_profile].get_temp(t as f32) / 2.0)
                    as i32;
            Pixel(Point::new((t / 2) as i32, y), self.styles.profile_color)
                .draw(&mut disp)
                .unwrap();
        }

        self.release_display(disp);

        let preheat_target = profiles::REFLOW_PROFILES[self.selected_profile].get_temp(0.0);

        let mut target_buf = ArrayString::<[_; 10]>::new();
        // Output `xxx.xx`
        write!(&mut target_buf, "{:.2}", preheat_target).expect("Failed to write to buffer");

        let mut preheat_ok_count = 0;
        let mut last_temp = 0.0;
        let mut overshoot = 0.0;

        while preheat_ok_count < 10 {
            let temp = self.read_temperature();
            if last_temp == 0.0 {
                last_temp = temp;
            }

            let delta = temp - last_temp;

            rprintln!("temp: {} delta: {}, overshoot: {}", temp, delta, overshoot,);

            if overshoot < 0.0 {
                overshoot = 0.0;
            }

            if temp >= preheat_target || temp + delta + overshoot >= preheat_target {
                self.heater.set_low().unwrap();
                overshoot -= 0.5;
            } else {
                self.heater.set_high().unwrap();
                overshoot += 5.0;
            }

            if temp > preheat_target - 1.0 && temp < preheat_target + 1.0 {
                preheat_ok_count += 1;
            } else {
                preheat_ok_count = 0;
            }

            last_temp = temp;

            let mut temp_buf = ArrayString::<[_; 10]>::new();
            // Output `xxx.xx`
            write!(&mut temp_buf, "{:.2}", temp).expect("Failed to write to buffer");

            let mut disp = self.get_display();
            let rect = Rectangle::new(Point::new(0, 0), Point::new(160, 10))
                .into_styled(self.styles.fill_black);
            rect.draw(&mut disp).unwrap();

            Text::new(&temp_buf, Point::new(8, 0))
                .into_styled(self.styles.text_red)
                .draw(&mut disp)
                .unwrap();

            Text::new(&target_buf, Point::new(80, 0))
                .into_styled(self.styles.text_green)
                .draw(&mut disp)
                .unwrap();

            self.release_display(disp);

            self.delay.delay_ms(250u32);
        }
        self.heater.set_low().ok();

        let mut time = 0.0;
        let mut last_temp = 0.0;
        let period = 0.25;

        loop {
            let target_temp = profiles::REFLOW_PROFILES[self.selected_profile].get_temp(time);
            let future_temp =
                profiles::REFLOW_PROFILES[self.selected_profile].get_temp(time + period);
            let temp = self.read_temperature();
            if last_temp == 0.0 {
                last_temp = temp;
            }

            let delta = temp - last_temp;

            rprintln!(
                "temp: {} delta: {}, overshoot: {}, future_temp: {}",
                temp,
                delta,
                overshoot,
                future_temp
            );

            if overshoot < 0.0 {
                overshoot = 0.0;
            }

            if temp >= target_temp || temp + delta + overshoot >= future_temp {
                self.heater.set_low().unwrap();
                overshoot -= 0.5;
            } else {
                self.heater.set_high().unwrap();
                overshoot += 2.0;
            }

            last_temp = temp;

            let mut target_buf = ArrayString::<[_; 10]>::new();
            // Output `xxx.xx`
            write!(&mut target_buf, "{:.2}", target_temp).expect("Failed to write to buffer");

            let mut temp_buf = ArrayString::<[_; 10]>::new();
            // Output `xxx.xx`
            write!(&mut temp_buf, "{:.2}", temp).expect("Failed to write to buffer");

            let mut disp = self.get_display();
            let rect = Rectangle::new(Point::new(0, 0), Point::new(160, 10))
                .into_styled(self.styles.fill_black);
            rect.draw(&mut disp).unwrap();

            Text::new(&temp_buf, Point::new(8, 0))
                .into_styled(self.styles.text_red)
                .draw(&mut disp)
                .unwrap();

            Text::new(&target_buf, Point::new(80, 0))
                .into_styled(self.styles.text_green)
                .draw(&mut disp)
                .unwrap();

            if time <= 320.0 {
                let y = 148 - (temp / 2.0) as i32;
                Pixel(Point::new((time / 2.0) as i32, y), self.styles.temp_color)
                    .draw(&mut disp)
                    .unwrap();
            }

            self.release_display(disp);

            time += period;
            self.delay.delay_ms(250u32);
        }
    }
}