import gov.cms.esmd.auth.api.AuthenticationAPIHandler;  
import gov.cms.esmd.bundlesubmission.api.BundlePractitionerAPIHandler;  
import gov.cms.esmd.bundlesubmission.api.BundleSubmissionAPIHandler;  
import gov.cms.esmd.bundlesubmission.api.ClinicalDocumentUploadAPIHandler;  
import gov.cms.esmd.bundlesubmission.api.PreSignedURLAPIHandler;  
import gov.cms.esmd.common.util.GuidUtil;  
import gov.cms.esmd.config.YamlConfigLoaderJackson;  
import gov.cms.esmd.documentretrieval.api.BinaryClientAPIHandler;  
import gov.cms.esmd.documentretrieval.api.DeliveryConfirmationAPIHandler;  
import gov.cms.esmd.documentretrieval.api.DocumentRetrievalAPIHandler;  
import gov.cms.esmd.notification.api.NotificationAPIHandler;  
import gov.cms.esmd.practitioner.api.PractitionerAPIHandler;

package gov.cms.esmd;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import gov.cms.esmd.auth.api.AuthenticationAPIHandler;
import gov.cms.esmd.bundlesubmission.api.BundlePractitionerAPIHandler;
import gov.cms.esmd.bundlesubmission.api.BundleSubmissionAPIHandler;
import gov.cms.esmd.bundlesubmission.api.ClinicalDocumentUploadAPIHandler;
import gov.cms.esmd.bundlesubmission.api.PreSignedURLAPIHandler;
import gov.cms.esmd.common.util.GuidUtil;
import gov.cms.esmd.config.YamlConfigLoaderJackson;
import gov.cms.esmd.documentretrieval.api.BinaryClientAPIHandler;
import gov.cms.esmd.documentretrieval.api.DeliveryConfirmationAPIHandler;
import gov.cms.esmd.documentretrieval.api.DocumentRetrievalAPIHandler;
import gov.cms.esmd.notification.api.NotificationAPIHandler;
import gov.cms.esmd.practitioner.api.PractitionerAPIHandler;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MainConsoleApplication {

    public static void main(String[] args) {
        try {
            // Load YAML configuration
            var loader = new YamlConfigLoaderJackson("app-settings-config-jackson.yml");
            var config = loader.getConfig();

            // Print some key config values
            log.info("HTTP Timeout: {}", config.getAppSettings().getHttpClientRequestTimeOutSeconds());
            log.info("FHIR Server URL: {}", config.getAppSettings().getFhirServerUrl());

            // Generate a shared GUID
            var commonSharedGuid = GuidUtil.generateGuid();

            // Authenticate and retrieve token
            var token = new AuthenticationAPIHandler(config.getAppSettings()).getToken();

            if (token.isSuccess()) {
                // Notifications
                var notification = new NotificationAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken()).getNotifications();

                // Presigned URL for document upload
                var preSignedURLHandler = new PreSignedURLAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                var preSignedURL = preSignedURLHandler.getPreSignedURLAsync(commonSharedGuid);

                // Upload clinical documents
                var clinicalDocumentUploadHandler = new ClinicalDocumentUploadAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                preSignedURLHandler.processPreSignedURLResponse(preSignedURL.getResponse()).forEach(url -> {
                    var uploadDocumentResponse = clinicalDocumentUploadHandler.uploadClinicalDocument(url.getPartValueUrl().getValueUrl(), url.getPartValueString().getValueString());
                    
                    // Submit bundle after successful document upload
                    var bundleSubmissionAPIHandler = new BundleSubmissionAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                    bundleSubmissionAPIHandler.processBundleSubmissionRequest(uploadDocumentResponse.getResponse(), commonSharedGuid);
                });

                // Bundle Practitioner submission
                var bundlePractitionerHandler = new BundlePractitionerAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                bundlePractitionerHandler.processBundlePractitionerRequest(commonSharedGuid);

                // Binary retrieval
                var binaryClientHandler = new BinaryClientAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                binaryClientHandler.getBinaryFileData(commonSharedGuid);

                // Delivery confirmation
                var deliveryConfirmationHandler = new DeliveryConfirmationAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                deliveryConfirmationHandler.processDeliveryConfirmation();

                // Practitioner retrieval
                var practitionerHandler = new PractitionerAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                practitionerHandler.processPractitionerRequest(null);

                // Document retrieval
                var documentRetrievalHandler = new DocumentRetrievalAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                documentRetrievalHandler.getDocumentRetrievalData();
            }

        } catch (Exception e) {
            log.error(e.getMessage());
        }
    }
}

// Load application configuration from YAML file
var loader = new YamlConfigLoaderJackson("app-settings-config-jackson.yml");

// Retrieve the parsed configuration object
var config = loader.getConfig();

// Generate a unique GUID to be shared across multiple API requests
var commonSharedGuid = GuidUtil.generateGuid();

// Log the generated GUID for tracking purposes
log.info("Common Shared GUID {}", commonSharedGuid);

// Log that the application is about to request an authentication token
log.info("Getting Token....");

// Call the Authentication API to obtain an access token using app settings
var token = new AuthenticationAPIHandler(config.getAppSettings()).getToken();
// Check if the token retrieval was successful  
if (token.isSuccess()) {  
	// Log the retrieved access token  
	log.info("token value is - {}", token.getResponse().getAccessToken());  
}

// Log the start of PreSigned URL processing
log.info("Now Processing PreSignedURL request!");

// Initialize the PreSigned URL handler with configuration and access token
var preSignedURLHandler = new PreSignedURLAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());

// Request pre-signed URLs asynchronously using the shared GUID
var preSignedURL = preSignedURLHandler.getPreSignedURLAsync(commonSharedGuid);

// Check if the PreSigned URL request succeeded
if (preSignedURL.isSuccess()) {
    // Log the retrieved pre-signed URL response
    log.info("PreSignedURL Retrieved Success - {}", new ObjectMapper().writeValueAsString(preSignedURL.getResponse()));

    // Process the response to extract individual URL details for document upload
    var urlList = preSignedURLHandler.processPreSignedURLResponse(preSignedURL.getResponse());
}

if (preSignedURL.isSuccess()) {
    // Log the successful retrieval of pre-signed URLs
    log.info("PreSignedURL Retrieved Success - {}", new ObjectMapper().writeValueAsString(preSignedURL.getResponse()));

    // Process the PreSigned URL response into a list of URLs
    var urlList = preSignedURLHandler.processPreSignedURLResponse(preSignedURL.getResponse());

    // Initialize the Clinical Document Upload handler
    var clinicalDocumentUploadHandler = new ClinicalDocumentUploadAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());

    // Iterate over each URL in the list and upload the corresponding document
    urlList.forEach(url -> {
        var uploadDocumentResponse = clinicalDocumentUploadHandler.uploadClinicalDocument(
            url.getPartValueUrl().getValueUrl(),
            url.getPartValueString().getValueString()
        );
    });
}

if (preSignedURL.isSuccess()) {
    log.info("PreSignedURL Retrieved Success - {}", new ObjectMapper().writeValueAsString(preSignedURL.getResponse()));
    
    // Convert PreSignedURL response to a list for processing
    var urlList = preSignedURLHandler.processPreSignedURLResponse(preSignedURL.getResponse());
    
    // Initialize handler for clinical document upload
    var clinicalDocumentUploadHandler = new ClinicalDocumentUploadAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());

    // Process each URL to upload the document and submit the bundle
    urlList.forEach(url -> {
        var uploadDocumentResponse = clinicalDocumentUploadHandler.uploadClinicalDocument(
            url.getPartValueUrl().getValueUrl(), 
            url.getPartValueString().getValueString()
        );

        try {
            if (uploadDocumentResponse.isSuccess()) {
                log.info("upload document response success - {}", new ObjectMapper().writeValueAsString(uploadDocumentResponse.getResponse()));

                log.info("Now Processing Bundle Submission request!");
                var bundleSubmissionAPIHandler = new BundleSubmissionAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
                var bundleSubmissionResponse = bundleSubmissionAPIHandler.processBundleSubmissionRequest(
                    uploadDocumentResponse.getResponse(), 
                    commonSharedGuid
                );

                if (bundleSubmissionResponse.isSuccess()) {
                    log.info("processing bundleSubmission success - {}", new ObjectMapper().writeValueAsString(bundleSubmissionResponse.getResponse()));
                } else {
                    log.error("processing bundleSubmission Failed - {}", bundleSubmissionResponse.getError());
                }

            } else {
                log.error("upload document Failed - {}", uploadDocumentResponse.getError());
            }

        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    });

} else {
    log.error("PreSignedURL Retrieval Failed - {}", preSignedURL.getError());
}

// Process Bundle Practitioner
log.info("Now Processing Bundle Practitioner request!");
var bundlePractitionerHandler = new BundlePractitionerAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
var bundlePractitioner = bundlePractitionerHandler.processBundlePractitionerRequest(commonSharedGuid);
if (bundlePractitioner.isSuccess()) {
    log.info("Successfully process bundlePractitioner  - {}", new ObjectMapper().writeValueAsString(bundlePractitioner.getResponse()));
} else {
    log.error("Bundle Practitioner Failed - {}", bundlePractitioner.getError());
}

// Process Binary Client
log.info("Now Processing Binary Client request!");
var binaryClientHandler = new BinaryClientAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
var binaryClientResponse = binaryClientHandler.getBinaryFileData(commonSharedGuid);
if (binaryClientResponse.isSuccess()) {
    log.info("Successfully processed Binary client Request  - {}", new ObjectMapper().writeValueAsString(binaryClientResponse.getResponse()));
} else {
    log.error("Binary Client Request processing Failed - {}", binaryClientResponse.getError());
}

// Process Delivery Confirmation
log.info("Now Processing Delivery Confirmation request!");
var deliveryConfirmationHandler = new DeliveryConfirmationAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
var deliveryConfirmationResponse = deliveryConfirmationHandler.processDeliveryConfirmation();
if (deliveryConfirmationResponse.isSuccess()) {
    log.info("Successfully processed Delivery Confirmation Request  - {}", new ObjectMapper().writeValueAsString(deliveryConfirmationResponse.getResponse()));
} else {
    log.error("Delivery Confirmation Request processing Failed - {}", deliveryConfirmationResponse.getError());
}

// Process Practitioner
log.info("Now Processing Practitioner request!");
var practitionerHandler = new PractitionerAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
var practitionerResponse = practitionerHandler.processPractitionerRequest(null);
if (practitionerResponse.isSuccess()) {
    log.info("Successfully processed practitioner Request  - {}", new ObjectMapper().writeValueAsString(practitionerResponse.getResponse()));
} else {
    log.error("practitioner Request processing Failed - {}", practitionerResponse.getError());
}

// Process Document Retrieval
log.info("Now Processing Document Retrieval request!");
var documentRetrievalHandler = new DocumentRetrievalAPIHandler(config.getAppSettings(), token.getResponse().getAccessToken());
var documentRetrievalHandlerResponse = documentRetrievalHandler.getDocumentRetrievalData();
if (documentRetrievalHandlerResponse.isSuccess()) {
    log.info("Successfully processed document retrieval Request  - {}", new ObjectMapper().writeValueAsString(documentRetrievalHandlerResponse.getResponse()));
} else {
    log.error("Document Retrieval Request processing Failed - {}", documentRetrievalHandlerResponse.getError());
}

// Info Logging: Logs a concise message indicating a significant event or operation status
log.info("Operation completed with status {}", status);

// Warn Logging: Logs a warning to indicate potential problems that may need attention
log.warn("Potential issue detected: {}", warningMessage);

// Debug Logging: Logs full details of the response or internal state for in-depth debugging purposes
log.debug("Full response data: {}", responseData);