use bollard::{Docker, query_parameters::{ListContainersOptionsBuilder, StopContainerOptionsBuilder}};
use chrono::{TimeDelta, Utc};

use crate::{ DbPool, dockermgr, models::{self, Servers}, schema, status::ServerStatus };

use async_std::task;

use std::{collections::HashMap, time::Duration};

use diesel::prelude::*;


async fn server_init(pool: &DbPool, docker: &Docker) -> Result<(), String> {
    use schema::servers::dsl::*;
    let conn = &mut pool.get().unwrap();

    println!("init start");

    let _ = diesel::update(servers).filter(simple_redirect.eq(false)).set(status.eq(ServerStatus::Stopped)).execute(conn);

    let mut filters = HashMap::new();
    filters.insert("name", vec!["minecraft-"]);
    let container_list_options = ListContainersOptionsBuilder::new()
        .all(true)
        .filters(&filters)
        .build();
    let containers = docker.list_containers(Some(container_list_options)).await.map_err(|e| format!("Failed get current containers : {}", e))?;

    if containers.len() != 0 {
        println!("stopping {} stray container(s)", containers.len())
    }

    for container in containers {
        let container_name = &container.names.unwrap()[0][1..];
        println!("stopping {}", container_name);
        let stop_options = StopContainerOptionsBuilder::new()
            .t(60)
            .build();
        docker.stop_container(container_name, Some(stop_options)).await.map_err(|e| format!("Failed to stop container {}, : {}", container_name, e))?;
        println!("{} stopped", container_name);
    }
    println!("init done");
    Ok(())
}

pub async fn server_manager_loop(pool: DbPool, docker: Docker)
{
    use schema::servers::dsl::*;

    let conn = &mut pool.get().unwrap();

    match server_init(&pool, &docker).await {
        Err(e) => { eprintln!("init failed , ignoring because idgaf : {}", e); },
        Ok(_) => {},
    };

    loop {
        let a_servers = match servers.select(models::Servers::as_select()).filter(simple_redirect.eq(false)).load(conn) {
            Ok( srv ) => { srv },
            Err(error) => { eprintln!("Failed to retreive servers, ignoring : {}", error); vec![] },
        };

        for srv in a_servers {
            let time_diff = Utc::now().naive_utc() - srv.last_login.unwrap();
            should_stop(&docker, &pool, &time_diff, &srv).await;
        }
        task::sleep(Duration::from_secs(5)).await;
    }
}

async fn should_stop(docker: &Docker, pool: &DbPool, diff: &TimeDelta, srv: &Servers) {
    if srv.status != ServerStatus::Running { return ; }

    if diff.num_days() >= 7 {
        println!("last login time exceeded, stopping {}", srv.name);
        let _ = dockermgr::stop_server(docker, pool, &srv.name).await;
        println!("{} stopped", srv.name);
    }
}