//! Manage and execute Obnam.

use serde::Serialize;
use std::path::{Path, PathBuf};
use tempfile::{tempdir, TempDir};

const SERVER_PORT: u16 = 8888;

/// An Obnam system.
///
/// Manage an Obnam server and run the Obnam client.
pub struct Obnam {
    configs: TempDir,
    root: TempDir,
    chunks: TempDir,
}

/// Possible errors from managing an Obnam system.
#[derive(Debug, thiserror::Error)]
pub enum ObnamError {
    /// Error creating a temporary directory.
    #[error(transparent)]
    TempDir(#[from] std::io::Error),
}

impl Obnam {
    pub fn new() -> Result<Self, ObnamError> {
        let o = Self {
            configs: tempdir()?,
            root: tempdir()?,
            chunks: tempdir()?,
        };
        o.configure()?;
        Ok(o)
    }

    pub fn root(&self) -> &Path {
        self.root.path()
    }

    fn chunks(&self) -> &Path {
        self.chunks.path()
    }

    fn configs(&self) -> &Path {
        self.configs.path()
    }

    fn server_config(&self) -> PathBuf {
        self.configs().join("server.yaml")
    }

    fn client_config(&self) -> PathBuf {
        self.configs().join("client.yaml")
    }

    fn configure(&self) -> Result<(), ObnamError> {
        ServerConfig::new(SERVER_PORT, self.chunks()).write(&self.server_config())?;
        ClientConfig::new(SERVER_PORT, self.root()).write(&self.client_config())?;
        Ok(())
    }

    pub fn start_server(&mut self) -> Result<(), ObnamError> {
        Ok(())
    }

    pub fn stop_server(&mut self) -> Result<(), ObnamError> {
        Ok(())
    }

    pub fn backup(&mut self) -> Result<(), ObnamError> {
        Ok(())
    }

    pub fn restore(&mut self) -> Result<(), ObnamError> {
        Ok(())
    }
}

#[derive(Debug, Serialize)]
struct ServerConfig {
    address: String,
    chunks: PathBuf,
    tls_key: PathBuf,
    tls_cert: PathBuf,
}

impl ServerConfig {
    fn new(port: u16, chunks: &Path) -> Self {
        Self {
            address: format!("localhost:{}", port),
            chunks: chunks.to_path_buf(),
            tls_key: PathBuf::from("tls.key"),
            tls_cert: PathBuf::from("tls.pem"),
        }
    }

    fn write(&self, filename: &Path) -> Result<(), ObnamError> {
        std::fs::write(filename, serde_yaml::to_string(self).unwrap())?;
        Ok(())
    }
}

#[derive(Debug, Serialize)]
struct ClientConfig {
    server_url: String,
    verify_tls_cert: bool,
    roots: Vec<PathBuf>,
    log: Option<PathBuf>,
}

impl ClientConfig {
    fn new(port: u16, root: &Path) -> Self {
        Self {
            server_url: format!("https://localhost:{}", port),
            verify_tls_cert: false,
            roots: vec![root.to_path_buf()],
            log: None,
        }
    }

    fn write(&self, filename: &Path) -> Result<(), ObnamError> {
        std::fs::write(filename, serde_yaml::to_string(self).unwrap())?;
        Ok(())
    }
}