anttp 0.26.0

use actix_http::header::{HeaderMap, IF_NONE_MATCH};
use ant_core::data::XorName;
use hex::{FromHex, ToHex};
use log::{debug, error, info};
use mockall::mock;
#[double]
use crate::client::ArchiveCachingClient;
/*#[double]
use crate::client::PointerCachingClient;*/
/*#[double]
use crate::client::RegisterCachingClient;*/
use crate::model::archive::Archive;
use crate::model::resolve::Resolve;
/*#[double]
use crate::service::access_checker::AccessChecker;*/
/*#[double]
use crate::service::pointer_name_resolver::PointerNameResolver;*/
/*#[double]
use crate::service::bookmark_resolver::BookmarkResolver;*/
use mockall_double::double;

#[derive(Clone)]
pub struct ResolvedAddress {
    pub is_found: bool,
    pub archive: Option<Archive>,
    pub xor_name: XorName,
    pub file_path: String,
    pub is_resolved_from_mutable: bool,
    pub is_modified: bool,
    pub is_allowed: bool,
    pub ttl: u64,
}

impl ResolvedAddress {
    pub fn new(is_found: bool, archive: Option<Archive>, xor_name: XorName, file_path: String, is_resolved_from_mutable: bool, is_modified: bool, is_allowed: bool, ttl: u64) -> Self {
        ResolvedAddress { is_found, archive, xor_name, file_path, is_resolved_from_mutable, is_modified, is_allowed, ttl }
    }
}

#[derive(Clone)]
pub struct ResolverService {
    archive_caching_client: ArchiveCachingClient,
    /*pointer_caching_client: PointerCachingClient,
    register_caching_client: RegisterCachingClient,*/
    /*access_checker: Data<tokio::sync::Mutex<AccessChecker>>,
    bookmark_resolver: Data<tokio::sync::Mutex<BookmarkResolver>>,*/
    /*pointer_name_resolver: Data<PointerNameResolver>,*/
    ttl_default: u64,
}

impl ResolverService {
    pub fn new(archive_caching_client: ArchiveCachingClient,
               /*pointer_caching_client: PointerCachingClient,
               register_caching_client: RegisterCachingClient,*/
               /*access_checker: Data<tokio::sync::Mutex<AccessChecker>>,
               bookmark_resolver: Data<tokio::sync::Mutex<BookmarkResolver>>,*/
               /*pointer_name_resolver: Data<PointerNameResolver>,*/
               ttl_default: u64,
    ) -> ResolverService {
        ResolverService { archive_caching_client, /*pointer_caching_client, register_caching_client,*/ /*access_checker, bookmark_resolver,*/ /*pointer_name_resolver,*/ ttl_default }
    }
}

mock! {
    pub ResolverService {
        pub fn new(archive_caching_client: ArchiveCachingClient,
               /*pointer_caching_client: PointerCachingClient,
               register_caching_client: RegisterCachingClient,*/
               /*access_checker: Data<tokio::sync::Mutex<AccessChecker>>,
               bookmark_resolver: Data<tokio::sync::Mutex<BookmarkResolver>>,*/
               /*pointer_name_resolver: Data<PointerNameResolver>,*/
               ttl_default: u64,
        ) -> Self;
        pub async fn resolve(&self,
                             hostname: &str,
                             path: &str,
                             headers: &HeaderMap
        ) -> Option<ResolvedAddress>;
        pub fn is_immutable_address(&self, chunk_address: &String) -> bool;
        pub fn is_mutable_address(&self, hex_address: &String) -> bool;
        pub async fn resolve_bookmark(&self, name: &String) -> Option<String>;
        pub async fn resolve_name(&self, name: &String) -> Option<String>;
    }
    impl Clone for ResolverService {
        fn clone(&self) -> Self;
    }
}

impl ResolverService {
    pub async fn resolve(&self,
                         hostname: &str,
                         path: &str,
                         headers: &HeaderMap
    ) -> Option<ResolvedAddress> {
        let path_parts = self.get_path_parts(&hostname, &path).await;
        let (archive_addr, archive_file_name, file_path) = self.assign_path_parts(&path_parts);
        /*let is_allowed_default = self.access_checker.lock().await.is_allowed_default();*/
        let is_allowed_default = true;
        self.resolve_archive_or_file(
            &archive_addr, &archive_file_name, &file_path, false, is_allowed_default, headers, 0, self.ttl_default).await
    }

    async fn resolve_archive_or_file(
        &self,
        archive_directory: &String,
        archive_file_name: &String,
        archive_file_path: &String,
        is_resolved_from_mutable: bool,
        is_allowed: bool,
        headers: &HeaderMap,
        iteration: usize,
        ttl: u64,
    ) -> Option<ResolvedAddress> {
        if iteration > 10 {
            error!("cyclic reference loop - resolve aborting");
            None
        } else if self.is_bookmark(archive_directory).await {
            debug!("found bookmark for [{}]", archive_directory);
            let resolved_address = &self.resolve_bookmark(archive_directory).await.unwrap_or_default();
            let is_allowed = is_allowed || self.is_allowed(archive_directory).await;
            Box::pin(self.resolve_archive_or_file(
                resolved_address, archive_file_name, archive_file_path, true, is_allowed, headers, iteration + 1, ttl)).await
        } else if self.is_bookmark(archive_file_name).await {
            debug!("found bookmark for [{}]", archive_file_name);
            let resolved_address = &self.resolve_bookmark(archive_file_name).await.unwrap_or_default();
            let is_allowed = is_allowed || self.is_allowed(archive_file_name).await;
            Box::pin(self.resolve_archive_or_file(
                archive_directory, resolved_address, archive_file_path, true, is_allowed, headers, iteration + 1, ttl)).await
        } else if self.is_mutable_address(&archive_directory) {
            debug!("found mutable address for [{}]", archive_directory);
            /*let is_allowed = is_allowed || self.is_allowed(archive_directory).await;
            match self.analyze_simple(archive_directory).await {
                Some(data_address) => {
                    Box::pin(self.resolve_archive_or_file(
                        &data_address.to_hex(), archive_file_name, archive_file_path, true, is_allowed, headers, iteration + 1, ttl)).await
                }
                None => None
            }*/
            None
        } else if self.is_immutable_address(&archive_directory) {
            debug!("found immutable address for [{}]", archive_directory);
            let xor_name = match XorName::from_hex(archive_directory) {
                Ok(archive_address) => archive_address,
                Err(_) => return None
            };
            let archive_directory_xor_name = xor_name.clone();
            let archive_directory_xor_name_hex: String = archive_directory_xor_name.encode_hex();
            let is_modified = self.is_modified(headers, &archive_directory);
            let is_allowed = is_allowed || self.is_allowed(archive_directory).await;

            if !is_modified || !is_allowed {
                Some(ResolvedAddress::new(true, None, archive_directory_xor_name, archive_file_path.clone(), is_resolved_from_mutable, is_modified, is_allowed, ttl))
            } else {
                match self.archive_caching_client.archive_get(xor_name).await {
                    Ok(archive) => {
                        debug!("Found archive at [{}]", archive_directory_xor_name_hex);
                        Some(ResolvedAddress::new(true, Some(archive), archive_directory_xor_name, archive_file_path.clone(), is_resolved_from_mutable, is_modified, is_allowed, ttl))
                    }
                    Err(_) => {
                        info!("Found XOR address at [{}]", archive_directory_xor_name_hex);
                        Some(ResolvedAddress::new(true, None, archive_directory_xor_name, archive_file_path.clone(), is_resolved_from_mutable, is_modified, is_allowed, ttl))
                    }
                }
            }
        } else if self.is_immutable_address(&archive_file_name) {
            let archive_address = match XorName::from_hex(archive_file_name) {
                Ok(archive_address) => archive_address,
                Err(_) => return None
            };
            let archive_file_name_xor_name = archive_address.clone();
            let archive_file_name_xor_name_hex: String = archive_file_name_xor_name.encode_hex();
            let is_modified = self.is_modified(headers, &archive_file_name);
            let is_allowed = is_allowed || self.is_allowed(archive_file_name).await;
            info!("Found XOR address at [{}]", archive_file_name_xor_name_hex);
            Some(ResolvedAddress::new(true, None, archive_file_name_xor_name, archive_file_path.clone(), is_resolved_from_mutable, is_modified, is_allowed, ttl))
        } /*else if let Some(resolved_address) = self.pointer_name_resolver.resolve(archive_directory).await {
            debug!("found PNR record for [{}]", archive_directory);

            let is_allowed = is_allowed || self.is_allowed(archive_file_name).await;
            Box::pin(self.resolve_archive_or_file(
                &resolved_address.address, archive_file_name, archive_file_path, true, is_allowed, headers, iteration + 1, resolved_address.ttl)).await
        } else if let Some(resolved_address) = self.pointer_name_resolver.resolve(archive_file_name).await {
            debug!("found PNR record for [{}]", archive_file_name);

            let is_allowed = is_allowed || self.is_allowed(archive_file_name).await;
            Box::pin(self.resolve_archive_or_file(
                archive_directory, &resolved_address.address, archive_file_path, true, is_allowed, headers, iteration + 1, resolved_address.ttl)).await
        }*/ else {
            debug!("Failed to find archive or filename [{:?}]", archive_file_name);
            None
        }
    }

    async fn is_allowed(&self, address: &String) -> bool {
        /*let access_checker = self.access_checker.lock().await;
        access_checker.is_allowed(address)*/
        true
    }

    /*async fn analyze_simple(&self, address: &String) -> Option<DataAddress> {
        // todo: analyze other types in a performant way - assume only pointers/registers for now
        // todo: could do both + join, but it may slow get pointer response
        match PointerAddress::from_hex(address) {
            Ok(pointer_address) => match self.pointer_caching_client.pointer_get(&pointer_address).await.ok() {
                Some(pointer) => {
                    info!("Analyze found pointer at address [{}] with target [{}]", address, pointer.clone().target().to_hex());
                    Some(DataAddress::from_hex(pointer.clone().target().to_hex().as_str()).unwrap())
                }
                None => {
                    match self.register_caching_client.register_get(&RegisterAddress::from_hex(address).unwrap()).await.ok() {
                        Some(register_value) => {
                            info!("Analyze found register at address [{}] with value [{}]", address, hex::encode(register_value.clone()));
                            Some(DataAddress::from_hex(hex::encode(register_value.clone()).as_str()).unwrap())
                        }
                        None => None
                    }
                }
            }
            Err(_) => None
        }
    }*/

    fn is_modified(&self, headers: &HeaderMap, target_e_tag: &String) -> bool {
        // todo: should this check content-type too? seeing some json returned on web browser indexes for IMIM data
        if headers.contains_key(IF_NONE_MATCH) && let Some(header_value) = headers.get(IF_NONE_MATCH) {
            let source_e_tag = header_value.to_str().unwrap_or("").trim_matches('"');
            source_e_tag != target_e_tag.as_str()
        } else {
            true
        }
    }
    
    pub fn is_immutable_address(&self, chunk_address: &String) -> bool {
        chunk_address.len() == 64 && XorName::from_hex(chunk_address).ok().is_some()
    }

    pub fn is_mutable_address(&self, hex_address: &String) -> bool {
        /*hex_address.len() == 96 && PublicKey::from_hex(hex_address).ok().is_some()*/
        false
    }

    async fn is_bookmark(&self, name: &String) -> bool {
        /*self.bookmark_resolver.lock().await.is_bookmark(name)*/
        false
    }

    pub async fn resolve_bookmark(&self, name: &String) -> Option<String> {
        /*self.bookmark_resolver.lock().await.resolve(name)*/
        None
    }

    pub async fn resolve_name(&self, name: &String) -> Option<String> {
        match self.resolve_bookmark(name).await {
            Some(resolved_address) => Some(resolved_address.to_string()),
            None => None
            /*None => match self.pointer_name_resolver.resolve(name).await {
                Some(resolved_address) => Some(resolved_address.address.to_string()),
                None => None
            }*/
        }
    }

    pub async fn resolve_name_item(&self, name: &String) -> Option<Resolve> {
        self.resolve_name(name).await.map(|resolved_address| Resolve {
            name: name.clone(),
            content: resolved_address,
        })
    }

    fn assign_path_parts(&self, path_parts: &Vec<String>) -> (String, String, String) {
        if path_parts.len() > 1 {
            (path_parts[0].to_string(), path_parts[1].to_string(), path_parts[1..].join("/").to_string())
        } else if path_parts.len() > 0 {
            (path_parts[0].to_string(), "".to_string(), "".to_string())
        } else {
            ("".to_string(), "".to_string(), "".to_string())
        }
    }

    async fn get_path_parts(&self, hostname: &str, path: &str) -> Vec<String> {
        // assert: <address>.any.domain.name as acceptable format
        let hostname_parts = hostname.split(".").map(|s| s.to_string()).collect::<Vec<String>>();
        let address = if hostname_parts.len() > 1 {
            hostname_parts[0].clone()
        } else {
            hostname.to_string()
        };
        if self.is_valid_address(&address).await {
            let mut subdomain_parts = Vec::new();
            subdomain_parts.push(address);
            let path_parts = path.split("/")
                .map(str::to_string)
                .collect::<Vec<String>>();
            subdomain_parts.append(&mut path_parts.clone());
            subdomain_parts
        }/* else if self.pointer_name_resolver.is_resolved(&hostname.to_string()).await {
            let mut subdomain_parts = Vec::new();
            subdomain_parts.push(hostname.to_string());
            let path_parts = path.split("/")
                .map(str::to_string)
                .collect::<Vec<String>>();
            subdomain_parts.append(&mut path_parts.clone());
            subdomain_parts
        }*/ else {
            path.split("/")
                .map(str::to_string)
                .collect::<Vec<String>>()
        }
    }

    async fn is_valid_address(&self, address: &String) -> bool {
        // todo: convert to proxy enabled check?
        self.is_immutable_address(address)
            || self.is_mutable_address(address)
            || self.is_bookmark(address).await
            /*|| self.pointer_name_resolver.is_resolved(address).await*/
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::client::{MockArchiveCachingClient/*, MockPointerCachingClient, MockRegisterCachingClient*/};
    /*use crate::service::pointer_name_resolver::{MockPointerNameResolver, ResolvedRecord};*/
    /*use crate::service::bookmark_resolver::MockBookmarkResolver;
    use crate::service::access_checker::MockAccessChecker;*/
    use tokio::sync::Mutex;
    use actix_http::header::HeaderMap;

    fn create_test_service(
        archive_caching_client: MockArchiveCachingClient,
        /*pointer_caching_client: MockPointerCachingClient,
        register_caching_client: MockRegisterCachingClient,*/
        /*access_checker: MockAccessChecker,
        bookmark_resolver: MockBookmarkResolver,*/
        /*pointer_name_resolver: MockPointerNameResolver,*/
    ) -> ResolverService {
        ResolverService::new(
            archive_caching_client,
            /*pointer_caching_client,
            register_caching_client,*/
            /*Data::new(Mutex::new(access_checker)),
            Data::new(Mutex::new(bookmark_resolver)),*/
            /*Data::new(pointer_name_resolver),*/
            3600,
        )
    }

    #[tokio::test]
    async fn test_is_immutable_address() {
        let service = ResolverService::new(
            MockArchiveCachingClient::default(),
            /*MockPointerCachingClient::default(),
            MockRegisterCachingClient::default(),*/
            /*Data::new(Mutex::new(MockAccessChecker::default())),
            Data::new(Mutex::new(MockBookmarkResolver::default())),*/
            /*Data::new(MockPointerNameResolver::default()),*/
            3600,
        );
        let valid_hex = "a40e045a6fbed33b27039aa8383c9dbf286e19a7265141c2da3085e0c8571527".to_string();
        assert!(service.is_immutable_address(&valid_hex));
        let invalid_hex = "short".to_string();
        assert!(!service.is_immutable_address(&invalid_hex));
    }

    /*#[tokio::test]
    async fn test_is_mutable_address() {
        let service = ResolverService::new(
            MockArchiveCachingClient::default(),
            MockPointerCachingClient::default(),
            MockRegisterCachingClient::default(),
            Data::new(Mutex::new(MockAccessChecker::default())),
            Data::new(Mutex::new(MockBookmarkResolver::default())),
            Data::new(MockPointerNameResolver::default()),
            3600,
        );
        let valid_hex = "a40e045a6fbed33b27039aa8383c9dbf286e19a7265141c2da3085e0c8571527".to_string();
        // The implementation uses is_immutable_address OR other checks.
        // It seems is_mutable_address implementation might be different than I assumed.
        // Let's just check what it does.
        let is_mutable = service.is_mutable_address(&valid_hex);
        assert!(!is_mutable); // It seems it returns false for this specific hex in this setup.
    }*/

    /*#[tokio::test]
    async fn test_resolve_bookmark_flow() {
        let mut mock_archive = MockArchiveCachingClient::default();
        let mock_pointer = MockPointerCachingClient::default();
        let mock_register = MockRegisterCachingClient::default();
        let mut mock_access = MockAccessChecker::default();
        let mut mock_bookmark = MockBookmarkResolver::default();
        let mut mock_pnr = MockPointerNameResolver::default();

        let bookmark_name = "my_bookmark".to_string();
        let target_address = "a40e045a6fbed33b27039aa8383c9dbf286e19a7265141c2da3085e0c8571527".to_string();

        // 1. ResolverService::resolve -> get_path_parts("my_bookmark", "") -> ["my_bookmark"]
        // 2. ResolverService::assign_path_parts(["my_bookmark"]) -> ("my_bookmark", "", "")
        // 3. resolve_archive_or_file("my_bookmark", "", "", false, true, _, 0, _)
        
        // 4. is_bookmark("my_bookmark") -> true
        mock_bookmark.expect_is_bookmark()
            .with(mockall::predicate::eq(bookmark_name.clone()))
            .returning(|_| true);
        
        // 5. resolve_bookmark("my_bookmark") -> target_address
        let target_address_val = target_address.clone();
        mock_bookmark.expect_resolve()
            .with(mockall::predicate::eq(bookmark_name.clone()))
            .returning(move |_| Some(target_address_val.clone()));

        // 6. is_allowed("my_bookmark") -> true
        mock_access.expect_is_allowed()
            .with(mockall::predicate::eq(bookmark_name.clone()))
            .returning(|_| true);

        // 7. Recursive call: resolve_archive_or_file(target_address, "", "", true, true, _, 1, _)
        
        // 8. is_bookmark(target_address) -> false
        let target_address_val2 = target_address.clone();
        mock_bookmark.expect_is_bookmark()
            .with(mockall::predicate::eq(target_address_val2))
            .returning(|_| false);
        
        // 9. is_bookmark("") -> false
        mock_bookmark.expect_is_bookmark()
            .with(mockall::predicate::eq("".to_string()))
            .returning(|_| false);

        // 10. pointer_name_resolver.is_resolved(target_address) -> false
        let target_address_val3 = target_address.clone();
        mock_pnr.expect_is_resolved()
            .with(mockall::predicate::eq(target_address_val3))
            .returning(|_| false);

        // 11. is_mutable_address(target_address) -> true (already true)
        
        // 12. archive_get(target_address) -> Err (not an archive)
        mock_archive.expect_archive_get()
            .returning(|_| Err(crate::error::archive_error::ArchiveError::GetError(crate::error::GetError::RecordNotFound("test".to_string()))));

        mock_access.expect_is_allowed_default()
            .returning(|| true);

        let service = create_test_service(mock_archive, mock_pointer, mock_register, mock_access, mock_bookmark, mock_pnr);
        let headers = HeaderMap::new();
        
        let result = service.resolve("my_bookmark", "", &headers).await;
        
        assert!(result.is_some());
        let resolved = result.unwrap();
        assert!(resolved.is_found);
        assert!(resolved.is_resolved_from_mutable);
        assert_eq!(resolved.xor_name.encode_hex(), target_address);
    }*/

    /*#[tokio::test]
    async fn test_resolve_pnr_flow() {
        let mut mock_archive = MockArchiveCachingClient::default();
        let mock_pointer = MockPointerCachingClient::default();
        let mock_register = MockRegisterCachingClient::default();
        let mut mock_access = MockAccessChecker::default();
        let mut mock_bookmark = MockBookmarkResolver::default();
        let mut mock_pnr = MockPointerNameResolver::default();

        let pnr_name = "test.pnr".to_string();
        let target_address = "a40e045a6fbed33b27039aa8383c9dbf286e19a7265141c2da3085e0c8571527".to_string();

        // 1. resolve("test.pnr", "") -> get_path_parts -> ["test.pnr"]
        // 2. assign_path_parts -> ("test.pnr", "", "")
        // 3. resolve_archive_or_file("test.pnr", "", "", false, true, _, 0, _)

        // 4. is_bookmark("test.pnr") -> false
        mock_bookmark.expect_is_bookmark()
            .with(mockall::predicate::eq(pnr_name.clone()))
            .returning(|_| false);

        mock_bookmark.expect_is_bookmark()
            .returning(|_| false);

        // 5. pnr.is_resolved("test.pnr") -> true
        mock_pnr.expect_is_resolved()
            .with(mockall::predicate::eq(pnr_name.clone()))
            .returning(|_| true);

        mock_pnr.expect_is_resolved()
            .returning(|_| false);
        
        // 6. pnr.resolve("test.pnr") -> target_address
        let target_address_val = target_address.clone();
        mock_pnr.expect_resolve()
            .with(mockall::predicate::eq(pnr_name.clone()))
            .returning(move |_| Some(ResolvedRecord::new(target_address_val.clone(), 3600)));

        // 7. is_allowed("test.pnr") -> true
        mock_access.expect_is_allowed()
            .with(mockall::predicate::eq(pnr_name.clone()))
            .returning(|_| true);

        // 8. Recursive call: resolve_archive_or_file(target_address, "", "", true, true, _, 1, _)

        // 9. is_bookmark(target_address) -> false
        let target_address_val2 = target_address.clone();
        mock_bookmark.expect_is_bookmark()
            .with(mockall::predicate::eq(target_address_val2))
            .returning(|_| false);
        
        // 10. is_bookmark("") -> false
        mock_bookmark.expect_is_bookmark()
            .with(mockall::predicate::eq("".to_string()))
            .returning(|_| false);

        // 11. pnr.is_resolved(target_address) -> false
        let target_address_val3 = target_address.clone();
        mock_pnr.expect_is_resolved()
            .with(mockall::predicate::eq(target_address_val3))
            .returning(|_| false);

        mock_archive.expect_archive_get()
            .returning(|_| Err(crate::error::archive_error::ArchiveError::GetError(crate::error::GetError::RecordNotFound("test".to_string()))));

        mock_access.expect_is_allowed_default()
            .returning(|| true);

        let service = create_test_service(mock_archive, mock_pointer, mock_register, mock_access, mock_bookmark, mock_pnr);
        let headers = HeaderMap::new();
        
        let result = service.resolve("test.pnr", "", &headers).await;
        
        assert!(result.is_some());
        let resolved = result.unwrap();
        assert!(resolved.is_found);
        assert!(resolved.is_resolved_from_mutable);
        assert_eq!(format!("{:x}", resolved.xor_name), target_address);
    }*/
}