#![warn(clippy::pedantic)]

use std::{
    f32::consts::FRAC_PI_2,
    io::stdout,
    net::{Ipv4Addr, SocketAddr, UdpSocket},
    thread::sleep,
    time::Duration,
};

use clap::Parser;
use image::{Pixel, Rgb, RgbImage};
use rand::Rng;

use splink_client::{Layout, send_frame};

/// Blinkenwall v3 prototype client
#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Args {
    /// Timeout in ms for frame completion responses (0 to disable)
    #[clap(long, default_value_t = 3)]
    response_timeout: u64,

    /// Local address and port to bind to
    #[clap(long = "bind")]
    bind_addr: Option<SocketAddr>,

    /// Controller's address
    remote_addr: SocketAddr,
}


fn get_frame(layout: Layout, frame: u32) -> RgbImage {
    #![allow(
        clippy::cast_precision_loss,
        clippy::cast_lossless,
        clippy::cast_possible_truncation,
        clippy::cast_sign_loss
    )]

    let w = layout.width_px();
    let h = layout.height_px();

    let frame = frame % 60;
    let frame = frame as f32 / 3.0;

    RgbImage::from_fn(w, h, |x, y| {
        let dist_from_center = {
            let x = x as f32;
            let y = y as f32;

            let center_x = w as f32 / 2.0;
            let center_y = h as f32 / 2.0;

            ((x - center_x).powf(2.0) + (y - center_y).powf(2.0)).sqrt()
        };

        let radius = frame.powf(1.8);

        let dist_from_radius = dist_from_center - radius;
        let dist = 0.3 * dist_from_radius;

        Rgb([100, 0, 100]).map(|x| {
            (if dist < 0.0 {
                (1.0 - (dist.abs() / 10.0)).max(0.0)
            } else {
                dist.min(FRAC_PI_2).cos()
            } * x as f32) as u8
        })
    })
}

fn print_image(image: &RgbImage) {
    let _hide = termion::cursor::HideCursor::from(stdout());

    print!("{}", termion::cursor::Goto(1, 1));
    for row in image.rows() {
        for &Rgb([r, g, b]) in row {
            print!("{}  ", termion::color::Rgb(r, g, b).bg_string());
        }
        println!("{}", termion::color::Reset.bg_str());
    }
}

fn main() -> anyhow::Result<()> {
    let args = Args::parse();

    let bind_addr = args
        .bind_addr
        .unwrap_or_else(|| (Ipv4Addr::UNSPECIFIED, 0).into());
    let socket = UdpSocket::bind(bind_addr)?;

    socket.connect(args.remote_addr)?;
    socket.set_read_timeout(match args.response_timeout {
        0 => None,
        t => Some(Duration::from_millis(t)),
    })?;

    let layout = Layout {
        gang_len: 8,
        num_gangs: 32,

        num_panels_h: 6,
        num_panels_v: 1,
    };

    for frame in 0.. {
        let image = get_frame(layout, frame);

        print_image(&image);

        let frame_num: u32 = rand::thread_rng().gen();
        send_frame(&socket, layout, frame_num, &image)?;

        sleep(Duration::from_millis(16));
    }

    let image = RgbImage::from_fn(96, 64, |_x, y| {
        [Rgb([0, 3, 1]), Rgb([1, 3, 0]), Rgb([3, 0, 1])][y as usize % 3]
    });

    Ok(())
}