use std::env;
use std::error::Error;
use std::fs::{create_dir_all, File, OpenOptions};
use std::io::{stdout, BufReader, Write};
use std::path::Path;
use std::process::exit;

use clap::{App, Arg};
use crossterm::{cursor, QueueableCommand};
use curl::easy::{Easy, WriteError};
use serde_json::from_reader;
use url::Url;

use lazy_static::lazy_static;

use crate::config::ConfigManager;
use crate::state::{State, StateManager};

const VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION");

lazy_static! {
    static ref COMMANDS: Vec<&'static str> = vec!["download", "favorites", "print", "searches"];
}
mod config;
mod model;
mod state;

fn read_animeboxes_backup<P: AsRef<Path>>(
    path: P,
) -> Result<model::anime_boxes::Backup, Box<dyn Error>> {
    let file = File::open(path)?;
    let reader = BufReader::new(file);
    let result: model::anime_boxes::Backup = from_reader(reader)?;
    Ok(result)
}

fn write_to_file(data: &[u8], path: &Path) -> std::io::Result<usize> {
    if !path.exists() {
        let mut file = File::create(path)?;
        file.write_all(data)?;
    } else {
        let mut file = OpenOptions::new().append(true).open(path)?;
        file.write_all(data)?;
    }
    Ok(data.len())
}

fn curl_write_to_file_function(data: &[u8], path: &Path) -> Result<usize, WriteError> {
    match write_to_file(data, &path) {
        Err(e) => {
            println!("Error writing to {:#?}: {}", &path, e);
            Err(WriteError::Pause)
        }
        Ok(d) => Ok(d),
    }
}

fn calculate_percentage(numerator: f64, denominator: f64) -> f64 {
    if numerator <= 0.0 {
        0.0
    } else {
        (numerator / denominator) * 100.0
    }
}

fn print_progress(data: &[u8]) -> Result<(), Box<dyn Error>> {
    let mut stdout = stdout();
    stdout.queue(cursor::SavePosition)?;
    stdout.write(data)?;
    stdout.queue(cursor::RestorePosition)?;
    stdout.flush()?;
    Ok(())
}

fn download_command(
    backup: model::anime_boxes::Backup,
    config_manager: config::ConfigManager,
    mut state_manager: state::StateManager,
) {
    let temp_directory = env::current_dir().unwrap().join(
        config_manager
            .config
            .save_directory
            .as_ref()
            .unwrap_or(&String::from("tmp")),
    );
    match create_dir_all(&temp_directory) {
        Err(e) => println!("Failed to create directory {:#?}: {}", &temp_directory, e),
        Ok(_) => (),
    };
    let favorites: Vec<String> = backup
        .favorites
        .iter()
        .map(|f| String::from(&f.file.url))
        .collect();
    let mut favorites_to_download: Vec<String> = Vec::new();
    for favorite in favorites {
        if !state_manager.state.downloaded.contains(&favorite) {
            favorites_to_download.push(favorite);
        }
    }
    let to_download_count = favorites_to_download.len();
    let mut count = 0;
    let mut favorites_downloaded = Vec::new();
    for favorite in favorites_to_download {
        count += 1;
        let mut easy = Easy::new();
        let favorite_url = Url::parse(&favorite);
        match favorite_url {
            Err(e) => {
                println!("Error downloading {}. Not a valid URL. {}", favorite, e);
                continue;
            }
            Ok(url) => {
                let path_segments = url.path_segments().unwrap();
                let filename = path_segments.last().unwrap();
                let target_path = temp_directory.as_path().join(&filename);

                let progress_count = format!("{:}/{:}", count, to_download_count);
                let progress_filename = String::from(filename);

                match easy.url(url.as_str()) {
                    Err(e) => println!("Error setting download URL {}: {}", &filename, e),
                    Ok(_) => (),
                };
                match easy.progress(true) {
                    Err(e) => println!("Error setting progress setting: {}", e),
                    Ok(_) => (),
                };
                let mut progress_length: usize = 0;
                match easy.progress_function(
                    move |total_bytes_to_download,
                          bytes_downloaded,
                          _total_bytes_to_upload,
                          _bytes_uploaded| {
                        let percentage =
                            calculate_percentage(bytes_downloaded, total_bytes_to_download);
                        let mut progress = format!(
                            "{}: {:.2}% {}",
                            progress_filename, percentage, &progress_count
                        );
                        progress_length = if progress.len() > progress_length {
                            progress.len()
                        } else {
                            progress_length
                        };
                        if progress_length > progress.len() {
                            progress = format!(
                                "{}{}",
                                progress,
                                " ".repeat(progress_length - progress.len())
                            );
                        }
                        match print_progress(progress.as_bytes()) {
                            Err(e) => println!("Error showing downloading progress: {}", e),
                            Ok(_) => (),
                        };
                        true
                    },
                ) {
                    Err(e) => println!("Error showing downloading progress: {}", e),
                    Ok(_) => (),
                };
                match easy
                    .write_function(move |data| curl_write_to_file_function(data, &target_path))
                {
                    Err(e) => println!("Error downloading {}: {}", &favorite, e),
                    Ok(_) => favorites_downloaded.push(String::from(&favorite)),
                }
                easy.perform().unwrap();
            }
        }
    }
    let favorites_downloaded_count = favorites_downloaded.len();
    let mut all_downloaded: Vec<String> = Vec::new();
    for downloaded in &state_manager.state.downloaded {
        all_downloaded.push(String::from(downloaded));
    }
    for downloaded in favorites_downloaded {
        println!("{}", downloaded);
        all_downloaded.push(downloaded);
    }
    let all_downloaded_count = all_downloaded.len();
    let new_state = State {
        downloaded: all_downloaded,
    };
    state_manager.save(new_state);
    println!(
        "Downloaded {:#?}/{:#?} images",
        favorites_downloaded_count, to_download_count
    );
    println!("Total Downloaded: {:#?}", all_downloaded_count);
}

fn favorites_command(backup: model::anime_boxes::Backup) {
    let favorites: Vec<String> = backup
        .favorites
        .iter()
        .map(|f| String::from(&f.file.url))
        .collect();
    for favorite in favorites {
        println!("{}", favorite);
    }
}

fn searches_command(backup: model::anime_boxes::Backup) {
    let mut searches: Vec<String> = backup
        .search_history
        .iter()
        .map(|s| String::from(&s.search_text))
        .collect();
    searches.sort();
    for search in searches {
        println!("{}", search);
    }
}

fn main() {
    let matches = App::new("AnimeBoxes Sync")
        .version(VERSION.unwrap_or("UNKNOWN"))
        .author("Drew Short <warrick@sothr.com>")
        .about("Parses AnimeBoxes backup files")
        .arg(
            Arg::with_name("config")
                .short("c")
                .value_name("FILE")
                .help("Set a custom config file")
                .takes_value(true),
        )
        .arg(
            Arg::with_name("INPUT")
                .help("The AnimeBoxes file to process")
                .required(true)
                .index(1),
        )
        .arg(
            Arg::with_name("COMMAND")
                .help("The command to run on the backup")
                .required(true)
                .index(2)
                .possible_values(&COMMANDS),
        )
        .get_matches();

    let config = matches.value_of("config").unwrap_or("config.json");
    let config_path = env::current_dir().unwrap().join(config);
    let config_manager = ConfigManager::new(config_path.as_path());

    let state_path = env::current_dir().unwrap().join("state.json");
    let state_manager = StateManager::new(state_path.as_path());

    let path = matches.value_of("INPUT").unwrap();
    let result = read_animeboxes_backup(path).unwrap();

    let command = matches.value_of("COMMAND").unwrap();
    match command {
        "download" => download_command(result, config_manager, state_manager),
        "favorites" => favorites_command(result),
        "print" => println!("{:#?}", result),
        "searches" => searches_command(result),
        _ => {
            println!("{} is unrecognized", command);
            exit(1)
        }
    }
}