use std::fs::{File, create_dir_all};
use std::io::Write;
use std::env;
use std::error::Error;
use std::ops::Drop;
use std::path::Path;
use std::process::Command;

use notify_rust::{Notification, Timeout, Urgency};
use reqwest::blocking::Client;
use serde::{Deserialize, Serialize};
use serde_json;

#[derive(Deserialize)]
pub struct AnityaResponse {
    items: Vec<AnityaProject>,
}

#[derive(Deserialize, Serialize, Clone)]
pub struct AnityaProject {
    name: String,
    version: String
}

pub struct Config {
    pub config: Vec<AnityaProject>,
    path: String,
}

impl Config {
    pub fn new() -> Result<Config, Box<dyn Error>> {
        let path = format!("{}/.config/aytina.json", env!("HOME"));
        let config_path = Path::new(&path);

        if !config_path.is_file() {
            File::create(&config_path)?;
        }

        let config_file = File::open(&config_path)?;
        let config = serde_json::from_reader(&config_file)?;

        Ok(Config {
            config: config,
            path: path,
        })
    }

    pub fn add(&mut self, name: &[&str]) -> Result<(), Box<dyn Error>> {
        let client = Client::new();

        for n in name {
            let response: AnityaResponse = client.get(&format!(
                "https://release-monitoring.org/api/v2/projects/?name={}", n))
                .send()?.json()?;

            if response.items.len() == 0 {
                println!("No project named {} was found.", n);
                continue
            }

            self.config.push(response.items[0].clone());
            println!("Project {} has been added.", n);
        }
        Ok(())
    }

    pub fn remove(&mut self, name: &[&str]) -> Result<(), Box<dyn Error>> {
        self.config = self.config.iter()
            .filter_map(|x| {
                if name.contains(&x.name.as_str()) {
                    println!("The project {} has been removed.", x.name);
                    return None;
                }

                Some(x.clone())
            })
            .collect();
        Ok(())
    }
}

impl Drop for Config {
    fn drop(&mut self) {
        let config_path = Path::new(&self.path);
        let config_file = File::create(&config_path).unwrap();
        serde_json::to_writer_pretty(config_file, &self.config).unwrap();
    }
}

pub fn check(do_notify: bool) -> Result<(), Box<dyn Error>> {
    let mut config = Config::new()?;

    let client = Client::new();

    for p in &mut config.config {
        let response: AnityaResponse = client.get(&format!(
            "https://release-monitoring.org/api/v2/projects/?name={}", p.name))
            .send()?.json()?;

        if p.version != response.items[0].version {
            if do_notify {
                notify(&response.items[0])?;
            } else {
                println!("{} {} was released (OLD: {})",
                    response.items[0].name,
                    response.items[0].version,
                    p.version);
            }

            p.version = response.items[0].version.clone();
        }
    }

    Ok(())
}

pub fn notify(project: &AnityaProject) -> Result<(), Box<dyn Error>> {
    Notification::new()
        .appname("Aytina: A software had a new release")
        .summary(&format!("New release: {}", &project.name))
        .body(&format!("{} {} was released", &project.name, &project.version))
        .icon("software-update-available-symbolic")
        .urgency(Urgency::Critical)
        .timeout(Timeout::Never)
        .show()?;
 
    Ok(())
}

pub fn autocheck(time: &str) -> Result<(), Box<dyn Error>> {
    match time {
        "never" => {
            Command::new("systemctl")
                .args(&["disable", "--user", "--now", "aytina.timer"])
                .output()?;
            println!("Automatic release checking disabled.");
            return Ok(());
        },
        _ => {
            let len = time.len();
            match time[0..len - 1].parse::<usize>() {
                Err(_) => {
                    println!("Incorrect TIME value.");
                    return Ok(());
                },
                _ => {}
            }
        }
    };

    let exec_path = env::current_exe()?;
    let exec_path = Path::new(&exec_path);
    let unit_path = format!("{}/.local/share/systemd/user/", env!("HOME"));
    let unit_path = Path::new(&unit_path);

    if !unit_path.is_dir() {
        create_dir_all(unit_path)?;
    }

    let serv_path = unit_path.join("aytina.service");
    let serv_content = format!(
"[Unit]
Description=Automatic checking service for Aytina

[Service]
Type=simple
ExecStart={} check --notify
", exec_path.to_str().unwrap()
    );

    File::create(&serv_path)?.write_all(serv_content.as_bytes())?;

    let timer_path = unit_path.join("aytina.timer");

    let timer_content = format!(
"[Unit]
Description=The timer for the Aytina autochecker

[Timer]
OnBootSec=15min
OnUnitActiveSec={}

[Install]
WantedBy=timers.target
", time
    );

    File::create(&timer_path)?.write_all(timer_content.as_bytes())?;

    Command::new("systemctl")
        .args(&["enable", "--user", "--now", "aytina.timer"])
        .output()?;
    println!("Automatic release checking enabled.");

    Ok(())
}