clickup_v2 0.1.1

use clickup_v2::config::{EnvManager, env::Environment};
use temp_env;
use std::fs;

#[test]
fn test_env_manager_load_development() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("dev_client")),
            ("CLICKUP_CLIENT_SECRET", Some("dev_secret")),
        ],
        || {
            // Remove variáveis de produção
            temp_env::with_vars_unset(
                vec!["PRODUCTION", "K_SERVICE", "GAE_APPLICATION", "GOOGLE_CLOUD_PROJECT"],
                || {
                    let env_manager = EnvManager::load();
                    assert!(env_manager.is_ok());

                    let env = env_manager.unwrap();
                    assert_eq!(env.environment, Environment::Development);
                    assert_eq!(env.client_id, "dev_client");
                    assert_eq!(env.client_secret, "dev_secret");
                }
            );
        }
    );
}

#[test]
fn test_env_manager_load_production() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("prod_client")),
            ("CLICKUP_CLIENT_SECRET", Some("prod_secret")),
            ("PRODUCTION", Some("true")),
        ],
        || {
            let env_manager = EnvManager::load();
            assert!(env_manager.is_ok());

            let env = env_manager.unwrap();
            assert_eq!(env.environment, Environment::Production);
            assert_eq!(env.client_id, "prod_client");
            assert_eq!(env.client_secret, "prod_secret");
        }
    );
}

#[test]
fn test_env_manager_cloud_run_detection() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("cloud_run_client")),
            ("CLICKUP_CLIENT_SECRET", Some("cloud_run_secret")),
            ("K_SERVICE", Some("my-service")),
        ],
        || {
            let env_manager = EnvManager::load().unwrap();
            assert_eq!(env_manager.environment, Environment::Production);
            assert!(EnvManager::is_cloud_run());
            assert!(!EnvManager::is_app_engine());
        }
    );
}

#[test]
fn test_env_manager_app_engine_detection() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("app_engine_client")),
            ("CLICKUP_CLIENT_SECRET", Some("app_engine_secret")),
            ("GAE_APPLICATION", Some("my-app")),
        ],
        || {
            let env_manager = EnvManager::load().unwrap();
            assert_eq!(env_manager.environment, Environment::Production);
            assert!(!EnvManager::is_cloud_run());
            assert!(EnvManager::is_app_engine());
        }
    );
}

#[test]
fn test_env_manager_missing_required_vars() {
    temp_env::with_vars_unset(
        vec!["CLICKUP_CLIENT_ID", "CLICKUP_CLIENT_SECRET"],
        || {
            let result = EnvManager::load();
            assert!(result.is_err());
        }
    );
}

#[test]
fn test_env_manager_default_values() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
        ],
        || {
            // Remove opcionais para testar defaults
            temp_env::with_vars_unset(
                vec!["CLICKUP_REDIRECT_URI", "CLICKUP_API_BASE_URL", "CALLBACK_PORT"],
                || {
                    let env_manager = EnvManager::load().unwrap();

                    // Verifica valores padrão
                    assert_eq!(env_manager.redirect_uri, "http://localhost:8888/callback");
                    assert_eq!(env_manager.api_base_url, "https://api.clickup.com/api/v2");
                    assert_eq!(env_manager.callback_port, 8888);
                }
            );
        }
    );
}

#[test]
fn test_env_manager_custom_values() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
            ("CLICKUP_REDIRECT_URI", Some("https://custom.com/callback")),
            ("CLICKUP_API_BASE_URL", Some("https://api-custom.clickup.com")),
            ("CALLBACK_PORT", Some("9999")),
        ],
        || {
            let result = EnvManager::load();

            // Como a URL personalizada não está na lista de permitidas,
            // a validação deve falhar
            if let Ok(env) = result {
                let validation = env.validate();
                assert!(validation.is_err());
            }
        }
    );
}

#[test]
fn test_valid_redirect_urls() {
    let valid_urls = EnvManager::get_valid_redirect_urls();

    assert_eq!(valid_urls.len(), 4);
    assert!(valid_urls.contains(&"http://localhost:8888/callback".to_string()));
    assert!(valid_urls.contains(&"https://chatguru-clickup-middleware-707444002434.southamerica-east1.run.app/callback".to_string()));
}

#[test]
fn test_redirect_url_validation() {
    // URLs válidas
    assert!(EnvManager::is_valid_redirect_url("http://localhost:8888/callback"));
    assert!(EnvManager::is_valid_redirect_url("https://chatguru-clickup-middleware-707444002434.southamerica-east1.run.app/callback"));

    // URLs inválidas
    assert!(!EnvManager::is_valid_redirect_url("http://malicious.com/callback"));
    assert!(!EnvManager::is_valid_redirect_url("https://example.com/callback"));
    assert!(!EnvManager::is_valid_redirect_url(""));
}

#[test]
fn test_api_url_generation() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
        ],
        || {
            let env_manager = EnvManager::load().unwrap();

            // Teste com diferentes endpoints
            assert_eq!(env_manager.get_api_url("user"), "https://api.clickup.com/api/v2/user");
            assert_eq!(env_manager.get_api_url("/user"), "https://api.clickup.com/api/v2/user");
            assert_eq!(env_manager.get_api_url("team/123/space"), "https://api.clickup.com/api/v2/team/123/space");
            assert_eq!(env_manager.get_api_url("/team/123/space"), "https://api.clickup.com/api/v2/team/123/space");
        }
    );
}

#[test]
fn test_oauth_urls() {
    let (auth_url, token_url) = EnvManager::get_oauth_urls();

    assert_eq!(auth_url, "https://app.clickup.com/api");
    assert_eq!(token_url, "https://api.clickup.com/api/v2/oauth/token");
}

#[test]
fn test_access_token_operations() {
    // Teste get sem token
    temp_env::with_var_unset("CLICKUP_ACCESS_TOKEN", || {
        assert!(EnvManager::get_access_token().is_none());
    });

    // Teste get com token
    temp_env::with_var("CLICKUP_ACCESS_TOKEN", Some("test_token"), || {
        assert_eq!(EnvManager::get_access_token(), Some("test_token".to_string()));
    });

    // Teste get com token vazio (deve retornar None)
    temp_env::with_var("CLICKUP_ACCESS_TOKEN", Some(""), || {
        assert!(EnvManager::get_access_token().is_none());
    });
}

#[test]
fn test_environment_info() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
        ],
        || {
            let env_manager = EnvManager::load().unwrap();
            let info = env_manager.environment_info();

            assert!(info.contains("Desenvolvimento"));
            assert!(info.contains("8888"));
            assert!(info.contains("localhost"));
        }
    );
}

#[test]
fn test_environment_details() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
        ],
        || {
            let env_manager = EnvManager::load().unwrap();
            let details = env_manager.get_environment_details();

            assert!(details.contains("Ambiente: Development"));
            assert!(details.contains("API Base: https://api.clickup.com/api/v2"));
            assert!(details.contains("Callback Port: 8888"));
        }
    );
}

#[test]
fn test_environment_details_cloud_run() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
            ("K_SERVICE", Some("my-service")),
            ("GOOGLE_CLOUD_PROJECT", Some("my-project")),
        ],
        || {
            let env_manager = EnvManager::load().unwrap();
            let details = env_manager.get_environment_details();

            assert!(details.contains("Plataforma: Google Cloud Run"));
            assert!(details.contains("Projeto GCP: my-project"));
        }
    );
}

#[test]
fn test_callback_url_development() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
        ],
        || {
            temp_env::with_vars_unset(vec!["PRODUCTION"], || {
                let env_manager = EnvManager::load().unwrap();
                assert_eq!(env_manager.get_callback_url(), "http://localhost:8888/callback");
            });
        }
    );
}

#[test]
fn test_callback_url_production() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
            ("PRODUCTION", Some("true")),
            ("CLICKUP_REDIRECT_URI", Some("https://prod.com/callback")),
        ],
        || {
            let env_manager = EnvManager::load().unwrap();
            assert_eq!(env_manager.get_callback_url(), "https://prod.com/callback");
        }
    );
}

#[test]
fn test_env_manager_validation() {
    // Teste com configuração válida
    let valid_env = EnvManager {
        client_id: "valid_id".to_string(),
        client_secret: "valid_secret".to_string(),
        redirect_uri: "http://localhost:8888/callback".to_string(),
        api_base_url: "https://api.clickup.com/api/v2".to_string(),
        callback_port: 8888,
        environment: Environment::Development,
    };

    assert!(valid_env.validate().is_ok());

    // Teste com client_id vazio
    let invalid_client_id = EnvManager {
        client_id: "".to_string(),
        client_secret: "valid_secret".to_string(),
        redirect_uri: "http://localhost:8888/callback".to_string(),
        api_base_url: "https://api.clickup.com/api/v2".to_string(),
        callback_port: 8888,
        environment: Environment::Development,
    };

    assert!(invalid_client_id.validate().is_err());

    // Teste com URL de redirect inválida
    let invalid_redirect = EnvManager {
        client_id: "valid_id".to_string(),
        client_secret: "valid_secret".to_string(),
        redirect_uri: "not-a-url".to_string(),
        api_base_url: "https://api.clickup.com/api/v2".to_string(),
        callback_port: 8888,
        environment: Environment::Development,
    };

    assert!(invalid_redirect.validate().is_err());

    // Teste com URL de redirect não autorizada
    let unauthorized_redirect = EnvManager {
        client_id: "valid_id".to_string(),
        client_secret: "valid_secret".to_string(),
        redirect_uri: "https://unauthorized.com/callback".to_string(),
        api_base_url: "https://api.clickup.com/api/v2".to_string(),
        callback_port: 8888,
        environment: Environment::Development,
    };

    assert!(unauthorized_redirect.validate().is_err());
}

#[test]
fn test_save_and_remove_token_in_memory() {
    temp_env::with_vars(
        vec![
            ("PRODUCTION", Some("true")),
        ],
        || {
            // Em produção, salva na memória do processo
            let result = EnvManager::save_access_token("test_token_prod");
            assert!(result.is_ok());

            // Verifica que foi salvo
            assert_eq!(std::env::var("CLICKUP_ACCESS_TOKEN").ok(), Some("test_token_prod".to_string()));

            // Remove o token
            let result = EnvManager::remove_access_token();
            assert!(result.is_ok());

            // Verifica que foi removido
            assert!(std::env::var("CLICKUP_ACCESS_TOKEN").is_err());
        }
    );
}

#[test]
fn test_create_env_file_if_not_exists() {
    // Usa um diretório temporário para o teste
    let temp_dir = tempfile::tempdir().unwrap();
    let env_path = temp_dir.path().join(".env");

    std::env::set_current_dir(&temp_dir).unwrap();

    // Em desenvolvimento, deve criar o arquivo
    temp_env::with_vars_unset(vec!["PRODUCTION"], || {
        let result = EnvManager::create_env_file_if_not_exists();
        assert!(result.is_ok());

        // Verifica que o arquivo foi criado
        assert!(env_path.exists());

        // Verifica o conteúdo
        let content = fs::read_to_string(&env_path).unwrap();
        assert!(content.contains("CLICKUP_CLIENT_ID="));
        assert!(content.contains("CLICKUP_CLIENT_SECRET="));
        assert!(content.contains("CLICKUP_REDIRECT_URI="));
    });
}

#[test]
fn test_production_default_port() {
    temp_env::with_vars(
        vec![
            ("CLICKUP_CLIENT_ID", Some("client")),
            ("CLICKUP_CLIENT_SECRET", Some("secret")),
            ("PRODUCTION", Some("true")),
        ],
        || {
            temp_env::with_vars_unset(vec!["PORT", "CALLBACK_PORT"], || {
                let env_manager = EnvManager::load().unwrap();
                assert_eq!(env_manager.callback_port, 8080);
            });

            temp_env::with_var("PORT", Some("3000"), || {
                let env_manager = EnvManager::load().unwrap();
                assert_eq!(env_manager.callback_port, 3000);
            });
        }
    );
}