ladose-sncf/src/main.rs

extern crate sdl2;
mod smashquery;
mod smashrequest;


use sdl2::pixels::{Color, PixelFormatEnum};
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::Rect;
use sdl2::render::{Canvas, TextureQuery};
use smashrequest::SmashQueue;

use std::sync::{Arc, Mutex};
use std::time::Duration;
use std::fs;
use serde::Deserialize;


#[derive(Deserialize,Clone)]
struct Config {
   tournament: String,
   update: Option<u32>,
   fullscreen: Option<bool>,
   smash_key: String,

}

impl Config {
    fn new() -> Self {
        Self { tournament: String::new(), update: Some(1),fullscreen:Some(false), smash_key: String::new() }
    }
}


pub fn render(canvas : &mut Canvas<sdl2::video::Window> , queues : &Vec<smashrequest::SmashQueue>,font : &sdl2::ttf::Font<'_, '_> ){


    let texture_creator = canvas.texture_creator();
    let mut backline_text = texture_creator.create_texture_streaming(PixelFormatEnum::RGB24, 1, 1).map_err(|e| e.to_string()).unwrap();

    backline_text.with_lock(None, |buffer : &mut [u8], pitch: usize| {
        buffer[1] = 5;
        buffer[1] = 30;
        buffer[2] = 66;
    }).unwrap();

    let mut y : u32 = 0; 
    let mut index = 0;
    for sq in queues {


        let surface = font.render(sq.name.as_str()).blended(Color::RGBA(255, 255, 0, 255)).map_err(|e| e.to_string()).unwrap();
        let text = texture_creator.create_texture_from_surface(&surface).unwrap();
        let textq  : TextureQuery = text.query();
        let _ = canvas.copy(&text, None, Rect::new(0, y.try_into().map_err(|_| 0).unwrap(), textq.width, textq.height));

        y += textq.height+10;

        
        for current_match in &sq.matches {
            
            index += 1;
            let switch_col : bool = index%2 == 0;

            let var_name = format!("{} vs {}", &current_match.player1, current_match.player2);
            let surface = font.render(var_name.as_str()).blended(Color::RGBA(255, 255, 255, 255)).map_err(|e| e.to_string()).unwrap();
            let text = texture_creator.create_texture_from_surface(&surface).unwrap();
            let textq  : TextureQuery = text.query();

            if switch_col {
                let _ = canvas.copy(&backline_text, None, Rect::new(0, y.try_into().map_err(|_| 0).unwrap(), canvas.viewport().width(), textq.height));
            }


            let _ = canvas.copy(&text, None, Rect::new(0, y.try_into().map_err(|e| 0).unwrap(), textq.width, textq.height));
            y += textq.height + 5;
        }


    }
    
}


pub fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Read config");
    let config_file = fs::read_to_string("config.toml");

    let config : Config = if config_file.is_ok() {
        toml::from_str(&config_file.unwrap()).unwrap()
    } else {
        Config::new()
    };

    println!("{}",config.tournament);
    if config.tournament.is_empty(){
        println!("Empty Tournament , Exiting.");
        return Ok(());
    }
    
    let fullscreen = match config.fullscreen {
        Some(v) => v,
        None => false
    };

    println!("Fullscreen : {}",fullscreen);
    println!("Done");
    let test = Arc::new(Mutex::new(Vec::<SmashQueue>::new()));

    let sdl_context = sdl2::init().unwrap();
    let video_subsystem = sdl_context.video().unwrap();
    
    let mut build = video_subsystem.window("LaDOSE-SNCF", 1280, 720);
    if fullscreen {
        build.fullscreen();
    }
    else {
        build.position_centered();
    }
    let window = build
        .build()
        .unwrap();

    let mut canvas: Canvas<sdl2::video::Window> = window.into_canvas().build().unwrap();
    let ttf_context = sdl2::ttf::init().unwrap();
    let font : sdl2::ttf::Font<'_, '_> = ttf_context.load_font("font/achemine_bold.ttf", 30).unwrap();

    let stream_queues : Vec<smashrequest::SmashQueue>= smashrequest::get_matches(config.tournament.as_str(),config.smash_key.as_str());
    
    let timer = sdl_context.timer()?;
    




    let test_clone = Arc::clone(&test);

    let _timer_cb = &timer.add_timer(1,Box::new(move || {  
        println!("timer"); 
        let data = smashrequest::get_matches(config.tournament.as_str(), config.smash_key.as_str());
        println!("{:?}", data);
        let mut a = test_clone.lock().unwrap();
        if a.len()>1 {
             a.clear();
        }
        else{
            a.clone_from(&data);
        }
        println!("{:?}",a);
        return config.update.ok_or(10).unwrap()*1000; 
    })
    );
    
    
    canvas.set_draw_color(Color::RGB(0, 255, 255));
    canvas.clear();
    canvas.present();
    let mut event_pump = sdl_context.event_pump().unwrap();
    'running: loop {
        canvas.set_draw_color(Color::RGB(0,136,206));
        canvas.clear();
        let test_c = Arc::clone(&test);
        let a = test_c.lock().unwrap();
        render(&mut canvas,&a,&font);
        //render(&mut canvas,&stream_queues,&font);
        timer.ticks();
        for event in event_pump.poll_iter() {
            match event {
                Event::Quit {..} |
                Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
                    break 'running Ok(());
                },
                _ => {}
            }
        }
        // The rest of the game loop goes here...

        canvas.present();
        ::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
    }
}