use core::net::SocketAddrV4;
use core::str::FromStr;

use embassy_futures::join::join;
use embassy_net::tcp::TcpSocket;
use embassy_time::Duration;
use esp_hal::peripherals::WIFI;
use esp_hal::rng::Rng;
use esp_println::println;
use esp_radio::wifi::{scan::ScanConfig, Config, ControllerConfig};
use esp_radio::wifi::sta::StationConfig;

use crate::{buffer::wait_for_config, tcp_read_loop, tcp_write_loop};

pub struct NetworkConfig<'a> {
    pub wifi: WIFI<'a>,
    pub wifi_network: &'a str,
    pub wifi_password: &'a str,
    pub target_ip: &'a str,
    pub target_port: u16,
}

#[embassy_executor::task]
async fn net_task(mut runner: embassy_net::Runner<'static, esp_radio::wifi::Interface<'static>>) -> ! {
    runner.run().await
}

#[embassy_executor::task]
pub async fn network_setup_task(spawner: embassy_executor::Spawner, config: NetworkConfig<'static>) {
    let wifi_config = Config::Station(
        StationConfig::default()
            .with_ssid(config.wifi_network)
            .with_password(config.wifi_password.into()),
    );

    println!("Starting wifi");
    let (mut controller, interfaces) = esp_radio::wifi::new(
        config.wifi,
        ControllerConfig::default().with_initial_config(wifi_config),
    )
    .unwrap();
    println!("Wifi configured and started!");

    let wifi_interface = interfaces.station;
    let net_config = embassy_net::Config::dhcpv4(Default::default());
    let rng = Rng::new();
    let seed = (rng.random() as u64) << 32 | rng.random() as u64;

    let (stack, runner) = embassy_net::new(
        wifi_interface,
        net_config,
        crate::screen::stack_resources(),
        seed,
    );
    spawner.spawn(net_task(runner).expect("spawn net task"));

    println!("Scan");
    let scan_config = ScanConfig::default().with_max(10);
    let result = controller.scan_async(&scan_config).await.unwrap();
    for ap in result {
        println!("{:?}", ap);
    }

    stack.wait_config_up().await;
    let cfg = wait_for_config(stack).await;
    let local_addr = cfg.address.address();
    println!("IP address: {:?}", local_addr);

    let host_addr = embassy_net::Ipv4Address::from_str(config.target_ip).unwrap();
    let mut rx_buffer = [0; 4096];
    let mut tx_buffer = [0; 4096];
    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
    socket.set_timeout(Some(Duration::from_secs(10)));
    socket.set_keep_alive(Some(Duration::from_secs(1)));
    if let Err(e) = socket.connect(SocketAddrV4::new(host_addr, config.target_port)).await {
        println!("tcp connect error: {:?}", e);
    }

    let (read, write) = socket.split();
    join(tcp_read_loop(read), tcp_write_loop(write)).await;
}