//! ref: composer/tests/Composer/Test/ComposerTest.php

use indexmap::IndexMap;
use shirabe::composer::Composer;
use shirabe::config::Config;
use shirabe::downloader::DownloadManager;
use shirabe::downloader::DownloadManagerInterface;
use shirabe::installer::InstallationManager;
use shirabe::installer::InstallationManagerInterface;
use shirabe::io::IOInterface;
use shirabe::io::null_io::NullIO;
use shirabe::json::JsonFile;
use shirabe::package::{Locker, LockerInterface, RootPackageHandle, RootPackageInterfaceHandle};
use shirabe::repository::RepositoryManager;
use shirabe::repository::RepositoryManagerInterface;
use shirabe::util::http_downloader::HttpDownloader;
use shirabe::util::r#loop::Loop;
use shirabe::util::process_executor::ProcessExecutor;

fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
    std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()))
}

fn http_downloader(
    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
) -> std::rc::Rc<std::cell::RefCell<HttpDownloader>> {
    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
    std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
        io.clone(),
        config,
        IndexMap::new(),
        true,
    )))
}

fn installation_manager(
    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
) -> std::rc::Rc<std::cell::RefCell<InstallationManager>> {
    let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(
        http_downloader(io),
        None,
    )));
    std::rc::Rc::new(std::cell::RefCell::new(InstallationManager::new(
        r#loop,
        io.clone(),
        None,
    )))
}

#[test]
fn test_set_get_package() {
    let mut composer = Composer::new();
    let package: RootPackageInterfaceHandle = RootPackageHandle::new(
        "foo".to_string(),
        "1.0.0.0".to_string(),
        "1.0.0".to_string(),
    )
    .into();
    composer.set_package(package.clone());

    assert!(composer.get_package().ptr_eq(&package));
}

#[test]
fn test_set_get_locker() {
    let mut composer = Composer::new();
    let io = null_io();
    let json_file = JsonFile::new("composer.lock".to_string(), None, None).unwrap();
    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
        io.clone(),
    ))));
    let locker: std::rc::Rc<std::cell::RefCell<dyn LockerInterface>> =
        std::rc::Rc::new(std::cell::RefCell::new(Locker::new(
            io.clone(),
            json_file,
            installation_manager(&io),
            "{}",
            process,
        )));
    composer.set_locker(locker.clone());

    assert!(std::rc::Rc::ptr_eq(&composer.get_locker(), &locker));
}

#[test]
fn test_set_get_repository_manager() {
    let mut composer = Composer::new();
    let io = null_io();
    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
    let manager: std::rc::Rc<std::cell::RefCell<dyn RepositoryManagerInterface>> =
        std::rc::Rc::new(std::cell::RefCell::new(RepositoryManager::new(
            io.clone(),
            config,
            http_downloader(&io),
            None,
            None,
        )));
    composer.set_repository_manager(manager.clone());

    assert!(std::rc::Rc::ptr_eq(
        &composer.get_repository_manager(),
        &manager
    ));
}

#[test]
fn test_set_get_download_manager() {
    let mut composer = Composer::new();
    let manager: std::rc::Rc<std::cell::RefCell<dyn DownloadManagerInterface>> = std::rc::Rc::new(
        std::cell::RefCell::new(DownloadManager::new(null_io(), false, None)),
    );
    composer.set_download_manager(manager.clone());

    assert!(std::rc::Rc::ptr_eq(
        &composer.get_download_manager(),
        &manager
    ));
}

#[test]
fn test_set_get_installation_manager() {
    let mut composer = Composer::new();
    let io = null_io();
    let manager: std::rc::Rc<std::cell::RefCell<dyn InstallationManagerInterface>> =
        installation_manager(&io);
    composer.set_installation_manager(manager.clone());

    assert!(std::rc::Rc::ptr_eq(
        &composer.get_installation_manager(),
        &manager
    ));
}