path: root/src/handlers/planets.rs

use axum::Extension;
use axum_macros::debug_handler;
use axum::{response::IntoResponse, Json, extract::Path};

use solarlib::ship::{DbShip, Ship};
use tokio::process::Command;
use tracing::{error, instrument};

use solarlib::star::{Star, NewPlanet};
use solarlib::planet::Planet;
use solarlib::errors::Error as SolarlibError;

use crate::{errors::*, get_star, State};
use std::sync::Arc;

pub async fn list() -> JsonResult<Json<Vec<Planet>>> {
    let con_url = std::env::var("QEMU_URL").unwrap_or("qemu:///system".to_string());
    let mut star = Star::new(con_url)?;
    
    let inhabitants = star.inhabitants()?;

    Ok(Json(inhabitants))
}

pub async fn get(Path(uuid): Path<String>) -> JsonResult<Json<Planet>> {

    let con_url = std::env::var("QEMU_URL").unwrap_or("qemu:///system".to_string());
    let mut star = Star::new(con_url)?;

    if let Ok(p) = star.find_planet(uuid) {
        return Ok(Json(p));
    } else {
        return Err(ServiceError::NotFound);
    }
}

pub async fn shutdown(Path(uuid): Path<String>) -> NoneResult {
    let con_url = std::env::var("QEMU_URL").unwrap_or("qemu:///system".to_string());
    let mut star = Star::new(con_url)?;

    if let Ok(p) = star.find_planet(uuid) {
        p.shutdown()?;
    } else {
        return Err(ServiceError::NotFound);
    }

    Ok(())
}

pub async fn start(Path(uuid): Path<String>) -> NoneResult {
    let mut s = get_star()?;

    if let Ok(p) = s.find_planet(uuid) {
        p.start()?;
    } else {
        return Err(ServiceError::NotFound);
    }

    Ok(())
}

pub async fn pause(Path(uuid): Path<String>) -> NoneResult {
    let mut s = get_star()?;

    if let Ok(p) = s.find_planet(uuid) {
        p.pause()?;
    } else {
        return Err(ServiceError::NotFound);
    }

    Ok(())
}

pub async fn reboot(Path(uuid): Path<String>) -> NoneResult {
    let mut s = get_star()?;

    if let Ok(p) = s.find_planet(uuid) {
        p.reboot()?;
    } else {
        return Err(ServiceError::NotFound);
    }
    
    Ok(())
}

pub async fn force_reboot(Path(uuid): Path<String>) -> NoneResult {
    let mut s = get_star()?;

    if let Ok(p) = s.find_planet(uuid) {
        p.hard_reboot()?;
    } else {
        return Err(ServiceError::NotFound);
    }

    Ok(())
}

pub async fn force_shutdown(Path(uuid): Path<String>) -> NoneResult {
    let mut s = get_star()?;

    if let Ok(p) = s.find_planet(uuid) {
        p.hard_shutdown()?;
    } else {
        return Err(ServiceError::NotFound);
    }

    Ok(())
}

#[debug_handler]
pub async fn new_planet(Json(new_planet): Json<NewPlanet>) -> JsonResult<Json<Planet>> {
    let hw_url = std::env::var("HOMEWORLD_URL").unwrap();

    let ship_shasum = new_planet.clone().ship;

    let res: DbShip = reqwest::get(format!("http://{}/ships/get/{}", hw_url, ship_shasum)).await?.json().await?;
    let ship: Ship = res.into();

    let mut s = get_star()?;

    println!("{:?}", s);

    // Try to create right away, if the Ship already exists on the system, it'll go through. If
    // not, we can download it by using the shasum
    let r = s.planet(new_planet.clone().name, new_planet.max_mem, new_planet.max_cpus, new_planet.disk_size_mb, ship.clone());
    match r {
        Err(e) => {
            match e {
                SolarlibError::MissingImage(_) => {
                    ship.download(&s)?;
                        return Ok(Json(s.planet(new_planet.name, new_planet.max_mem, new_planet.max_cpus, new_planet.disk_size_mb, ship.clone())?));
                },
                _ => {
                    return Err(ServiceError::Solarlib(e));
                }
            }
        },
        Ok(r) => {
            let tmp = s.inhabitants()?[0].clone();
            return Ok(Json(tmp));
        }
    };
}


pub async fn no_planet(Path(uuid): Path<String>) -> NoneResult {
    let mut s = get_star()?;

    if let Ok(p) = s.find_planet(uuid) {
        p.deathstar()?;
    } else {
        return Err(ServiceError::NotFound);
    }

    Ok(())
}