extern crate sdl2;

mod font;
pub mod generated;

use font::BakedFont;
use generated::fonts::{FONT_CHERRY_BOMB_ONE, FONT_GALMURI};
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::pixels::{Color, PixelFormatEnum};
use sdl2::rect::Rect;
use sdl2::render::Texture;
use sdl2::surface::Surface;
use std::ops::DerefMut;
use std::time::{Duration, SystemTime};

pub fn main() {
  let sdl_context = sdl2::init().unwrap();
  let video_subsystem = sdl_context.video().unwrap();

  let window = &mut video_subsystem
    .window("Cosin25 Invite", 512, 256)
    .position_centered()
    .build()
    .unwrap();

  let mut canvas = window.clone().into_canvas().build().unwrap();
  let texture_creator = canvas.texture_creator();
  // let uwu_font = font::UwUFont::new(&texture_creator);
  canvas.clear();
  canvas.present();
  let mut event_pump = sdl_context.event_pump().unwrap();
  let mut i = 0;

  // amount to incr sin_offset by per frame
  let start_time = SystemTime::now();
  let movement_per_second = 0.5;
  'running: loop {
    let time = SystemTime::now()
      .duration_since(start_time)
      .expect("Time went back between frames");
    let time = f64::from(time.as_millis() as u32) / 1000.0;
    i = (i + 1) % 255;

    canvas.set_draw_color(Color::RGB(12, 12, 12));
    canvas.clear();

    let mut offset: f32 = 0.0;
    for c in "UwU-Space".chars() {
      let char = FONT_CHERRY_BOMB_ONE.get_char(c);
      canvas
        .copy(
          &char
            .to_texture(&texture_creator, Color::RGB(i, 64, 255 - i))
            .unwrap(),
          None,
          char.to_rect(offset as i32 + 16, 16),
        )
        .unwrap();
      offset += char.advance_width;
    }

    {
      let mut sin_surface = Surface::new(512, 256, PixelFormatEnum::RGBA32).unwrap();

      let w = sin_surface.width();
      let h = sin_surface.height();
      let f = &mut sin_surface.deref_mut().without_lock_mut().unwrap();

      for x in 0..w {
        let f64_w = f64::from(w);
        let f64_h = f64::from(h);
        let sin_x = {
          let mut sin_x = f64::from(x) + ((time * movement_per_second) * f64_w);
          if sin_x > f64_w {
            sin_x = sin_x - f64_w;
          }
          sin_x
        };
        let sin_y =
          ((f64::sin(sin_x * (3.141 * 2.0) / f64_w) + 1.0) * (f64_h / 2.0)).floor() as usize;
        // let sin_idx = (sin_y * w as usize + x as usize) * 4;

        for y in 0..h {
          let idx = (y * w + x) as usize * 4;
          f[idx] = 122 - (x / 8) as u8;
          f[idx + 1] = 255 - (x / 2) as u8;
          f[idx + 2] = (x / 2) as u8;
          f[idx + 3] = if sin_y < y as usize { 255 } else { 0 };
        }
      }

      let sin_texture = Texture::from_surface(&sin_surface, &texture_creator).unwrap();

      canvas
        .copy(&sin_texture, None, Rect::new(0, 0, 512, 256))
        .unwrap();
    }
    offset = 0.0;
    for c in "Come to Cosin25 :3".chars() {
      let char = FONT_GALMURI.get_char(c);
      canvas
        .copy(
          &char
            .to_texture(&texture_creator, Color::RGB(i, 64, 255 - i))
            .unwrap(),
          None,
          char.to_rect(offset as i32 + 18, 16 + 36),
        )
        .unwrap();
      offset += char.advance_width;
    }
    for event in event_pump.poll_iter() {
      match event {
        Event::Quit { .. }
        | Event::KeyDown {
          keycode: Some(Keycode::Escape),
          ..
        } => break 'running,
        _ => {}
      }
    }
    // The rest of the game loop goes here...
    canvas.present();
    ::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 12000));
  }
}