terraform {
  required_providers {
    turingpi = {
      source  = "jfreed-dev/turingpi"
      version = ">= 1.3.0"
    }
  }
}

provider "turingpi" {
  username = "root"                      # or TURINGPI_USERNAME env var
  password = "turing"                    # or TURINGPI_PASSWORD env var
  endpoint = "https://turingpi.local"    # or TURINGPI_ENDPOINT env var (optional)
  insecure = false                       # or TURINGPI_INSECURE env var (optional)
}

provider "turingpi" {}

data "turingpi_info" "bmc" {}

output "firmware_version" {
  value = data.turingpi_info.bmc.firmware_version
}

output "node_power_status" {
  value = data.turingpi_info.bmc.nodes
}

data "turingpi_usb" "current" {}

output "usb_config" {
  value = {
    mode  = data.turingpi_usb.current.mode   # "host" or "device"
    node  = data.turingpi_usb.current.node   # 1-4
    route = data.turingpi_usb.current.route  # "usb-a" or "bmc"
  }
}

data "turingpi_power" "status" {}

output "power_status" {
  value = {
    node1      = data.turingpi_power.status.node1  # true/false
    nodes_on   = data.turingpi_power.status.powered_on_count
    nodes_off  = data.turingpi_power.status.powered_off_count
  }
}

data "turingpi_uart" "node1" {
  node = 1
}

output "node1_output" {
  value = data.turingpi_uart.node1.output
}

data "turingpi_sdcard" "storage" {}

output "sdcard_info" {
  value = {
    total_gb     = data.turingpi_sdcard.storage.total_gb
    free_gb      = data.turingpi_sdcard.storage.free_gb
    used_percent = data.turingpi_sdcard.storage.used_percent
  }
}

data "turingpi_about" "bmc" {}

output "bmc_versions" {
  value = {
    api      = data.turingpi_about.bmc.api_version
    firmware = data.turingpi_about.bmc.firmware_version
    daemon   = data.turingpi_about.bmc.daemon_version
  }
}

resource "turingpi_power" "node1" {
  node  = 1       # Node ID (1-4)
  state = "on"    # "on", "off", or "reset"
}

# Reset (reboot) a node
resource "turingpi_power" "node2_reset" {
  node  = 2
  state = "reset"
}

resource "turingpi_flash" "node1" {
  node          = 1
  firmware_file = "/path/to/firmware.img"
}

resource "turingpi_usb" "node1" {
  node  = 1           # Node ID (1-4)
  mode  = "host"      # "host" or "device"
  route = "usb-a"     # "usb-a" or "bmc" (default: "usb-a")
}

resource "turingpi_network_reset" "switch" {
  triggers = {
    # Reset network when node power changes
    node_states = join(",", [for k, v in turingpi_power.nodes : "${k}:${v.current_state}"])
  }
}

resource "turingpi_bmc_firmware" "upgrade" {
  firmware_file = "/path/to/bmc-firmware.swu"
  timeout       = 300
}

# Or use a file already on the BMC
resource "turingpi_bmc_firmware" "upgrade_local" {
  firmware_file = "/tmp/firmware.swu"
  bmc_local     = true
}

resource "turingpi_uart" "node1_cmd" {
  node    = 1
  command = "echo 'Hello from Terraform'\n"
}

resource "turingpi_bmc_reboot" "maintenance" {
  wait_for_ready = true
  ready_timeout  = 120
}

resource "turingpi_bmc_reload" "daemon" {
  wait_for_ready = true
  ready_timeout  = 30
}

resource "turingpi_usb_boot" "node1" {
  node = 1
}

resource "turingpi_node_to_msd" "node1" {
  node = 1
}

resource "turingpi_clear_usb_boot" "node1" {
  node = 1
}

resource "turingpi_node" "node1" {
  node                 = 1                              # Node ID (1-4)
  power_state          = "on"                           # "on" or "off" (default: "on")
  firmware_file        = "/path/to/firmware.img"        # optional
  boot_check           = true                           # Monitor UART for boot pattern (default: false)
  boot_check_pattern   = "login:"                       # Pattern to detect (default: "login:")
  login_prompt_timeout = 120                            # Timeout in seconds (default: 60)
}

# For Talos Linux, use the appropriate boot pattern:
resource "turingpi_node" "talos" {
  node               = 2
  boot_check         = true
  boot_check_pattern = "machine is running and ready"
}