views

var ColumnBackupInstanceConfiguredWorkers = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Workers",
	DataFn: func(instance fdb.BackupInstance) string {
		return fmt.Sprintf("%d", instance.ConfiguredWorkers)
	},
}

var ColumnBackupInstanceId = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Instance Id",
	DataFn: func(instance fdb.BackupInstance) string {
		return instance.Id
	},
}

var ColumnBackupInstanceRecentOperations = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Recent Operations",
	DataFn: func(instance fdb.BackupInstance) string {
		return fmt.Sprintf("%d Succeeded / %d Failed", int(instance.BlobStats.Recent.RequestsSuccessful), int(instance.BlobStats.Recent.RequestsFailed))
	},
}

var ColumnBackupInstanceRecentTransfer = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Recent Transfer",
	DataFn: func(instance fdb.BackupInstance) string {
		return fmt.Sprintf("%s / %s", Convert(instance.BlobStats.Recent.BytesPerSecond, 1, "s"), Convert(instance.BlobStats.Recent.BytesSent, 1, None))
	},
}

var ColumnBackupInstanceUsedMemory = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "RAM Usage",
	DataFn: func(instance fdb.BackupInstance) string {
		return Convert(instance.RSSBytes, 1, None)
	},
}

var ColumnBackupInstanceVersion = components.ColumnImpl[fdb.BackupInstance]{
	ColName: "Version",
	DataFn: func(instance fdb.BackupInstance) string {
		return instance.Version
	},
}

var ColumnBackupLogBytes = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Log Bytes",
	DataFn: func(tag fdb.BackupTag) string {
		return Convert(float64(tag.MutationLogBytesWritten), 1, None)
	},
}

var ColumnBackupRangeBytes = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Range Bytes",
	DataFn: func(tag fdb.BackupTag) string {
		return Convert(float64(tag.RangeBytesWritten), 1, None)
	},
}

var ColumnBackupRestorable = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Restorable?",
	DataFn: func(tag fdb.BackupTag) string {
		return Boolify(tag.RunningBackupIsRestorable)
	},
}

var ColumnBackupRestorableVersion = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Restorable Version",
	DataFn: func(tag fdb.BackupTag) string {
		return fmt.Sprintf("%d", tag.LastRestorableVersion)
	},
}

var ColumnBackupRunning = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Running?",
	DataFn: func(tag fdb.BackupTag) string {
		return Boolify(tag.RunningBackup)
	},
}

var ColumnBackupSecondsBehind = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Seconds Behind",
	DataFn: func(tag fdb.BackupTag) string {
		return fmt.Sprintf("%0.1f", tag.LastRestorableSecondsBehind)
	},
}

var ColumnBackupStatus = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Status",
	DataFn: func(tag fdb.BackupTag) string {
		return Titlify(tag.CurrentStatus)
	},
}

var ColumnBackupTagId = components.ColumnImpl[fdb.BackupTag]{
	ColName: "Tag",
	DataFn: func(tag fdb.BackupTag) string {
		return tag.Id
	},
}

var ColumnCPUActivity = components.ColumnImpl[process.Process]{
	ColName: "CPU Activity",
	DataFn: func(pd process.Process) string {
		return fmt.Sprintf("%0.1f%%", pd.FDBData.CPU.UsageCores*100)
	},
	ColorFn: ProcessColour,
}

var ColumnClass = components.ColumnImpl[process.Process]{
	ColName: "Class",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Class
	},
	ColorFn: ProcessColour,
}

var ColumnDRBackupInstanceId = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Instance Id",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return instance.Id
	},
}

var ColumnDRBackupInstanceLastUpdated = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Last Updated",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return time.Unix(int64(instance.LastUpdated), 0).String()
	},
}

var ColumnDRBackupInstanceMainThreadCPU = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Main Thread CPU",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return fmt.Sprintf("%0.0fs", instance.MainThreadCPUSeconds)
	},
}

var ColumnDRBackupInstanceMemoryUsage = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Memory Usage",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return Convert(float64(instance.MemoryUsage), 1, None)
	},
}

var ColumnDRBackupInstanceProcessCPU = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Process CPU",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return fmt.Sprintf("%0.0fs", instance.ProcessCPUSeconds)
	},
}

var ColumnDRBackupInstanceResidentSize = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Resident Size",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return Convert(float64(instance.ResidentSize), 1, None)
	},
}

var ColumnDRBackupInstanceVersion = components.ColumnImpl[fdb.DRBackupInstance]{
	ColName: "Version",
	DataFn: func(instance fdb.DRBackupInstance) string {
		return instance.Version
	},
}

var ColumnDRBackupTagId = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Tag",
	DataFn: func(instance fdb.DRBackupTag) string {
		return instance.Id
	},
}

var ColumnDRBackupTagLogBytes = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Log Bytes Written",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Convert(float64(instance.MutationLogBytesWritten), 1, None)
	},
}

var ColumnDRBackupTagMutationStream = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Mutation Stream Id",
	DataFn: func(instance fdb.DRBackupTag) string {
		return instance.MutationSteamId
	},
}

var ColumnDRBackupTagRangeBytes = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Range Bytes Written",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Convert(float64(instance.RangeBytesWritten), 1, None)
	},
}

var ColumnDRBackupTagRestorable = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Restorable",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Boolify(instance.BackupRestorable)
	},
}

var ColumnDRBackupTagRunning = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Running",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Boolify(instance.RunningBackup)
	},
}

var ColumnDRBackupTagSecondsBehind = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "Seconds Behind",
	DataFn: func(instance fdb.DRBackupTag) string {
		return fmt.Sprintf("%0.1f", instance.SecondsBehind)
	},
}

var ColumnDRBackupTagState = components.ColumnImpl[fdb.DRBackupTag]{
	ColName: "State",
	DataFn: func(instance fdb.DRBackupTag) string {
		return Titlify(instance.BackupState)
	},
}

var ColumnDiskActivity = components.ColumnImpl[process.Process]{
	ColName: "Disk Activity",
	DataFn: func(pd process.Process) string {
		busy := pd.FDBData.Disk.Busy * 100
		return fmt.Sprintf("%0.1f RPS / %0.1f WPS / %0.1f%%", pd.FDBData.Disk.Reads.Hz, pd.FDBData.Disk.Writes.Hz, busy)
	},
	ColorFn: ProcessColour,
}

var ColumnDiskUsage = components.ColumnImpl[process.Process]{
	ColName: "Disk Usage",
	DataFn: func(pd process.Process) string {
		usedBytes := pd.FDBData.Disk.TotalBytes - pd.FDBData.Disk.FreeBytes
		diskUsage := float64(usedBytes) / float64(pd.FDBData.Disk.TotalBytes)
		return fmt.Sprintf("%0.1f%% (%s of %s)", diskUsage*100, Convert(float64(usedBytes), 1, None), Convert(float64(pd.FDBData.Disk.TotalBytes), 1, None))
	},
	ColorFn: ProcessColour,
}

var ColumnIPAddressPort = components.ColumnImpl[process.Process]{
	ColName: "IP Address:Port",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Address
	},
	ColorFn: ProcessColour,
}

var ColumnKVStorage = components.ColumnImpl[process.Process]{
	ColName: "KV Storage",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return Convert(pd.FDBData.Roles[idx].KVUsedBytes, 1, None)
	},
	ColorFn: ProcessColour,
}

var ColumnLocality = components.ColumnImpl[process.Process]{
	ColName: "Locality",
	DataFn: func(pd process.Process) string {
		return fmt.Sprintf("%s / %s", pd.FDBData.Locality[fdb.LocalityDataHall], pd.FDBData.Locality[fdb.LocalityDataCenter])
	},
	ColorFn: ProcessColour,
}

var ColumnLogDurabilityRate = components.ColumnImpl[process.Process]{
	ColName: "Input / Durable Rate",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "log")
		return fmt.Sprintf("%s / %s", Convert(pd.FDBData.Roles[idx].InputBytes.Hz, 1, "s"), Convert(pd.FDBData.Roles[idx].DurableBytes.Hz, 1, "s"))
	},
	ColorFn: ProcessColour,
}

var ColumnLogQueueLength = components.ColumnImpl[process.Process]{
	ColName: "Queue Length",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "log")
		length := pd.FDBData.Roles[idx].InputBytes.Counter - pd.FDBData.Roles[idx].DurableBytes.Counter
		return Convert(length, 1, None)
	},
	ColorFn: ProcessColour,
}

var ColumnLogQueueStorage = components.ColumnImpl[process.Process]{
	ColName: "Queue Storage",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "log")
		return Convert(pd.FDBData.Roles[idx].QueueUsedBytes, 1, None)
	},
	ColorFn: ProcessColour,
}

var ColumnMachine = components.ColumnImpl[process.Process]{
	ColName: "Machine",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Locality[fdb.LocalityMachineID]
	},
	ColorFn: ProcessColour,
}

var ColumnNetworkActivity = components.ColumnImpl[process.Process]{
	ColName: "Network Activity",
	DataFn: func(pd process.Process) string {
		return fmt.Sprintf("%0.1f Mbps / %0.1f Mbps", pd.FDBData.Network.MegabitsSent.Hz, pd.FDBData.Network.MegabitsReceived.Hz)
	},
	ColorFn: ProcessColour,
}

var ColumnRAMUsage = components.ColumnImpl[process.Process]{
	ColName: "RAM Usage",
	DataFn: func(pd process.Process) string {
		memUsage := float64(pd.FDBData.Memory.RSSBytes) / float64(pd.FDBData.Memory.AvailableBytes)
		return fmt.Sprintf("%0.1f%% (%s of %s)", memUsage*100, Convert(float64(pd.FDBData.Memory.RSSBytes), 1, None), Convert(float64(pd.FDBData.Memory.AvailableBytes), 1, None))
	},
	ColorFn: ProcessColour,
}

var ColumnRoles = components.ColumnImpl[process.Process]{
	ColName: "Roles",
	DataFn: func(pd process.Process) string {
		var roles []string

		for _, role := range pd.FDBData.Roles {
			roles = append(roles, role.Role)
		}

		return strings.Join(roles, ", ")
	},
	ColorFn: ProcessColour,
}

var ColumnSelected = components.ColumnImpl[process.Process]{
	ColName: " ",
	DataFn: func(pd process.Process) string {
		if pd.Metadata.Selected {
			return "*"
		}
		return " "
	},
	ColorFn: func(pd process.Process) tcell.Color {
		if pd.Metadata.Selected {
			return tcell.ColorGreen
		}
		return ProcessColour(pd)
	},
}

var ColumnStatus = components.ColumnImpl[process.Process]{
	ColName: "Status",
	DataFn: func(pd process.Process) string {
		var statuses []string

		if pd.FDBData.Excluded {
			statuses = append(statuses, "Excluded")
		}

		if pd.FDBData.Degraded {
			statuses = append(statuses, "Degraded")
		}

		if pd.FDBData.UnderMaintenance {
			statuses = append(statuses, "Maintenance")
		}

		if len(pd.FDBData.Messages) > 0 {
			statuses = append(statuses, "Message")
		}

		return strings.Join(statuses, " / ")
	},
	ColorFn: ProcessColour,
}

var ColumnStorageDurabilityRate = components.ColumnImpl[process.Process]{
	ColName: "Input / Durable Rate",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return fmt.Sprintf("%s / %s", Convert(pd.FDBData.Roles[idx].InputBytes.Hz, 1, "s"), Convert(pd.FDBData.Roles[idx].DurableBytes.Hz, 1, "s"))
	},
	ColorFn: ProcessColour,
}

var ColumnStorageLag = components.ColumnImpl[process.Process]{
	ColName: "Data / Durability Lag",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return fmt.Sprintf("%0.1fs / %0.1fs", pd.FDBData.Roles[idx].DataLag.Seconds, pd.FDBData.Roles[idx].DurabilityLag.Seconds)
	},
	ColorFn: ProcessColour,
}

var ColumnStorageTotalQueries = components.ColumnImpl[process.Process]{
	ColName: "Queries",
	DataFn: func(pd process.Process) string {
		idx := findRole(pd.FDBData.Roles, "storage")
		return fmt.Sprintf("%0.1f/s", pd.FDBData.Roles[idx].TotalQueries.Hz)
	},
	ColorFn: ProcessColour,
}

var ColumnUptime = components.ColumnImpl[process.Process]{
	ColName: "Uptime",
	DataFn: func(process process.Process) string {
		return (time.Duration(process.FDBData.Uptime) * time.Second).String()
	},
	ColorFn: ProcessColour,
}

var ColumnVersion = components.ColumnImpl[process.Process]{
	ColName: "Version",
	DataFn: func(pd process.Process) string {
		return pd.FDBData.Version
	},
	ColorFn: ProcessColour,
}

var StatBytesRead = components.ColumnImpl[ClusterStats]{
	ColName: "Bytes Read",
	DataFn: func(cs ClusterStats) string {
		return Convert(cs.BytesRead, 1, "s")
	},
}

var StatBytesWritten = components.ColumnImpl[ClusterStats]{
	ColName: "Bytes Written",
	DataFn: func(cs ClusterStats) string {
		return Convert(cs.BytesWritten, 1, "s")
	},
}

var StatClusterHealth = components.ColumnImpl[ClusterHealth]{
	ColName: "Healthy",
	DataFn: func(h ClusterHealth) string {
		return h.Health
	},
	ColorFn: func(h ClusterHealth) tcell.Color {
		if h.Healthy {
			return tcell.ColorGreen
		} else {
			return tcell.ColorRed
		}
	},
}

var StatDatabaseLocked = components.ColumnImpl[ClusterHealth]{
	ColName: "Database Locked",
	DataFn: func(h ClusterHealth) string {
		return Boolify(h.DatabaseLocked)
	},
	ColorFn: func(h ClusterHealth) tcell.Color {
		if h.DatabaseLocked {
			return tcell.ColorRed
		} else {
			return tcell.ColorWhite
		}
	},
}

var StatEmpty = components.ColumnImpl[ClusterHealth]{
	ColName: "",
	DataFn: func(h ClusterHealth) string {
		return ""
	},
}

var StatReads = components.ColumnImpl[ClusterStats]{
	ColName: "Reads",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.Reads)
	},
}

var StatRebalanceInflight = components.ColumnImpl[ClusterHealth]{
	ColName: "Rebalance In-flight",
	DataFn: func(h ClusterHealth) string {
		return Convert(float64(h.RebalanceInFlight), 1, None)
	},
}

var StatRebalanceQueued = components.ColumnImpl[ClusterHealth]{
	ColName: "Rebalance Queued",
	DataFn: func(h ClusterHealth) string {
		return Convert(float64(h.RebalanceQueued), 1, None)
	},
}

var StatRecoveryDescription = components.ColumnImpl[ClusterHealth]{
	ColName: "Recovery Description",
	DataFn: func(h ClusterHealth) string {
		return h.RecoveryDescription
	},
}

var StatRecoveryState = components.ColumnImpl[ClusterHealth]{
	ColName: "Recovery State",
	DataFn: func(h ClusterHealth) string {
		return h.RecoveryState
	},
}

var StatReplicasRemaining = components.ColumnImpl[ClusterHealth]{
	ColName: "Replicas Remaining",
	DataFn: func(h ClusterHealth) string {
		return fmt.Sprintf("%d", h.MinReplicas)
	},
}

var StatTxCommitted = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Committed",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxCommitted)
	},
}

var StatTxConflicted = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Conflicted",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxConflicted)
	},
}

var StatTxRejected = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Rejected",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxRejected)
	},
}

var StatTxStarted = components.ColumnImpl[ClusterStats]{
	ColName: "Tx Started",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.TxStarted)
	},
}

var StatWrites = components.ColumnImpl[ClusterStats]{
	ColName: "Writes",
	DataFn: func(cs ClusterStats) string {
		return fmt.Sprintf("%0.1f/s", cs.Writes)
	},
}