mod common;
pub mod config;
pub mod install;
pub mod link;
pub mod local;
pub mod package;
pub mod profile;
pub mod remove;
pub mod repo;
pub mod version;

use common::fs::LockGuard;
use config::AllConfig;
use local::{Cache, DataDir, LocalDb};
use profile::Profile;
use rust_i18n::t;

rust_i18n::i18n!("locales/libpackie", fallback = "en");

/// Main Packie state.
#[derive(Debug)]
pub struct Packie {
    profile: Profile,
    local_db: LocalDb,
    config: AllConfig,
    local_data: DataDir,
    cache: Cache,
    _lock_guard: LockGuard,
}
impl Packie {
    /// Returns profile of the Packie instance.
    pub fn profile(&self) -> &Profile {
        &self.profile
    }

    /// Returns cache manager for the Packie instance.
    pub fn cache(&self) -> &Cache {
        &self.cache
    }
}

#[derive(Debug, Clone)]
pub struct PackieBuilder {
    profile: Profile,
    readonly: bool,
    nonblocking: bool,
}
impl PackieBuilder {
    pub fn new() -> Self {
        Self {
            profile: Profile::builtin(),
            readonly: false,
            nonblocking: false,
        }
    }

    pub fn readonly(mut self, val: bool) -> Self {
        self.readonly = val;
        self
    }

    pub fn nonblocking(mut self, val: bool) -> Self {
        self.nonblocking = val;
        self
    }

    pub fn profile(mut self, val: Profile) -> Self {
        self.profile = val;
        self
    }

    pub fn build(self) -> Result<Packie, BuildPackieError> {
        let mut _lock_guard = LockGuard::noop();
        if !self.readonly {
            _ = std::fs::create_dir_all(&self.profile.packie_data_dir);
            _ = std::fs::create_dir_all(&self.profile.packie_cache_dir);
            _ = std::fs::create_dir_all(&self.profile.packie_config_dir);
            _ = std::fs::create_dir_all(&self.profile.pkg_dir);

            let lock_path = self.profile.packie_data_dir.join("packie.lock");
            _lock_guard =
                LockGuard::open(lock_path, self.nonblocking).map_err(BuildPackieError::Lock)?;
        }
        let local_db_path = self.profile.packie_data_dir.join(LocalDb::FILENAME);
        let open_local_db = if self.readonly {
            LocalDb::open_ro
        } else {
            LocalDb::open_rw
        };
        let local_db = open_local_db(local_db_path).map_err(BuildPackieError::LocalDb)?;
        let config = AllConfig::open(&self.profile.packie_config_dir);
        let cache = Cache(self.profile.packie_cache_dir.clone());
        let local_data = DataDir(self.profile.packie_data_dir.clone());

        Ok(Packie {
            profile: self.profile,
            local_db,
            config,
            cache,
            local_data,
            _lock_guard,
        })
    }
}

#[derive(Debug, thiserror::Error)]
pub enum BuildPackieError {
    #[error("{0}")]
    LocalDb(rusqlite::Error),

    #[error("{}", t!("BuildPackieError.Lock", error = .0))]
    Lock(std::io::Error),
}