//create folder done 



public with sharing class GoogleDriveFeature extends CloudStorageBase {
    private static final String GOOGLE_DRIVE_API_URL = 'https://www.googleapis.com/drive/v3/files';    
    private static final String GOOGLE_API_URL = 'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart';
    private static String externalStorage = 'GoogleDrive';

    // public override OperationResult listFiles(Boolean isServiceMode, Boolean myDrive, String userId, Boolean isRootFolder, String folderId, String accessToken, String level){
    public override OperationResult listFiles(Map<String, Object> params){
        List<Map<String, Object>> resultFiles = new List<Map<String, Object>>();
        OperationResult result;

        Boolean isServiceMode = (Boolean) params.get('isServiceMode');
        Boolean myDrive = (Boolean) params.get('myDrive');
        Boolean isRootFolder = (Boolean) params.get('isRootFolder');
        String folderId = (String) params.get('folderId');
        String accessToken = (String) params.get('accessToken');
        String level = (String) params.get('level');

        // Fetching userId from Apex instead of user sent parameter
        String userId;
        userId = SalesforceEnvironmentUtil.getUserId();

        try {
            // Fetch access token
           // accessTokenMap = CloudStorageUtlilty.getAccessToken(isServiceMode, userId, externalStorage);
           
            System.debug('isServiceMode ' + isServiceMode);
            System.debug('accessToken ' + accessToken);


            String currentFolder = (String.isBlank(folderId) && isRootFolder) ? 'root' : folderId;
            Map<String, String> headers = new Map<String, String>{ 'Authorization' => 'Bearer ' + accessToken };

            if(currentFolder != 'root'){
                String checkerEndpoint = GOOGLE_DRIVE_API_URL +'/'+ currentFolder + '?fileds=id';
                HttpResponse res = CloudStorageUtlilty.makeCallout(null, checkerEndpoint, headers, 'GET');
                if(res.getStatusCode() != 200){
                    System.debug('You do not have access.: '+ res.getStatus());
                    return OperationResult.error('You do not have access');
                }
            }

            String baseEndpoint;
            if (myDrive || !isRootFolder) {
                baseEndpoint = GOOGLE_DRIVE_API_URL + '?q=\'' + currentFolder + '\'+in+parents+and+trashed=false' +
                            '&fields=nextPageToken,files(id,name,createdTime,owners,mimeType,webViewLink,parents,size,webContentLink)';
            } else {
                baseEndpoint = GOOGLE_DRIVE_API_URL + '?q=sharedWithMe=true' +
                            '&fields=nextPageToken,files(id,name,createdTime,owners,mimeType,webViewLink,parents,size,webContentLink)';
        }

            String pageToken = null;
            Boolean morePages = true;
            List<string> fileIdList = new list<string>();
            while (morePages) {
                String endpoint = baseEndpoint;
                if (pageToken != null) {
                    endpoint += '&pageToken=' + pageToken;
                }

                HttpResponse res = CloudStorageUtlilty.makeCallout(null, endpoint, headers, 'GET');
                System.debug('res.getBody() >>> ' + res.getBody());
                System.debug('res.getStatusCode() >>> ' + res.getStatusCode());

                if (res.getStatusCode() == 200) {
                    String responseBody = res.getBody();
                    Map<String, Object> resultMap = (Map<String, Object>) JSON.deserializeUntyped(responseBody);
                    List<Object> files = (List<Object>) resultMap.get('files');
                    //Loop to get the fileid to find out tag data
                    for (Object file : files) {
                        Map<String, Object> fileDetails = (Map<String, Object>) file;
                        fileIdList.add((String) fileDetails.get('id'));
                    }

                    Map<string,list<string>> fileIdVsTagListMap = new map<string,list<string>>();
                    for(HIC_FilesME__Tags_Data__c tag :[select id,HIC_FilesME__Tags__c,HIC_FilesME__FileId__c from HIC_FilesME__Tags_Data__c where HIC_FilesME__FileId__c in:fileIdList AND HIC_FilesME__Tags__c != null]){
                        for(String tagValue : tag.HIC_FilesME__Tags__c.split(';')){
                            if(fileIdVsTagListMap.containsKey(tag.HIC_FilesME__FileId__c)){
                                List<string> taglist = fileIdVsTagListMap.get(tag.HIC_FilesME__FileId__c);
                                taglist.add(tagValue);
                                fileIdVsTagListMap.put(tag.HIC_FilesME__FileId__c,taglist);
                            }else{
                                List<string> taglist = new list<string>();
                                taglist.add(tagValue);
                                fileIdVsTagListMap.put(tag.HIC_FilesME__FileId__c,taglist);
                            }
                            
                        }
                    } 

                    for (Object file : files) {
                        Map<String, Object> fileDetails = (Map<String, Object>) file;
                        Map<String, Object> fileData = new Map<String, object>();
                        String fileId =  (String) fileDetails.get('id');
                        fileData.put('id', fileId);
                        fileData.put('name', (String) fileDetails.get('name'));
                        fileData.put('createdTime', (String) fileDetails.get('createdTime'));
                        fileData.put('webContentLink', (String) fileDetails.get('webContentLink'));

                        //added
                        fileData.put('iconName', getFileType( (String) fileDetails.get('name') ));
                        fileData.put('mimeType', getFileType( (String) fileDetails.get('name') ));
                        //added
                        // if (type == 'folder') {
                        //     fileData.put('mimeType', 'doctype:folder');
                        //     fileData.put('iconName', 'doctype:folder');
                        // }


                        if(fileIdVsTagListMap.containsKey(fileId)){
                            fileData.put('tagData',fileIdVsTagListMap.get(fileId));
                        }else{
                            fileData.put('tagData',new list<string>());
                        }
                        
                        if (fileDetails.containsKey('size')) {
                            String fileSizeStr = (String) fileDetails.get('size');
                            String size = getSizeString(fileSizeStr);
                            fileData.put('size', size);
                        }

                        if (fileDetails.containsKey('parents')) {
                            List<Object> parents = (List<Object>) fileDetails.get('parents');
                            fileData.put('parents', !parents.isEmpty() ? (String) parents[0] : '');
                        }

                        String mimeType = (String) fileDetails.get('mimeType');
                        fileData.put('mimeType', mimeType);

                        List<Object> owners = (List<Object>) fileDetails.get('owners');
                        if (!owners.isEmpty()) {
                            Map<String, Object> owner = (Map<String, Object>) owners[0];
                            fileData.put('createdBy', (String) owner.get('displayName'));
                        }

                        // fileData.put('url', 'https://drive.google.com/file/d/' + fileData.get('id') + '/view');
                        //only change to check 
                        fileData.put('url', (String) fileDetails.get('webViewLink'));

                        fileData.put('iconName', (mimeType == 'application/vnd.google-apps.folder') ? 'doctype:folder' : 'doctype:unknown');

                        resultFiles.add(fileData);
                    }

                    pageToken = (String) resultMap.get('nextPageToken');
                    morePages = pageToken != null;

                    result = OperationResult.success(resultFiles);

                } else {
                    morePages = false;
                    result = OperationResult.error('Error listing files');
                    FME_Logger.error('Failed to list files: ' + res.getBody(), 'GoogleDriveFeature', 'listFiles');
                }
            }
            

        } catch (Exception e) {
            FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'listFiles');
            result = OperationResult.error('Error listing files: ' + e.getMessage());

        }

        return result;
    }


    //added to check
    // private method to get file type supported in salesforce
    private static String getFileType(String fileName) {
        if (fileName.endsWithIgnoreCase('.jpg') || fileName.endsWithIgnoreCase('.jpeg') ) {
            return 'doctype:image';
        }
        if (fileName.endsWithIgnoreCase('.png') || fileName.endsWithIgnoreCase('.svg') || fileName.endsWithIgnoreCase('.bmp') ) {
            return 'doctype:image';
        }
        if (fileName.endsWithIgnoreCase('.mp4') || fileName.endsWithIgnoreCase('.mkv') || fileName.endsWithIgnoreCase('.gif') || fileName.endsWithIgnoreCase('.ogg') ) {
            return 'doctype:video';
        }
        if (fileName.endsWithIgnoreCase('.mp3') || fileName.endsWithIgnoreCase('.wav') ) {
            return 'doctype:audio';
        }
        if (fileName.endsWithIgnoreCase('.docx') || fileName.endsWithIgnoreCase('.doc') || fileName.endsWithIgnoreCase('.word') ) {
            return 'doctype:document';
        }
        if (fileName.endsWithIgnoreCase('.pdf') ) {
            return 'doctype:pdf';
        }
        if (fileName.endsWithIgnoreCase('.txt') ) {
            return 'doctype:txt';
        }
        if (fileName.endsWithIgnoreCase('.csv') ) {
            return 'doctype:csv';
        }
        if (fileName.endsWithIgnoreCase('.ppt') || fileName.endsWithIgnoreCase('.pptx') ) {
            return 'doctype:ppt';
        }
        return 'doctype:unknown';
    }


    private static String getSizeString(String fileSizeStr){
        Decimal fileSize = Decimal.valueOf(fileSizeStr);
        String size;
    
        if (fileSize < 1024 * 1000 && fileSize > 0) {
            size = String.valueOf(fileSize / 1024) + ' KB';
        } else if (fileSize < 1024 * 1024 * 1000 && fileSize > 1024 * 1000) {
            size = String.valueOf(fileSize / (1024 * 1024)) + ' MB';
        } else if (fileSize >= 1024 * 1024 * 1000) {
            size = String.valueOf(fileSize / (1024 * 1024 * 1024)) + ' GB';
        } else {
            size = fileSizeStr + ' bytes';
        }
		return size;
	}
     


    public override OperationResult createFolder(Map<String, Object> params) {
        Map<String, Object> resultMap = new Map<String, Object>();
        OperationResult result;

        try {

            String parentFolderId = (String) params.get('parentFolderId');
            Boolean isServiceMode = (Boolean) params.get('isServiceMode');
            String folderName = (String) params.get('folderName');
            String userId = (String) SalesforceEnvironmentUtil.getUserId();
            String accessToken = (String) params.get('accessToken');

            // Build metadata for folder creation
            String folderMetadata = '{' + 
                                    '"name": "' + folderName + '",' + 
                                    '"mimeType": "application/vnd.google-apps.folder"';

            if (parentFolderId != null && parentFolderId != '') {
                folderMetadata += ',"parents": ["' + parentFolderId + '"]';
            }
            folderMetadata += '}'; 

            // Prepare headers
            Map<String, String> headers = new Map<String, String>{
                'Authorization' => 'Bearer ' + accessToken,
                'Content-Type' => 'application/json'
            };

            // Make callout
            HttpResponse res = CloudStorageUtlilty.makeCallout(folderMetadata, GOOGLE_DRIVE_API_URL, headers, 'POST');

            if (res.getStatusCode() == 200) {
                String responseBody = res.getBody();
                resultMap = (Map<String, Object>) JSON.deserializeUntyped(responseBody);
                resultMap.put('code', '200');
                result = OperationResult.success(resultMap);
            
                 // Adding audit log
                // String userName = UserInfo.getName();
                // System.debug('username>>>' + userName);
                // String logMsg = userName + ' created folder "' + folderName + 
                //                 (String.isNotBlank(parentFolderId) ? ('" under parentId ' + parentFolderId) : '" at root');
                // System.debug('logmsg>>>.'+ logMsg);
                // FME_Logger.audit('Create Folder', logMsg, 'GoogleDriveFeature', 'createFolder');

            
            
            } else if(res.getStatusCode() == 403) {
                System.debug('Failed to create folder: ' + res.getBody());
                result = OperationResult.error(res.getBody());
            } else {
                System.debug('Failed to create folder: ' + res.getBody());
                result = OperationResult.error(res.getBody());
            }

        } catch (Exception e) {
            FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'createFolder');
            result = OperationResult.error('Error creating folder: ' + e.getMessage());

        }
        System.debug('result create folder >>>>>' +result);
        return result;
    }

   

    // public override OperationResult renameFile(Map<String, Object> params) {
    //     OperationResult result;
    //     try {
    //         String fileId = (String) params.get('fileId');
    //         Boolean isServiceMode = (Boolean) params.get('isServiceMode');
    //         String newFileName = (String) params.get('newFileName');
    //         String accessToken = (String) params.get('accessToken');

    //         String url = 'https://www.googleapis.com/drive/v3/files/' + fileId;
    //         System.debug('url == ' + url);
    //         System.debug('newFileName == ' + newFileName);

    //         String body = '{"name": "' + newFileName + '"}';
    //         System.debug('body == ' + body);

    //         Map<String, String> headers = new Map<String, String>();
    //         headers.put('Authorization', 'Bearer ' + accessToken);
    //         headers.put('Content-Type', 'application/json');

    //         HttpResponse res = CloudStorageUtlilty.makeCallout(body, url, headers, 'PATCH');

    //             if (res.getStatusCode() == 200) {
    //                 System.debug('>>>> ' + res.getBody());
    //                 System.debug('File renamed successfully.');
    //                 result= OperationResult.success(res.getBody());

    //                 // Add audit log
    //                 String userName = UserInfo.getName();
    //                 String logMsg = userName + ' renamed file with Id ' + fileId + ' to "' + newFileName + '"';
    //                 FME_Logger.audit('Rename', logMsg, 'GoogleDriveFeature', 'renameFile');

    //             } else {
    //                 System.debug('Failed to rename file: ' + res.getBody());
    //                 result= OperationResult.error(res.getBody());
    //             }
    //     } catch (Exception e) {
    //                 FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'renameFile');
    //                 // throw new AuraHandledException(e.getMessage());
    //     }
    //     return  result;
    // }

    //also to update linkedfoldername
    public override OperationResult renameFile(Map<String, Object> params) {
        OperationResult result;
        try {
            String fileId = (String) params.get('fileId');
            Boolean isServiceMode = (Boolean) params.get('isServiceMode');
            String newFileName = (String) params.get('newFileName');
            String accessToken = (String) params.get('accessToken');

            String url = 'https://www.googleapis.com/drive/v3/files/' + fileId;

            String body = '{"name": "' + newFileName + '"}';

            Map<String, String> headers = new Map<String, String>();
            headers.put('Authorization', 'Bearer ' + accessToken);
            headers.put('Content-Type', 'application/json');

            HttpResponse res = CloudStorageUtlilty.makeCallout(body, url, headers, 'PATCH');

            if (res.getStatusCode() == 200) {

                // Update Salesforce Linked Folder record
                List<HIC_FilesME__Linked_Folder__c> folders = [
                    SELECT Id, HIC_FilesME__Folder_Name__c
                    FROM HIC_FilesME__Linked_Folder__c
                    WHERE HIC_FilesME__External_Folder_ID__c = :fileId
                ];
                System.debug('rename folder name' + folders);
                for (HIC_FilesME__Linked_Folder__c f : folders) {
                    f.HIC_FilesME__Folder_Name__c = newFileName;
                }
                System.debug('folders rename>>>>' + folders);
                if (!folders.isEmpty()) {
                    update folders;
                }

                // Success result
                result = OperationResult.success(res.getBody());

                // Audit Log
                String userName = UserInfo.getName();
                String logMsg = userName + ' renamed file with Id ' + fileId + ' to "' + newFileName + '"';
                FME_Logger.audit('Rename', logMsg, 'GoogleDriveFeature', 'renameFile');

            }
            else if(res.getStatusCode() == 403) {
                System.debug('Failed to create folder: ' + res.getBody());
                result = OperationResult.error(res.getBody());
            }
            
            else {
                result = OperationResult.error(res.getBody());
            }

        } catch (Exception e) {
            FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'renameFile');
            result = OperationResult.error(e.getMessage());
        }
        System.debug('result is >>>>>' + result);
        return result;
    }


    public override OperationResult moveFileAndFolder(Map<String, Object> params) {
        OperationResult result;

        try {
            String fileId = (String) params.get('fileId');
            Boolean isServiceMode = (Boolean) params.get('isServiceMode');
            String oldFolderId = (String) params.get('oldFolderId');
            String newFolderId = (String) params.get('newFolderId');
            String accessToken = (String) params.get('accessToken');
            String userId = (String) SalesforceEnvironmentUtil.getUserId();

            // Endpoint
            String endpoint = 'https://www.googleapis.com/drive/v3/files/' + fileId +
                            '?addParents=' + newFolderId +
                            '&removeParents=' + oldFolderId +
                            '&fields=id,parents,name';

            // Headers
            Map<String, String> headers = new Map<String, String>();
            headers.put('Authorization', 'Bearer ' + accessToken);
            headers.put('Content-Type', 'application/json');

            // Callout
            HttpResponse res = CloudStorageUtlilty.makeCallout(null, endpoint, headers, 'PATCH');

            if (res.getStatusCode() == 200) {
                System.debug('>>>>' + res.getBody());
                System.debug('File moved successfully.');
                result = OperationResult.success(res.getBody());

                //Add audit log
                // String userName = UserInfo.getName();
                // String logMsg = userName + ' moved file/folder with Id ' + fileId +
                //                 ' from oldFolderId ' + oldFolderId +
                //                 ' to newFolderId ' + newFolderId;
                // FME_Logger.audit('Move', logMsg, 'GoogleDriveFeature', 'moveFileAndFolder');

            } 
            else if(res.getStatusCode() == 403) {
                System.debug('Failed to move folder: ' + res.getBody());
                return OperationResult.error(res.getBody());
            }
            
            else {
                System.debug('Failed to move file: ' + res.getBody());
                result = OperationResult.error(res.getBody());
            }

        } catch (Exception e) {
            FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'moveFileAndFolder');
            result = OperationResult.error('Error moving file: ' + e.getMessage());

        } 
        return result;
    }


    public override OperationResult deleteFile(Map<String, Object> params) {
        try {
            String fileId = (String) params.get('fileId');
            Boolean isServiceMode = (Boolean) params.get('isServiceMode');
            String accessToken = (String) params.get('accessToken');
            String userId = (String) SalesforceEnvironmentUtil.getUserId();
            
            // Endpoint
            String endpoint = 'https://www.googleapis.com/drive/v2/files/' + fileId;
            System.debug('endpoint=' + endpoint);

            // Callout
            Map<String, String> headers = new Map<String, String>();
            headers.put('Authorization', 'Bearer ' + accessToken);
            HttpResponse res = CloudStorageUtlilty.makeCallout(null, endpoint, headers, 'DELETE');
            System.debug('>>>res=' + res.getBody());
            System.debug('>>>res.getStatusCode()=' + res.getStatusCode());

            // Handle response
            if (res.getStatusCode() == 204) {
                String userName = SalesforceEnvironmentUtil.getName();
                String logMsg = userName + ' deleted file with Id "' + fileId + '"';
                FME_Logger.audit('Delete', logMsg, 'GoogleDriveFeature', 'deleteFile');

                return OperationResult.success(res.getBody());
            }
            else if(res.getStatusCode() == 403) {
                System.debug('Failed to delete folder: ' + res.getBody());
                return OperationResult.error(res.getBody());
            }
            
            else {
                return OperationResult.error(res.getBody());
            }

        } catch (Exception e) {
            FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'deleteFile');
            return OperationResult.error('Error deleting file: ' + e.getMessage());
        }
    }



      

    public override OperationResult emailFile(Map<String,Object> params) {

        OperationResult result;

        try {

            //maildetails
            Map<String, Object> mailDetails =(Map<String, Object>) JSON.deserializeUntyped(JSON.serialize(params.get('mailDetails')));

            String fileId     = (String) params.get('fileId');
            String fileName   = (String) params.get('fileName');
            String mimeType   = (String) params.get('toSendFileNameMimeType');

            String senderId   = (String) mailDetails.get('fromUser');
            String toUser     = (String) mailDetails.get('toUser');
            String ccUser     = (String) mailDetails.get('ccUser');
            String bccUser    = (String) mailDetails.get('bccUser');
            String subject    = (String) mailDetails.get('subject');
            String body       = (String) mailDetails.get('body');


            Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();

            // Required
            mail.setToAddresses(new List<String>{ toUser });

            // Optional
            if (String.isNotBlank(ccUser))
                mail.setCcAddresses(new List<String>{ ccUser });

            if (String.isNotBlank(bccUser))
                mail.setBccAddresses(new List<String>{ bccUser });

            mail.setSubject(subject);

            // Remove HTML tags safely
            mail.setPlainTextBody(body != null ? body.replaceAll('<[^>]+>', '') : '');

            if (String.isNotBlank(senderId) && senderId.startsWith('0D2')) {
                mail.setOrgWideEmailAddressId(senderId);
            }

            Map<String, Object> downloadParams = new Map<String, Object>(params);
            downloadParams.put('fileId', fileId);
            downloadParams.put('fileName', fileName);

            OperationResult op = downloadFile(downloadParams);

            if (op != null && op.data != null) {

                Blob fileBlob = EncodingUtil.base64Decode((String) op.data);

                Messaging.EmailFileAttachment attachment = new Messaging.EmailFileAttachment();

                attachment.setFileName(fileName);
                attachment.setBody(fileBlob);
                attachment.setContentType(String.isNotBlank(mimeType) ? mimeType: 'application/octet-stream');

                mail.setFileAttachments(new List<Messaging.EmailFileAttachment>{ attachment });
            }


            Messaging.SendEmailResult[] results = Messaging.sendEmail( new List<Messaging.SingleEmailMessage>{ mail });

            if (!results.isEmpty() && results[0].isSuccess()) {
                result = OperationResult.success(null);
                System.debug(' Email sent successfully');

            } else {
                String errMsg = (!results.isEmpty() && results[0].getErrors().size() > 0)? results[0].getErrors()[0].getMessage(): 'Unknown send failure';
                result = OperationResult.error(errMsg);
            }

        } catch (Exception e) {
            FME_Logger.error(e.getMessage(),'EmailFeature ' + e.getLineNumber(),'emailFile');
            result = OperationResult.error('Error sending email: ' + e.getMessage());
        }
        System.debug('result:' + result);
        return result;
    }


    public static Blob fetchFileAndConvertToBase64(Map<String, Object> params) {
        System.debug('fetchFileAndConvertToBase64');
        Blob fileBlob;
        try {
            
            Boolean isServiceMode = (Boolean) params.get('isServiceMode');
            String fileId = (String) params.get('fileId');
            String fileName = (String) params.get('fileName');
            String accessToken = (String) params.get('accessToken');
            String userId = (String) SalesforceEnvironmentUtil.getUserId();

            System.debug('accessToken: ' + accessToken);
            System.debug('userId: ' + userId);
            System.debug('isServiceMode: ' + isServiceMode);
            System.debug('fileId: ' + fileId);
            System.debug('fileName: ' + fileName);



            String metaUrl = 'https://www.googleapis.com/drive/v3/files/' + fileId + '?fields=mimeType';
            System.debug('metaUrl: ' + metaUrl);
            System.debug('accessToken: ' + accessToken);
            Map<String, String> headers = new Map<String, String>{ 'Authorization' => 'Bearer ' + accessToken };
            HttpResponse metaRes = CloudStorageUtlilty.makeCallout(null, metaUrl, headers, 'GET');

            String mimeType = '';
            if (metaRes.getStatusCode() == 200) {
                Map<String, Object> metadata = (Map<String, Object>) JSON.deserializeUntyped(metaRes.getBody());
                mimeType = (String) metadata.get('mimeType');
            }  else {
                System.debug('Failed to fetch metadata: ' + metaRes.getStatus());
                return null;
            }

            String downloadUrl;
            if (mimeType != null && mimeType.equals('application/vnd.google-apps.spreadsheet')) {
                downloadUrl = 'https://www.googleapis.com/drive/v3/files/' + fileId + '/export?mimeType=application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
            } else if (mimeType != null && mimeType.equals('application/vnd.google-apps.document')) {
                downloadUrl = 'https://www.googleapis.com/drive/v3/files/' + fileId + '/export?mimeType=application/pdf';
            } else {
                downloadUrl = 'https://www.googleapis.com/drive/v3/files/' + fileId + '?alt=media';
            }

            HttpResponse fileRes = CloudStorageUtlilty.makeCallout(null, downloadUrl, headers, 'GET');

            if (fileRes.getStatusCode() == 200) {
                fileBlob = fileRes.getBodyAsBlob();
            } else {
                System.debug('Failed to fetch file: ' + fileRes.getStatus() + ', body: ' + fileRes.getBody());
            }

        } catch (Exception e) {
            System.debug('Error in fetchFileAndConvertToBase64: ' + e.getMessage() + ' | Line: ' + e.getLineNumber());
            FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'fetchFileAndConvertToBase64');
        }
        System.debug('Blob received:-> '+ fileBlob);
        return fileBlob;
    }

    



    public override OperationResult downloadFile(Map<String, Object> params) {
        System.debug('GoogleDriveFeature.downloadFile');

        OperationResult result;
        try {
            Blob fileBlob = fetchFileAndConvertToBase64(params);

            if (fileBlob != null) {
                result = OperationResult.success(EncodingUtil.base64Encode(fileBlob));
                System.debug('File downloaded successfully.');
            
            } else {
                result = OperationResult.error('Failed to download file');
                }
        } catch (Exception e) {
            result = OperationResult.error('Error downloading file: ' + e.getMessage());
            FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'downloadFile');

        } 
        System.debug('Resultindownloadfile:-> '+ result);
        return result;
    }


    // public override OperationResult linkFiles(String recordId) {
    //     List<Map<String, String>> resultFiles = new List<Map<String, String>>();
    //     OperationResult result;
    //     try {
    //         List<HIC_FilesME__File_Link__c> recordFiles = [SELECT Id,CreatedDate,CreatedBy.Name,HIC_FilesME__Linked_Entity_Id__c,HIC_FilesME__Linked_Entity_Name__c,HIC_FilesME__Linked_Mimetype__c,HIC_FilesME__Linked_Record_Id__c,HIC_FilesME__Linked_Storage_Type__c FROM HIC_FilesME__File_Link__c WHERE HIC_FilesME__Linked_Record_Id__c = :recordId];

    //         for (HIC_FilesME__File_Link__c file : recordFiles) {
    //             String createDate = String.valueOf(file.CreatedDate);
    //             Map<String, String> fileData = new Map<String, String>();
    //             fileData.put('id', (String) file.HIC_FilesME__Linked_Entity_Id__c);
    //             fileData.put('recordId', (String) file.Id);
    //             fileData.put('name', (String) file.HIC_FilesME__Linked_Entity_Name__c);
    //             fileData.put('mimeType', (String) file.HIC_FilesME__Linked_Mimetype__c);
    //             fileData.put('externalStorageType', (String) file.HIC_FilesME__Linked_Storage_Type__c);
    //             fileData.put('createdTime', createDate);
    //             fileData.put('createdBy', (String) file.CreatedBy.Name);
    //             fileData.put('url', 'https://drive.google.com/file/d/' + fileData.get('id') + '/view');

    //             resultFiles.add(fileData);
    //         }
    //         return OperationResult.success(resultFiles);
    //     } catch (Exception e) {
    //         FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'linkFiles');
    //         return OperationResult.error('Failed to fetch linked files. ' + e.getMessage());
    //     } 
    // }


    // public override OperationResult toLinkFiles(String recordId, String filesDetails, String providerType) {
    //     OperationResult result;
    //     try {
    //         Map<String, Object> filesMap = (Map<String, Object>) JSON.deserializeUntyped(filesDetails);
    //         System.debug('filesMap >>>> ' + filesMap);

    //         HIC_FilesME__File_Link__c fileLink = new HIC_FilesME__File_Link__c();
    //         fileLink.HIC_FilesME__Linked_Record_Id__c   = recordId;
    //         // fileLink.HIC_FilesME__Linked_By__c = UserInfo.getUserId();
    //         fileLink.HIC_FilesME__Linked_Entity_Id__c   = (String) filesMap.get('id');
    //         fileLink.HIC_FilesME__Linked_Entity_Name__c = (String) filesMap.get('name');
    //         fileLink.HIC_FilesME__Linked_Mimetype__c    = (String) filesMap.get('mimetype');
    //         fileLink.HIC_FilesME__Linked_Storage_Type__c = providerType;

    //         insert fileLink;

    //         result = OperationResult.success(fileLink);
    //     } catch (Exception e) {
    //         result = OperationResult.error('Error linking file: ' + e.getMessage());
    //         FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'toLinkFiles');
    //     }
    //     return result;
    // }




    // change custom object  -- linkedFolder
    public override OperationResult linkFiles(String recordId) {
        List<Map<String, String>> resultFolders = new List<Map<String, String>>();

        try {
            List<HIC_FilesME__Linked_Folder__c> linkedFolders = [
                SELECT Id,Name,CreatedDate,CreatedBy.Name,HIC_FilesME__External_Folder_ID__c,
                    HIC_FilesME__Folder_Name__c,
                    HIC_FilesME__Folder_URL__c,
                    HIC_FilesME__Storage_Provider__c,
                    HIC_FilesME__Access_Level__c,
                    HIC_FilesME__Connected_Username__c
                FROM HIC_FilesME__Linked_Folder__c
                WHERE HIC_FilesME__Linked_Record__c = :recordId
                AND HIC_FilesME__Is_Active__c = true
            ];

            System.debug('linkedFolders in line 702 >>>> ' + linkedFolders);

            for (HIC_FilesME__Linked_Folder__c folder : linkedFolders) {

                Map<String, String> folderData = new Map<String, String>();

                folderData.put('id', folder.HIC_FilesME__External_Folder_ID__c);
                folderData.put('recordId', folder.Id);
                folderData.put('name', folder.HIC_FilesME__Folder_Name__c);
                folderData.put('externalStorageType', folder.HIC_FilesME__Storage_Provider__c);
                folderData.put('accessLevel', folder.HIC_FilesME__Access_Level__c);
                folderData.put('createdTime', String.valueOf(folder.CreatedDate));
                folderData.put('createdBy', folder.CreatedBy != null ? folder.CreatedBy.Name : '-');
                folderData.put('linkedBy', folder.HIC_FilesME__Connected_Username__c);
                folderData.put('url', folder.HIC_FilesME__Folder_URL__c);

                resultFolders.add(folderData);
            }

            System.debug('resultFolders >>>> ' + resultFolders);

            return OperationResult.success(resultFolders);

        } catch (Exception e) {FME_Logger.error(e.getMessage(),'LinkedFolderFeature' + e.getLineNumber(),'linkFiles');
            return OperationResult.error('Failed to fetch linked folders. ' + e.getMessage());
        }
    }

    // change custom object  -- linkedFolder multiplefolderlink
    public override OperationResult toLinkFiles(String recordId,String folderDetails,String providerType) {
        try {
            System.debug('providerType >>>> ' + providerType);
            System.debug('recordId >>>> ' + recordId);
            System.debug('JSON.deserializeUntyped folderDetails  >>>> ' + JSON.deserializeUntyped(folderDetails));
            Map<String, Object> folderMap =
                (Map<String, Object>) JSON.deserializeUntyped(folderDetails);

            HIC_FilesME__Linked_Folder__c linkedFolder = new HIC_FilesME__Linked_Folder__c();

            linkedFolder.HIC_FilesME__Linked_Record__c      = recordId;
            linkedFolder.HIC_FilesME__External_Folder_ID__c = (String) folderMap.get('id');
            linkedFolder.HIC_FilesME__Folder_Name__c        = (String) folderMap.get('name');
            //add
            linkedFolder.HIC_FilesME__Created__c = UserInfo.getUserId();
            linkedFolder.HIC_FilesME__Created_Date__c = System.now();
            linkedFolder.HIC_FilesME__Connected_Username__c = (String) folderMap.get('linkedBy');
            linkedFolder.HIC_FilesME__Folder_URL__c         = (String) folderMap.get('url');
            linkedFolder.HIC_FilesME__Storage_Provider__c   =  providerType;
            // linkedFolder.HIC_FilesME__Access_Level__c       = (String) folderMap.get('accessLevel');
            linkedFolder.HIC_FilesME__Is_Active__c          = true;
            String key = providerType +' '+ recordId +' '+ (String) folderMap.get('id');
            linkedFolder.HIC_FilesME__Key__c = key;

            upsert linkedFolder HIC_FilesME__Key__c;
            System.debug('linkedFolder >>>> ' + linkedFolder);
            return OperationResult.success(linkedFolder);

        } catch (Exception e) {
            FME_Logger.error(e.getMessage(),'LinkedFolderFeature' + e.getLineNumber(),'toLinkFiles' );
            return OperationResult.error('Error linking folder: ' + e.getMessage());
        }
    }




    

    public override OperationResult unlinkFiles(String recordId, String filesId, Boolean deleteFromDrive) {
        System.debug('recordId >>>> ' + recordId);
        System.debug('filesId >>>> ' + filesId);
        System.debug('deleteFromDrive >>>> ' + deleteFromDrive);
        
        OperationResult result;
        try {
            List<HIC_FilesME__Linked_Folder__c> fileLinks = [SELECT Id FROM HIC_FilesME__Linked_Folder__c  WHERE HIC_FilesME__Linked_Record__c = :recordId AND HIC_FilesME__External_Folder_ID__c = :filesId];

                if (fileLinks.size() > 0) {
                    delete fileLinks;

                    // if (deleteFromDrive) {
                    //     deleteFile(filesId, true, null);
                    // }

                    result = OperationResult.success(null);
                } else {
                    result = OperationResult.error('No record found');
                }
            } catch (Exception e) {
                result = OperationResult.error('Error unlinking file: ' + e.getMessage());
                FME_Logger.error(e.getMessage(), 'GoogleDriveFeature' + e.getLineNumber(), 'unlinkFiles');
            } 
            return result;
    }


    // Method to fetch tags Data
    // @AuraEnabled
    // public static List<String> fetchTagsData(String uniqueKey){
    //     try {
    //         System.debug('Inside fetchTagsData');
    //         List<HIC_FilesME__Tags_Data__c> tagsData = [
    //             SELECT Id,Name,CreatedDate,
    //                 HIC_FilesME__Tags__c
    //             FROM HIC_FilesME__Tags_Data__c
    //             WHERE HIC_FilesME__Key__c = :uniqueKey
    //         ];

    //         List<String> tags = new List<String>();
    //         if(!tagsData.isEmpty()) {
    //             tags = (List<String>) tagsData[0].get(HIC_FilesME__Tags_Data__c);
    //         }
    //         return tags;

    //     } catch (Exception e) {
    //         throw new AuraHandledException(e.getMessage());
    //     }
    // }


    // Method to update tags Data
    @AuraEnabled
    public static Boolean updateTagsData(String details) {

        try {
            System.debug('Inside updateTagsData- '+details);
            Map<String, Object> res = (Map<String, Object>) JSON.deserializeUntyped(details);

            // List<String> tags = new List<String>();
            String key  = (String) res.get('key');
            List<Object> rawTagList = (List<Object>) res.get('tags');
            Set<Object> tags = new Set<Object>();

            for(Object t : rawTagList) {
                tags.add(t);
            }
            
            // List<Object> rawTagList = (List<Object>) res.get('tags');
            // for (Object o : rawTagList) {
            //     Map<String,Object> tagMap = (Map<String,Object>) o;
            //     String label = (String) tagMap.get('label');
            //     tags.add(label);
            // }


            // When tags is blank -> delete existing record
            if (tags.isEmpty()) {

                HIC_FilesME__Tags_Data__c existing =
                    [SELECT Id
                    FROM HIC_FilesME__Tags_Data__c
                    WHERE HIC_FilesME__Key__c = :key
                    LIMIT 1];

                if (existing != null) {
                    delete existing;
                }
                // returning true if either record is deleted or tags is blank (since we don't need to go further)
                return true;
            }

            // Build record
            HIC_FilesME__Tags_Data__c rec = new HIC_FilesME__Tags_Data__c();

            rec.HIC_FilesME__ConnectedUser__c = (String) SalesforceEnvironmentUtil.getName();
            rec.HIC_FilesME__FileId__c        = (String) res.get('fileId');
            rec.HIC_FilesME__Key__c           = (String) key;
            rec.HIC_FilesME__LinkedFolderId__c= (String) res.get('linkedFolderId');
            rec.HIC_FilesME__Provider__c      = (String) res.get('provider');
            rec.HIC_FilesME__RecordId__c      = (String) res.get('recordId');
            
            rec.HIC_FilesME__Tags__c          = String.join(tags, ';');

            // Upsert using Key as the external id field
            Schema.SObjectField extKey = HIC_FilesME__Tags_Data__c.Fields.HIC_FilesME__Key__c;
            Database.UpsertResult status = Database.upsert(rec, extKey, false);

            System.debug('upsert result in Tags Data:-> '+ status.isSuccess());
            return status.isSuccess();

        //     for (Database.SaveResult sr : results) {
        // if (sr.isSuccess()) {
        //     // Operation was successful for this specific record
        //     System.debug('Successfully inserted account with ID: ' + sr.getId());
        // } else {
        //     // Operation failed for this specific record
        //     for (Database.Error err : sr.getErrors()) {
        //         System.debug('Error inserting account: ' + 
        //                      err.getStatusCode() + ': ' + err.getMessage());
        //         // You can also get the field that caused the error:
        //         System.debug('Fields that caused error: ' + err.getFields());
        //     }
        // }
        } catch (Exception e) {
            throw new AuraHandledException(e.getMessage());
        }
    }


}