/***********************************************************************************************************
 * Name         : SubUploadBatch
 * Purpose      : Job to create TempFormResponse records from a Sub_Upload_Util__c
 **********************************************************************************************************/
public with sharing class SubUploadBatch implements Database.Batchable<SObject>, Database.Stateful, Database.RaisesPlatformEvents {
    Sub_Upload_Util__c subUpload;
    Id formId;
    Boolean isUSTerritory = false;
    @TestVisible
    Integer totalAttachments = 0;
    Integer processedAttachments = 0;
    @TestVisible
    Integer successRecordCount = 0;
    @TestVisible
    Integer failureRecordCount = 0;
    String creatorEmail;

    public SubUploadBatch(Id subUploadId) {
        List<Sub_Upload_Util__c> subUploads = [
            SELECT
                ID,
                Name,
                File_Source_Description__c,
                Mailing_List__c,
                Mailing_List__r.TLA_ID__c,
                Mailing_List__r.TLA_ID__r.TL_ID__r.Territory_ID__r.Territory__c,
                Artist__c,
                Label__c,
                DSP__c,
                Territory_Name__c,
                Territory_Label__c,
                Success_Record_Count__c,
                Failure_Record_count__c,
                Is_Crm_Generated__c,
                Progress__c,
                Status__c,
                OverwriteFanData__c,
                AcquisitionChannel__c,
                CreatedBy.Email
            FROM Sub_Upload_Util__c
            WHERE
                Status__c = :SubUploadBatchUtils.SUB_UPLOAD_READING_FILE_STATUS
                AND Initiate_Process__c = TRUE
                AND Id = :subUploadId
        ];
        if (!subUploads.isEmpty()) {
            subUpload = subUploads[0];
            String territory = subUpload.Mailing_List__r.TLA_ID__r?.TL_ID__r?.Territory_ID__r?.Territory__c;
            isUSTerritory = UtilConstants.US_TERRITORIES.contains(territory);
            creatorEmail = subUpload.CreatedBy.Email;
        }
    }

    public Database.queryLocator start(Database.BatchableContext bc) {
        String query = 'SELECT Id FROM Attachment LIMIT 0';
        if (subUpload != null) {
            Id subUploadId = subUpload.Id;
            formId = SubUploadBatchUtils.getForm(subUpload);
            SubUploadBatchUtils.populatePromo(subUpload, formId);
            totalAttachments = Database.countQuery('SELECT count() FROM Attachment WHERE ParentId = :subUploadId');
            query = 'SELECT Id, Body, Name FROM Attachment WHERE ParentId = :subUploadId';
        }

        return Database.getQueryLocator(query);
    }

    public void execute(Database.BatchableContext bc, List<Attachment> attachments) {
        List<Temp_Form_Response__c> tfrRecords = new List<Temp_Form_Response__c>();
        Map<String, String> emailInvalidDOBmap = new Map<String, String>();
        Set<String> emails = new Set<String>();
        List<SubUploadFailures__c> subUploadFailuresToInsert = new List<SubUploadFailures__c>();

        Attachment attachment = attachments[0];

        List<List<String>> csvLines = FormatUtils.parseCSV(attachment.Body.toString(), true);
        SubUploadBatchUtils.processAttachment(
            csvLines,
            tfrRecords,
            emailInvalidDOBmap,
            subUpload,
            isUSTerritory,
            formId
        );

        List<Temp_Form_Response__c> tfrsToInsert = SubUploadBatchUtils.validateTFRS(
            tfrRecords,
            subUploadFailuresToInsert,
            emailInvalidDOBmap,
            attachment.Name
        );

        Database.SaveResult[] saveResults = Database.insert(tfrsToInsert, false);
        Integer index = 0;
        Integer failedInserts = 0;
        for (Database.SaveResult saveResult : saveResults) {
            if (!saveResult.isSuccess()) {
                failedInserts++;
                List<String> errors = new List<String>{ String.valueOf(saveResult.getErrors()[0].getStatusCode()) };
                subUploadFailuresToInsert.add(
                    SubUploadBatchUtils.createSubUploadFailure(tfrsToInsert[index], errors, null, attachment.Name)
                );
            }
            index++;
        }

        Database.DMLOptions dmlOpts = new Database.DMLOptions();
        dmlOpts.allowFieldTruncation = true;
        dmlOpts.optAllOrNone = false;

        Database.insert(subUploadFailuresToInsert, dmlOpts);
        Database.delete(attachment.Id, false);

        successRecordCount += (tfrsToInsert.size() - failedInserts);
        failureRecordCount += subUploadFailuresToInsert.size();

        processedAttachments++;
        subUpload.Progress__c = (processedAttachments * 100 / totalAttachments) / 2;
        Database.update(subUpload, false);
    }

    public void finish(Database.BatchableContext bc) {
        subUpload.File_Processed__c = true;
        subUpload.IsDataCleared__c = true;
        subUpload.Success_Record_Count__c = successRecordCount;
        subUpload.Failure_Record_count__c = failureRecordCount;
        subUpload.Progress__c = successRecordCount > 0 ? 50 : 100;
        subUpload.Status__c = subUpload.Progress__c == 100
            ? SubUploadBatchUtils.SUB_UPLOAD_COMPLETED_STATUS
            : SubUploadBatchUtils.SUB_UPLOAD_CREATING_RECORDS_STATUS;

        try {
            sendEmail();
        } catch (Exception ex) {
            SMELogger.logError(ex);
        } finally {
            if (successRecordCount > 0 && !Test.isRunningTest()) {
                Id tfrJobId = Database.executeBatch(new TempFormResponseFileUploadBatch(subUpload.Id));
                subUpload.TfrFileUploadJobId__c = tfrJobId;
            }
        }

        Database.update(subUpload);
    }

    /**
     * Method Name  : sendEmail
     * Description  : Sends result email using EmailTemplate
     */
    private void sendEmail() {
        EmailTemplate emailTemplate = [
            SELECT HtmlValue, Subject
            FROM EmailTemplate
            WHERE DeveloperName = 'FileUploadEmailTemplate'
        ];
        Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();
        List<String> recipients = ConfigUtils.getConfigMultipleStrings(ConfigUtils.FILE_UPLOAD_EMAIL_RECIPIENTS);
        recipients.add(creatorEmail);
        email.setToAddresses(recipients);

        List<OrgWideEmailAddress> orgWideEmailAddresses = [
            SELECT Id
            FROM OrgWideEmailAddress
            WHERE DisplayName = :ConfigUtils.getConfigString(ConfigUtils.FILE_UPLOAD_EMAIL_SENDER)
        ];
        if (!orgWideEmailAddresses.isEmpty()) {
            email.setOrgWideEmailAddressId(orgWideEmailAddresses[0].Id);
        }

        email.setSubject(emailTemplate.Subject);
        List<SubUploadFailures__c> subUploadFailures = new List<SubUploadFailures__c>();

        if (failureRecordCount > 0) {
            subUploadFailures = [
                SELECT
                    Email__c,
                    First_Name__c,
                    Last_Name__c,
                    Birthday_mm_dd__c,
                    Birthdate__c,
                    Gender__c,
                    Twitter_Handle__c,
                    Failure_Reason__c,
                    Attachment__c
                FROM SubUploadFailures__c
                WHERE Upload_Id__c = :subUpload.Id
            ];

            Blob csvBlob = FormatUtils.createCsvBlobFromSObjectList(subUploadFailures, true);
            Messaging.EmailFileAttachment csvAttc = new Messaging.EmailFileAttachment();
            csvAttc.setFileName('Errors.csv');
            csvAttc.setBody(csvBlob);
            email.setFileAttachments(new List<Messaging.EmailFileAttachment>{ csvAttc });
        }

        String emailContent = emailTemplate.HtmlValue;

        emailContent = emailContent.replace('{{SUB_UPLOAD_NAME}}', subUpload.Name);
        emailContent = emailContent.replace(
            '{{SUB_UPLOAD_TERRITORY}}',
            subUpload.Mailing_List__r.TLA_ID__r.TL_ID__r.Territory_ID__r.Territory__c
        );
        emailContent = emailContent.replace('{{SUCCESSFUL_COUNT}}', successRecordCount.format());
        emailContent = emailContent.replace('{{FAILURE_COUNT}}', failureRecordCount.format());
        email.setHtmlBody(emailContent);

        Messaging.sendEmail(new List<Messaging.SingleEmailMessage>{ email });

        if (!subUploadFailures.isEmpty() && !Test.isRunningTest()) {
            Database.delete(subUploadFailures, false);
        }
    }
}