// Copyright 2025 International Digital Economy Academy
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

///|
pub(all) struct ProcessRefreshKind {
  cpu : Bool
  disk_usage : Bool
  memory : Bool
  user : UpdateKind
  cwd : UpdateKind
  root : UpdateKind
  environ : UpdateKind
  cmd : UpdateKind
  exe : UpdateKind
  tasks : Bool
} derive(Debug, Eq)

///|
pub fn ProcessRefreshKind::nothing() -> ProcessRefreshKind {
  {
    cpu: false,
    disk_usage: false,
    memory: false,
    user: UpdateKind::Never,
    cwd: UpdateKind::Never,
    root: UpdateKind::Never,
    environ: UpdateKind::Never,
    cmd: UpdateKind::Never,
    exe: UpdateKind::Never,
    tasks: true,
  }
}

///|
pub fn ProcessRefreshKind::everything() -> ProcessRefreshKind {
  {
    cpu: true,
    disk_usage: true,
    memory: true,
    user: UpdateKind::OnlyIfNotSet,
    cwd: UpdateKind::OnlyIfNotSet,
    root: UpdateKind::OnlyIfNotSet,
    environ: UpdateKind::OnlyIfNotSet,
    cmd: UpdateKind::OnlyIfNotSet,
    exe: UpdateKind::OnlyIfNotSet,
    tasks: true,
  }
}

///|
pub fn ProcessRefreshKind::cpu(self : ProcessRefreshKind) -> Bool {
  self.cpu
}

///|
pub fn ProcessRefreshKind::with_cpu(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, cpu: true }
}

///|
pub fn ProcessRefreshKind::without_cpu(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, cpu: false }
}

///|
pub fn ProcessRefreshKind::disk_usage(self : ProcessRefreshKind) -> Bool {
  self.disk_usage
}

///|
pub fn ProcessRefreshKind::with_disk_usage(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, disk_usage: true }
}

///|
pub fn ProcessRefreshKind::without_disk_usage(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, disk_usage: false }
}

///|
pub fn ProcessRefreshKind::memory(self : ProcessRefreshKind) -> Bool {
  self.memory
}

///|
pub fn ProcessRefreshKind::with_memory(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, memory: true }
}

///|
pub fn ProcessRefreshKind::without_memory(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, memory: false }
}

///|
pub fn ProcessRefreshKind::user(self : ProcessRefreshKind) -> UpdateKind {
  self.user
}

///|
pub fn ProcessRefreshKind::with_user(
  self : ProcessRefreshKind,
  kind : UpdateKind,
) -> ProcessRefreshKind {
  { ..self, user: kind }
}

///|
pub fn ProcessRefreshKind::without_user(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, user: UpdateKind::Never }
}

///|
pub fn ProcessRefreshKind::cwd(self : ProcessRefreshKind) -> UpdateKind {
  self.cwd
}

///|
pub fn ProcessRefreshKind::with_cwd(
  self : ProcessRefreshKind,
  kind : UpdateKind,
) -> ProcessRefreshKind {
  { ..self, cwd: kind }
}

///|
pub fn ProcessRefreshKind::without_cwd(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, cwd: UpdateKind::Never }
}

///|
pub fn ProcessRefreshKind::root(self : ProcessRefreshKind) -> UpdateKind {
  self.root
}

///|
pub fn ProcessRefreshKind::with_root(
  self : ProcessRefreshKind,
  kind : UpdateKind,
) -> ProcessRefreshKind {
  { ..self, root: kind }
}

///|
pub fn ProcessRefreshKind::without_root(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, root: UpdateKind::Never }
}

///|
pub fn ProcessRefreshKind::environ(self : ProcessRefreshKind) -> UpdateKind {
  self.environ
}

///|
pub fn ProcessRefreshKind::with_environ(
  self : ProcessRefreshKind,
  kind : UpdateKind,
) -> ProcessRefreshKind {
  { ..self, environ: kind }
}

///|
pub fn ProcessRefreshKind::without_environ(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, environ: UpdateKind::Never }
}

///|
pub fn ProcessRefreshKind::cmd(self : ProcessRefreshKind) -> UpdateKind {
  self.cmd
}

///|
pub fn ProcessRefreshKind::with_cmd(
  self : ProcessRefreshKind,
  kind : UpdateKind,
) -> ProcessRefreshKind {
  { ..self, cmd: kind }
}

///|
pub fn ProcessRefreshKind::without_cmd(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, cmd: UpdateKind::Never }
}

///|
pub fn ProcessRefreshKind::exe(self : ProcessRefreshKind) -> UpdateKind {
  self.exe
}

///|
pub fn ProcessRefreshKind::with_exe(
  self : ProcessRefreshKind,
  kind : UpdateKind,
) -> ProcessRefreshKind {
  { ..self, exe: kind }
}

///|
pub fn ProcessRefreshKind::without_exe(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, exe: UpdateKind::Never }
}

///|
pub fn ProcessRefreshKind::tasks(self : ProcessRefreshKind) -> Bool {
  self.tasks
}

///|
pub fn ProcessRefreshKind::with_tasks(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, tasks: true }
}

///|
pub fn ProcessRefreshKind::without_tasks(
  self : ProcessRefreshKind,
) -> ProcessRefreshKind {
  { ..self, tasks: false }
}

///|
pub(all) struct CpuRefreshKind {
  cpu_usage : Bool
  frequency : Bool
} derive(Debug, Eq)

///|
pub fn CpuRefreshKind::nothing() -> CpuRefreshKind {
  { cpu_usage: false, frequency: false }
}

///|
pub fn CpuRefreshKind::everything() -> CpuRefreshKind {
  { cpu_usage: true, frequency: true }
}

///|
pub fn CpuRefreshKind::cpu_usage(self : CpuRefreshKind) -> Bool {
  self.cpu_usage
}

///|
pub fn CpuRefreshKind::with_cpu_usage(self : CpuRefreshKind) -> CpuRefreshKind {
  { ..self, cpu_usage: true }
}

///|
pub fn CpuRefreshKind::without_cpu_usage(
  self : CpuRefreshKind,
) -> CpuRefreshKind {
  { ..self, cpu_usage: false }
}

///|
pub fn CpuRefreshKind::frequency(self : CpuRefreshKind) -> Bool {
  self.frequency
}

///|
pub fn CpuRefreshKind::with_frequency(self : CpuRefreshKind) -> CpuRefreshKind {
  { ..self, frequency: true }
}

///|
pub fn CpuRefreshKind::without_frequency(
  self : CpuRefreshKind,
) -> CpuRefreshKind {
  { ..self, frequency: false }
}

///|
pub(all) struct MemoryRefreshKind {
  ram : Bool
  swap : Bool
} derive(Debug, Eq)

///|
pub fn MemoryRefreshKind::nothing() -> MemoryRefreshKind {
  { ram: false, swap: false }
}

///|
pub fn MemoryRefreshKind::everything() -> MemoryRefreshKind {
  { ram: true, swap: true }
}

///|
pub fn MemoryRefreshKind::ram(self : MemoryRefreshKind) -> Bool {
  self.ram
}

///|
pub fn MemoryRefreshKind::with_ram(
  self : MemoryRefreshKind,
) -> MemoryRefreshKind {
  { ..self, ram: true }
}

///|
pub fn MemoryRefreshKind::without_ram(
  self : MemoryRefreshKind,
) -> MemoryRefreshKind {
  { ..self, ram: false }
}

///|
pub fn MemoryRefreshKind::swap(self : MemoryRefreshKind) -> Bool {
  self.swap
}

///|
pub fn MemoryRefreshKind::with_swap(
  self : MemoryRefreshKind,
) -> MemoryRefreshKind {
  { ..self, swap: true }
}

///|
pub fn MemoryRefreshKind::without_swap(
  self : MemoryRefreshKind,
) -> MemoryRefreshKind {
  { ..self, swap: false }
}

///|
pub(all) struct RefreshKind {
  processes : ProcessRefreshKind?
  memory : MemoryRefreshKind?
  cpu : CpuRefreshKind?
} derive(Debug, Eq)

///|
pub fn RefreshKind::nothing() -> RefreshKind {
  { processes: None, memory: None, cpu: None }
}

///|
pub fn RefreshKind::everything() -> RefreshKind {
  {
    processes: Some(ProcessRefreshKind::everything()),
    memory: Some(MemoryRefreshKind::everything()),
    cpu: Some(CpuRefreshKind::everything()),
  }
}

///|
pub fn RefreshKind::processes(self : RefreshKind) -> ProcessRefreshKind? {
  self.processes
}

///|
pub fn RefreshKind::with_processes(
  self : RefreshKind,
  kind : ProcessRefreshKind,
) -> RefreshKind {
  { ..self, processes: Some(kind) }
}

///|
pub fn RefreshKind::without_processes(self : RefreshKind) -> RefreshKind {
  { ..self, processes: None }
}

///|
pub fn RefreshKind::memory(self : RefreshKind) -> MemoryRefreshKind? {
  self.memory
}

///|
pub fn RefreshKind::with_memory(
  self : RefreshKind,
  kind : MemoryRefreshKind,
) -> RefreshKind {
  { ..self, memory: Some(kind) }
}

///|
pub fn RefreshKind::without_memory(self : RefreshKind) -> RefreshKind {
  { ..self, memory: None }
}

///|
pub fn RefreshKind::cpu(self : RefreshKind) -> CpuRefreshKind? {
  self.cpu
}

///|
pub fn RefreshKind::with_cpu(
  self : RefreshKind,
  kind : CpuRefreshKind,
) -> RefreshKind {
  { ..self, cpu: Some(kind) }
}

///|
pub fn RefreshKind::without_cpu(self : RefreshKind) -> RefreshKind {
  { ..self, cpu: None }
}

///|
pub(all) struct DiskRefreshKind {
  kind : Bool
  storage : Bool
  io_usage : Bool
} derive(Debug, Eq)

///|
pub fn DiskRefreshKind::nothing() -> DiskRefreshKind {
  { kind: false, storage: false, io_usage: false }
}

///|
pub fn DiskRefreshKind::everything() -> DiskRefreshKind {
  { kind: true, storage: true, io_usage: true }
}

///|
pub fn DiskRefreshKind::kind(self : DiskRefreshKind) -> Bool {
  self.kind
}

///|
pub fn DiskRefreshKind::with_kind(self : DiskRefreshKind) -> DiskRefreshKind {
  { ..self, kind: true }
}

///|
pub fn DiskRefreshKind::without_kind(self : DiskRefreshKind) -> DiskRefreshKind {
  { ..self, kind: false }
}

///|
pub fn DiskRefreshKind::storage(self : DiskRefreshKind) -> Bool {
  self.storage
}

///|
pub fn DiskRefreshKind::with_storage(self : DiskRefreshKind) -> DiskRefreshKind {
  { ..self, storage: true }
}

///|
pub fn DiskRefreshKind::without_storage(
  self : DiskRefreshKind,
) -> DiskRefreshKind {
  { ..self, storage: false }
}

///|
pub fn DiskRefreshKind::io_usage(self : DiskRefreshKind) -> Bool {
  self.io_usage
}

///|
pub fn DiskRefreshKind::with_io_usage(
  self : DiskRefreshKind,
) -> DiskRefreshKind {
  { ..self, io_usage: true }
}

///|
pub fn DiskRefreshKind::without_io_usage(
  self : DiskRefreshKind,
) -> DiskRefreshKind {
  { ..self, io_usage: false }
}