// MinIO Rust Library for Amazon S3 Compatible Cloud Storage
// Copyright 2025 MinIO, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

mod common;

use crate::common::{TestContext, create_bucket_helper};
use minio::s3::builders::VersioningStatus;
use minio::s3::client::DEFAULT_REGION;
use minio::s3::response::{
    DeleteBucketReplicationResponse, GetBucketReplicationResponse, GetBucketVersioningResponse,
    SetBucketReplicationResponse, SetBucketVersioningResponse,
};
use minio::s3::types::{
    AndOperator, Destination, Filter, ReplicationConfig, ReplicationRule, S3Api,
};
use std::collections::HashMap;

#[tokio::test(flavor = "multi_thread", worker_threads = 10)]
async fn set_get_delete_bucket_replication() {
    let ctx = TestContext::new_from_env();
    let (bucket_name, _cleanup) = create_bucket_helper(&ctx).await;

    let mut tags: HashMap<String, String> = HashMap::new();
    tags.insert(String::from("key1"), String::from("value1"));
    tags.insert(String::from("key2"), String::from("value2"));

    let config = ReplicationConfig {
        role: Some("example1".to_string()),
        rules: vec![ReplicationRule {
            destination: Destination {
                bucket_arn: String::from("REPLACE-WITH-ACTUAL-DESTINATION-BUCKET-ARN"),
                access_control_translation: None,
                account: None,
                encryption_config: None,
                metrics: None,
                replication_time: None,
                storage_class: None,
            },
            delete_marker_replication_status: None,
            existing_object_replication_status: None,
            filter: Some(Filter {
                and_operator: Some(AndOperator {
                    prefix: Some(String::from("TaxDocs")),
                    tags: Some(tags),
                }),
                prefix: None,
                tag: None,
            }),
            id: Some(String::from("rule1")),
            prefix: None,
            priority: Some(1),
            source_selection_criteria: None,
            delete_replication_status: Some(false),
            status: true,
        }],
    };

    let resp: SetBucketVersioningResponse = ctx
        .client
        .set_bucket_versioning(&bucket_name)
        .versioning_status(VersioningStatus::Enabled)
        .send()
        .await
        .unwrap();
    assert_eq!(resp.bucket, bucket_name);
    assert_eq!(resp.region, DEFAULT_REGION);

    let resp: GetBucketVersioningResponse = ctx
        .client
        .get_bucket_versioning(&bucket_name)
        .send()
        .await
        .unwrap();
    assert_eq!(resp.status, Some(VersioningStatus::Enabled));
    assert_eq!(resp.bucket, bucket_name);
    assert_eq!(resp.region, DEFAULT_REGION);

    if false {
        // TODO panic: called `Result::unwrap()` on an `Err` value: S3Error(ErrorResponse { code: "XMinioAdminRemoteTargetNotFoundError", message: "The remote target does not exist",
        let resp: SetBucketReplicationResponse = ctx
            .client
            .set_bucket_replication(&bucket_name)
            .replication_config(config.clone())
            .send()
            .await
            .unwrap();
        println!("response of setting replication: resp={:?}", resp);
        assert_eq!(resp.bucket, bucket_name);
        assert_eq!(resp.region, DEFAULT_REGION);

        let resp: GetBucketReplicationResponse = ctx
            .client
            .get_bucket_replication(&bucket_name)
            .send()
            .await
            .unwrap();
        //assert_eq!(resp.config, config); //TODO
        assert_eq!(resp.bucket, bucket_name);
        assert_eq!(resp.region, DEFAULT_REGION);

        // TODO called `Result::unwrap()` on an `Err` value: S3Error(ErrorResponse { code: "XMinioAdminRemoteTargetNotFoundError", message: "The remote target does not exist",
        let resp: DeleteBucketReplicationResponse = ctx
            .client
            .delete_bucket_replication(&bucket_name)
            .send()
            .await
            .unwrap();
        println!("response of deleting replication: resp={:?}", resp);
    }

    let resp: GetBucketVersioningResponse = ctx
        .client
        .get_bucket_versioning(&bucket_name)
        .send()
        .await
        .unwrap();
    println!("response of getting replication: resp={:?}", resp);
}