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){
        List<Map<String, Object>> resultFiles = new List<Map<String, Object>>();
        OperationResult result;
        // 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);

            // Determine endpoint
            String baseEndpoint;
            String currentFolder = (String.isBlank(folderId) && isRootFolder) ? 'root' : folderId;

            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)';
            }

            Map<String, String> headers = new Map<String, String>{ 'Authorization' => 'Bearer ' + accessToken };
            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'));
                        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;

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

            result = OperationResult.success(resultFiles);

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

        } finally {
           
        }

        return result;
    }



    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(String parentFolderId, Boolean isServiceMode, String folderName, String userId) {
        Map<String, Object> resultMap = new Map<String, Object>();
        Map<String, String> accessTokenMap = new Map<String, String>();
        String refreshToken;
        OperationResult result;

        try {
            // userId need not tobe sent. getAccessToken() is calling it from apex already
            String accessToken;
            accessTokenMap = CloudStorageUtlilty.getAccessToken(isServiceMode, userId, externalStorage);
            accessToken = (String) accessTokenMap.get('ACCESS_TOKEN');
            refreshToken = (String) accessTokenMap.get('REFRESH_TOKEN');

            // 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 {
                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());

        } finally {
            if (accessTokenMap.containsKey('newAccessToken')) {
                CloudStorageUtlilty.updateAccessToken(isServiceMode, userId, refreshToken,externalStorage);
            }
        }

        return result;
    }



    public override OperationResult renameFile(String fileId, Boolean isServiceMode, String userId, String newFileName) {
        String accessToken;
        String refreshToken;
        OperationResult result ;
        Map<String, String> accessTokenMap = new Map<String, String>();
        try {
            accessTokenMap = CloudStorageUtlilty.getAccessToken(isServiceMode, userId, externalStorage);
            accessToken = (String) accessTokenMap.get('ACCESS_TOKEN');
            refreshToken = (String) accessTokenMap.get('REFRESH_TOKEN');                     

            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());
        } finally {
                    if (accessTokenMap.containsKey('newAccessToken')) {
                        CloudStorageUtlilty.updateAccessToken(isServiceMode, userId, refreshToken, externalStorage);
                    }
                }
                return  result;
    }


    public override OperationResult moveFileAndFolder(String fileId, Boolean isServiceMode, String userId, String newFolderId, String oldFolderId) {
        Map<String, String> accessTokenMap = new Map<String, String>();
        String refreshToken;
        OperationResult result;

        try {
            System.debug('>>>>fileId=' + fileId);
            System.debug('>>>>newFolderId=' + newFolderId);
            System.debug('>>>>oldFolderId=' + oldFolderId);

            // Get Access Token
            accessTokenMap = CloudStorageUtlilty.getAccessToken(isServiceMode, userId, externalStorage);
            String ACCESS_TOKEN = accessTokenMap.get('ACCESS_TOKEN');
            refreshToken = accessTokenMap.get('REFRESH_TOKEN');

            // 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 ' + ACCESS_TOKEN);
            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 {
                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());

        } finally {
            if (accessTokenMap.containsKey('newAccessToken')) {
                CloudStorageUtlilty.updateAccessToken(isServiceMode, userId, refreshToken, externalStorage);
            }
        }

        return result;
    }


    public override OperationResult deleteFile(String fileId, Boolean isServiceMode, String userId) {
        Map<String, String> accessTokenMap = new Map<String, String>();
        String refreshToken;
        try {
            System.debug('>>>fileId=' + fileId + ' >>>userId=' + userId + ' >>>isServiceMode=' + isServiceMode);
            String ACCESS_TOKEN;
            
            // Get tokens
            accessTokenMap = CloudStorageUtlilty.getAccessToken(isServiceMode, userId, externalStorage);
            ACCESS_TOKEN = (String) accessTokenMap.get('ACCESS_TOKEN');
            refreshToken = (String) accessTokenMap.get('REFRESH_TOKEN');
            
            // 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 ' + ACCESS_TOKEN);
            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 = UserInfo.getName();
                // String logMsg = userName + ' deleted file with Id "' + fileId + '"';
                // FME_Logger.audit('Delete', logMsg, 'GoogleDriveFeature', 'deleteFile');

                return OperationResult.success(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());
        }
    }


    //changes
    // public override OperationResult emailFile(Boolean isServiceMode,String userId,Map<String,Object> mailDetails,String fileId,String fileName,String toSendFileNameMimeType) {
    //     OperationResult result;
    //     try {
    //         System.debug('Mail Details:-> ' + mailDetails);
    //         System.debug('FileName-> ' + fileName + ' | toSendFileNameMimeType=' + toSendFileNameMimeType);

    //         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');

    //         // Build email
    //         Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
    //         mail.setToAddresses(new List<String>{ toUser });

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

    //         mail.setSubject(subject);
    //         mail.setPlainTextBody(body != null ? body.replaceAll('<[^>]+>', '') : '');
    //         mail.setSenderDisplayName(userId);

    //         // Attach file
    //         Blob fileBlob = fetchFileAndConvertToBase64(isServiceMode, userId, fileId);
    //         System.debug('fileBlob=' + fileBlob);
          
    //         if (fileBlob != null) {
    //             Messaging.EmailFileAttachment attachment = new Messaging.EmailFileAttachment();
    //             attachment.setFileName(fileName);
    //             attachment.setBody(fileBlob);
    //             attachment.setContentType(toSendFileNameMimeType);
    //             mail.setFileAttachments(new List<Messaging.EmailFileAttachment>{ attachment });
    //         }

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

    //         if (!results.isEmpty() && results[0].isSuccess()) {
    //             result = OperationResult.success(null);
    //         } 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(), 'GoogleDriveFeature' + e.getLineNumber(), 'emailFile');
    //         result = OperationResult.error('Error sending email: ' + e.getMessage());

    //     } 
    //     return result;
    // }

 
    
    public override OperationResult emailFile(Boolean isServiceMode,String userId,Map<String,Object> mailDetails,String fileId,String fileName,String toSendFileNameMimeType) {
        OperationResult result;
        try {
            System.debug('Mail Details:-> ' + mailDetails);
            System.debug('FileName-> ' + fileName + ' | toSendFileNameMimeType=' + toSendFileNameMimeType);

            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');

            // Build email
            Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
            mail.setToAddresses(new List<String>{ toUser });

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

            mail.setSubject(subject);
            mail.setPlainTextBody(body != null ? body.replaceAll('<[^>]+>', '') : '');
            mail.setSenderDisplayName(userId);

            // Attach file
            Blob fileBlob = fetchFileAndConvertToBase64(isServiceMode, userId, fileId);
            System.debug('fileBlob=' + fileBlob);
          
            if (fileBlob != null) {
                Messaging.EmailFileAttachment attachment = new Messaging.EmailFileAttachment();
                attachment.setFileName(fileName);
                attachment.setBody(fileBlob);
                attachment.setContentType(toSendFileNameMimeType);
                mail.setFileAttachments(new List<Messaging.EmailFileAttachment>{ attachment });
            }

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

            if (!results.isEmpty() && results[0].isSuccess()) {
                result = OperationResult.success(null);
            } 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(), 'GoogleDriveFeature' + e.getLineNumber(), 'emailFile');
            result = OperationResult.error('Error sending email: ' + e.getMessage());

        } 
        return result;
    }



    public static Blob fetchFileAndConvertToBase64(Boolean isServiceMode, String userId, String fileId) {
        System.debug('fetchFileAndConvertToBase64');
        System.debug('isServiceMode: ' + isServiceMode);
        System.debug('userId: ' + userId);
        System.debug('fileId: ' + fileId);
        Blob fileBlob;
        try {
            Map<String, Object> credentials = CloudStorageUtlilty.getAccessToken(isServiceMode, userId, externalStorage);
            String accessToken = (String) credentials.get('ACCESS_TOKEN');
            String refreshToken = (String) credentials.get('REFRESH_TOKEN');

            String metaUrl = 'https://www.googleapis.com/drive/v3/files/' + fileId + '?fields=mimeType';
            System.debug('metaUrl: ' + metaUrl);
            System.debug('accessToken: ' + accessToken);
            System.debug('refreshToken: ' + refreshToken);
            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 if (metaRes.getStatusCode() == 401) {
                GoogleDriveAuth auth = new GoogleDriveAuth();
                String newAccessToken = auth.refreshAccessToken(refreshToken);
                CloudStorageUtlilty.updateAccessToken(isServiceMode, userId, newAccessToken, externalStorage);
                headers.put('Authorization', 'Bearer ' + newAccessToken);

                HttpResponse metaRes2 = CloudStorageUtlilty.makeCallout(null, metaUrl, headers, 'GET');
                if (metaRes2.getStatusCode() == 200) {
                    Map<String, Object> metadata = (Map<String, Object>) JSON.deserializeUntyped(metaRes2.getBody());
                    mimeType = (String) metadata.get('mimeType');
                    accessToken = newAccessToken;
                } else {
                    System.debug('Failed to fetch metadata after refresh.');
                    return null;
                }
            } 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';
            }



            headers.put('Authorization', 'Bearer ' + accessToken);
            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('File downloaded successfully.'+ fileBlob);
        return fileBlob;
    }

    



    public override OperationResult downloadFile(Boolean isServiceMode, String userId, String fileId, String fileName) {
        System.debug('GoogleDriveFeature.downloadFile');

        OperationResult result;
        try {
            Blob fileBlob = fetchFileAndConvertToBase64(isServiceMode, userId, fileId);

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

        } 
        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
            ];

            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
    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;

            insert linkedFolder;
            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());
        }
    }


    //for multiple linked folder
    // @AuraEnabled
    // public static OperationResult toLinkFiles(String recordId,List<String> foldersJson,   String providerType){
    //     try {
    //         List<HIC_FilesME__Linked_Folder__c> toInsert = new List<HIC_FilesME__Linked_Folder__c>();

    //         for (String fj : foldersJson){
    //             Map<String,Object> m = (Map<String,Object>)JSON.deserializeUntyped(fj);

    //             toInsert.add(new HIC_FilesME__Linked_Folder__c(
    //                 HIC_FilesME__Linked_Record__c      = recordId,
    //                 HIC_FilesME__External_Folder_ID__c = (String)m.get('id'),
    //                 HIC_FilesME__Folder_Name__c        = (String)m.get('name'),
    //                 HIC_FilesME__Folder_URL__c         = (String)m.get('url'),
    //                 HIC_FilesME__Storage_Provider__c   = providerType,
    //                 HIC_FilesME__Access_Level__c       = (String)m.get('accessLevel'),
    //                 HIC_FilesME__Is_Active__c          = true,
    //                 HIC_FilesME__Created__c            = UserInfo.getUserId(),
    //                 HIC_FilesME__Created_Date__c       = System.now()
    //             ));
    //         }

    //         insert toInsert;
    //         System.debug('toInsert >>>> ' + toInsert);
    //         return OperationResult.success(toInsert);
    //     }
    //     catch (Exception e){
    //         return OperationResult.error('Bulk link failed: '+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());
        }
    }


}