// SPDX-License-Identifier: AGPL-3.0-or-later
use super::DEFAULT_CONFIG;
use std::{
    net::IpAddr,
    path::{Path, PathBuf},
};

pub struct Config {
    pub ip_addr: IpAddr,
    pub tabrmd: String,
    pub tpm_state_path: PathBuf,
    pub block_dir: PathBuf,
}

impl Config {
    pub fn builder() -> ConfigBuilder {
        ConfigBuilder::new()
    }
}

#[derive(Default)]
pub struct ConfigBuilder {
    pub ip_addr: Option<IpAddr>,
    pub tabrmd: Option<String>,
    pub tpm_state_path: Option<PathBuf>,
    pub block_dir: Option<PathBuf>,
}

impl ConfigBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_ip_addr(mut self, ip_addr: Option<IpAddr>) -> Self {
        self.ip_addr = ip_addr;
        self
    }

    pub fn with_tabrmd(mut self, tabrmd: Option<String>) -> Self {
        self.tabrmd = tabrmd;
        self
    }

    pub fn with_tpm_state_path(mut self, tpm_state_path: Option<PathBuf>) -> Self {
        self.tpm_state_path = tpm_state_path;
        self
    }

    pub fn with_block_dir(mut self, block_dir: Option<PathBuf>) -> Self {
        self.block_dir = block_dir;
        self
    }

    pub fn build(self) -> Config {
        Config {
            ip_addr: self.ip_addr.unwrap_or(DEFAULT_CONFIG.ip_addr),
            tabrmd: self.tabrmd.unwrap_or(DEFAULT_CONFIG.tabrmd.to_owned()),
            tpm_state_path: self
                .tpm_state_path
                .unwrap_or(Path::new(DEFAULT_CONFIG.tpm_state_path).to_owned()),
            block_dir: self
                .block_dir
                .unwrap_or(Path::new(DEFAULT_CONFIG.block_dir).to_owned()),
        }
    }
}

pub struct ConfigRef<'a> {
    pub ip_addr: IpAddr,
    pub tabrmd: &'a str,
    pub tpm_state_path: &'a str,
    pub block_dir: &'a str,
}

pub struct Envvars<'a> {
    pub ip_addr: &'a str,
    pub tabrmd: &'a str,
    pub tpm_state_path: &'a str,
    pub block_dir: &'a str,
}