extern crate sdl2;

mod font;
pub mod generated;

use font::BakedFont;
use generated::fonts::{FONT_CHERRY_BOMB_ONE, FONT_GALMURI};
use rand::Rng;
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;

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
  // TODO: do not bind to framerate u silly bean
  let sin_speed = 0.003;
  let mut sin_offset = 0.5;
  'running: loop {
    i = (i + 1) % 255;

    if sin_offset > 1.0 {
      sin_offset -= 1.0;
    }

    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;
    }

    offset = 0.0;
    let mut rng = rand::thread_rng();

    for c in "sorry for shit demo we have adhd".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 + rng.gen_range(-2..2),
            16 + 36 * 2 + rng.gen_range(-2..2),
          ),
        )
        .unwrap();
      offset += char.advance_width / 1.0;
    }

    {
      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) + (sin_offset * 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 {
            if idx % 5 == 0 {
              255
            } else {
              122
            }
          } else {
            0
          };
        }
      }
      sin_offset += sin_speed;

      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,
        _ => {}
      }
    }
    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 / 120));
  }
}