/*******************************************************************************
 * © 2007-2026 - LogicMonitor, Inc. All rights reserved.
 ******************************************************************************/

import com.santaba.agent.groovy.utils.GroovyScriptHelper as GSH
import com.logicmonitor.mod.Snippets
import groovy.json.JsonOutput

// To run in debug mode, set to true
Boolean debug = false

// Set props object based on whether or not we are running inside a netscan or debug console
def props
try {
    hostProps.get("system.hostname")
    props = hostProps
    debug = true  // set debug to true so that we can ensure we do not print sensitive properties
}
catch (MissingPropertyException) {
    props = netscanProps
}

// Import any needed credentials or properties that have been set in the UI
// Required properties
def rscPortal = props.get('rubrik.rsc.portal')
def rscClientId = props.get('rubrik.rsc.clientid')
def rscSecret = props.get('rubrik.rsc.key')

// Optional properties
def rootFolder = props.get('custom.folder.name', 'Rubrik Security Cloud')
Boolean skipDeviceDedupe = props.get("skip.device.dedupe", "false").toBoolean()
String hostnameSource    = props.get("hostname.source", "")?.toLowerCase()?.trim()


// Bail out early if we don't have the necessary credentials
if (!rscPortal || !rscClientId || !rscSecret) {
    throw new Exception(" Must provide Rubrik Security Cloud credentials (rubrik.rsc.portal, rubrik.rsc.clientid, rubrik.rsc.key) to run this script.")
}

def modLoader = GSH.getInstance(GroovySystem.version).getScript("Snippets", Snippets.getLoader()).withBinding(getBinding())
def lmEmit = modLoader.load("lm.emit", "1.1")
def lmDebug   = modLoader.load("lm.debug", "1.0").debugSnippetFactory(out, debug)
def http = modLoader.load("proto.http", "0").httpSnippetFactory(props)

// Only initialize lmApi snippet class if customer has not opted out
def lmApi
if (!skipDeviceDedupe) {
    def lmApiSnippet = modLoader.load("lm.api", "0")
    lmApi = lmApiSnippet.lmApiSnippetFactory(props, http, lmDebug)
}

// Initialize Rubrik Security Cloud snippet
def collectorCache = modLoader.load("lm.cache", "0")
def rubrikSC = modLoader.load("rubrik.securitycloud", "0").create(props, lmDebug, http, collectorCache)

// Get information about devices that already exist in LM portal
List fields = ["name", "currentCollectorId", "displayName"]
Map args = ["size": 1000, "fields": fields.join(",")]
def lmDevices
// But first determine if the portal size is within a range that allows us to get all devices at once
def pathFlag, portalInfo, timeLimitSec, timeLimitMs
if (!skipDeviceDedupe) {
    portalInfo = lmApi.apiCallInfo("Devices", args)
    timeLimitSec = props.get("lmapi.timelimit.sec", "60").toInteger()
    timeLimitMs = (timeLimitSec) ? Math.min(Math.max(timeLimitSec, 30), 120) * 1000 : 60000 // Allow range 30-120 sec if configured; default to 60 sec

    if (portalInfo.timeEstimateMs > timeLimitMs) {
        lmDebug.LMDebugPrint("Estimate indicates LM API calls would take longer than time limit configured.  Proceeding with individual queries by display name for each device to add.")
        lmDebug.LMDebugPrint("\t${portalInfo}\n\tNOTE:  Time limit is set to ${timeLimitSec} seconds.  Adjust this limit by setting the property lmapi.timelimit.sec.  Max 120 seconds, min 30 seconds.")
        pathFlag = "ind"
    }
    else {
        lmDebug.LMDebugPrint("Response time indicates LM API calls will complete in a reasonable time range.  Proceeding to collect info on all devices to cross reference and prevent duplicate device creation.\n\t${portalInfo}")
        pathFlag = "all"
        lmDevices = lmApi.getPortalDevices(args)
    }
}

// Retrieve all clusters from Rubrik Security Cloud
def allClustersQuery = """
query AllClusters {
  clusterConnection {
    nodes {
      id
      name
      version
      status
      geoLocation {
        address
        latitude
        longitude
      }
      metric {
        totalCapacity
        usedCapacity
      }
    }
  }
}
"""

def allClustersResults = rubrikSC.graphqlQuery(allClustersQuery, [:], "AllClusters")
if (!allClustersResults) {
    throw new Exception("Failed to retrieve clusters from Rubrik Security Cloud.")
}

// Extract clusters from the response
def clusters = allClustersResults?.data?.clusterConnection?.nodes
if (!clusters) {
    throw new Exception("No clusters found in Rubrik Security Cloud portal.")
}

lmDebug.LMDebugPrint("Found ${clusters.size()} clusters in Rubrik Security Cloud portal.")

// Build list of resources
List<Map> resources = []

def now = new Date()
def dateFormat = "yyyy-MM-dd'T'HH:mm:ss.s z"
TimeZone tz = TimeZone.getDefault()
Map duplicateResources = [
    "date" : now.format(dateFormat, tz),
    "message" : "Duplicate display names found within LogicMonitor portal wherein hostname in LM does not match hostname in Netscan output.  Refer to documentation for how to resolve name collisions using 'hostname.source' netscan property.",
    "total" : 0,
    "resources" : []
]

// Process each cluster
clusters.each { cluster ->
    String clusterId = cluster.id ?: ""
    String clusterName = cluster.name ?: clusterId
    String hostname = "${clusterId}.rsc.invalid" // Create a fake non-routable hostname since RSC clusters do not have real hostnames
    String displayName = clusterName
    Integer collectorId
    
    // Check for existing device in LM portal with this displayName
    def deviceMatch = false
    if (!skipDeviceDedupe) {
        if (pathFlag == "ind") {
            deviceMatch = lmApi.findPortalDevice(displayName, args)
        }
        else if (pathFlag == "all") {
            deviceMatch = lmApi.checkExistingDevices(displayName, lmDevices)
        }
    }

    if (deviceMatch) {
        // Log duplicates that would cause additional devices to be created
        if (hostname != deviceMatch.name) {
            def collisionInfo = [
                (displayName) : [
                    "Netscan" : [
                        "hostname"    : hostname
                    ],
                    "LM" : [
                        "hostname"    : deviceMatch.name,
                        "collectorId" : deviceMatch.currentCollectorId
                    ],
                    "Resolved" : false
                ]
            ]
    
            // If user specified to use LM hostname on display name match, update hostname variable accordingly
            if (hostnameSource == "lm" || hostnameSource == "logicmonitor") {
                hostname = deviceMatch.name
                collectorId = deviceMatch.currentCollectorId
                deviceMatch = false
                collisionInfo[displayName]["Resolved"] = true
            }
            // If user specified to use netscan data for hostname, update the display name to make it unique
            else if (hostnameSource == "netscan") {
                collisionInfo[displayName]["Resolved"] = true
                displayName = "${displayName} - ${hostname}"
                deviceMatch = false
            }
    
            duplicateResources["resources"].add(collisionInfo)
        }
        // Don't worry about matches where the hostname values are the same
        else {
            deviceMatch = false
        }
    }

    // Build device properties
    Map deviceProps = [
        "rubrik.rsc.clusteruuid": clusterId,
        "rubrik.rsc.portal": rscPortal,
        "rubrik.rsc.clustername": clusterName,
        "rubrik.rsc.clusterversion": cluster.version ?: "",
        "rubrik.rsc.clusterstatus": cluster.status ?: "",
        "rubrik.rsc.clientid": rscClientId ?: "",
        "rubrik.rsc.key": rscSecret ?: ""
    ]
    
    // Add location information if available
    if (cluster.geoLocation?.address) {
        deviceProps["system.location"] = cluster.geoLocation.address
    }
    if (cluster.geoLocation?.latitude != null) {
        deviceProps["system.latitude"] = cluster.geoLocation.latitude
    }
    if (cluster.geoLocation?.longitude != null) {
        deviceProps["system.longitude"] = cluster.geoLocation.longitude
    }

    // Determine group name based on status and location
    List<String> groupName = [rootFolder]
    if (cluster.status == "Connected") {
        if (cluster.geoLocation?.address) {
            groupName.add(cluster.geoLocation.address)
        } else {
            groupName.add("Connected")
        }
    } else {
        groupName.add(cluster.status ?: "Unknown Status")
    }

    Map resource = [
        "hostname"    : hostname,
        "displayname" : displayName,
        "hostProps"   : deviceProps,
        "groupName"   : groupName
    ]

    // Only add the collectorId field to resource map if we found a collector ID above
    if (collectorId) {
        resource["collectorId"] = collectorId
        duplicateResources["resources"][displayName]["Netscan"]["collectorId"] = collectorId
    }

    if (!deviceMatch) {
        resources.add(resource)
        lmDebug.LMDebugPrint("Added cluster: ${clusterName} (${clusterId}) - Status: ${cluster.status}")
    }
}

// Output validated data in JSON format
lmEmit.resource(resources, debug)

// Report devices that already exist in LM via log file named after root folder
if (duplicateResources["resources"].size() > 0) {
    def netscanDupLog = new File("../logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json")
    new File(netscanDupLog.getParent()).mkdirs()
    duplicateResources["total"] = duplicateResources["resources"].size()
    def json = JsonOutput.prettyPrint(JsonOutput.toJson(duplicateResources))
    netscanDupLog.write(json)
    if (hostnameSource) {
        lmDebug.LMDebug("${duplicateResources["resources"].size()} devices found that were resolved with hostname.source=${hostnameSource} in netscan output.  See LogicMonitor/Agent/logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json for details.")
    }
    else {
        lmDebug.LMDebug("${duplicateResources["resources"].size()} devices found that were not reported in netscan output.  See LogicMonitor/Agent/logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json for details.")
    }
}

lmDebug.LMDebugPrint("Successfully discovered ${resources.size()} Rubrik Security Cloud cluster(s)")
return 0