#[allow(dead_code)]

use std::{
    fs::OpenOptions,
    fs::File,
    io::{prelude::*, BufReader},
    path::Path,
    thread::{self},
};
use rfd::FileDialog;
use text_io::read;
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::Arc;

fn load(filename: impl AsRef<Path>) -> Vec<String> {
    let file = File::open(filename)
        .expect("error");
    let buffer = BufReader::new(file);
    buffer.lines()
        .map(|l| l.expect("error"))
        .collect()
}

fn write(filename: impl AsRef<Path>, mut t_write: String) {
    let mut file = OpenOptions::new()
        .append(true)
        .open(filename)
        .expect("error");
    t_write.push_str("\n");
    file.write_all(t_write
        .as_bytes())
        .unwrap();
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {

    let file = FileDialog::new()
        .add_filter("text", &["txt"])
        .set_directory(".")
        .pick_file();
    let url = load(file.unwrap());
    println!("{}", url.len());
    let threads: i16 = read!("{}\n");
    println!("Splitting URLs...");
    let mut values = url
        .into_iter()
        .peekable();
    let mut chunks = Vec::new();
    while values.peek().is_some() {
        let chunk: Vec<_> = values
            .by_ref()
            .take(threads as usize)
            .collect();
        chunks.push(chunk);
    }
    let mut handles = Vec::new();
    println!("Done.");
    let checked = Arc::new(AtomicU32::new(1));
    let valid = Arc::new(AtomicU32::new(1));
    let invalid = Arc::new(AtomicU32::new(1));
    // println!("{:?}", chunks);
    for chunk in chunks {
        let handle = thread::spawn({
                let c_clone = Arc::clone(&checked);
                let v_clone = Arc::clone(&valid);
                let i_clone = Arc::clone(&invalid);
                move ||
            for x in chunk {
                print! ("\x1B[2J\x1B[1;1H");
                let resp = reqwest
                    ::blocking
                    ::get(x.as_str());
                let _resp_r = match resp {
                    Ok(_ok) => {
                        c_clone.fetch_add(1, Ordering::SeqCst);
                        v_clone.fetch_add(1, Ordering::SeqCst);
                        write("valid.txt".to_string(), x);
                        println!("{} | Valid: {} | Invalid: {}",
                            c_clone.load(Ordering::SeqCst),
                            v_clone.load(Ordering::SeqCst),
                            i_clone.load(Ordering::SeqCst));}
                    Err(_error) => {
                        c_clone.fetch_add(1, Ordering::SeqCst);
                        i_clone.fetch_add(1, Ordering::SeqCst);
                        write("invalid.txt".to_string(), x);
                        println!("{} | Valid: {} | Invalid: {}",
                            c_clone.load(Ordering::SeqCst),
                            v_clone.load(Ordering::SeqCst),
                            i_clone.load(Ordering::SeqCst));}
                };
            }
        });

        handles.push(handle);

    }
    for x in handles {
        x.join().unwrap();
    }
    Ok(())
}