towerops/lib/towerops_web/controllers/api/mobile_controller.ex

defmodule ToweropsWeb.Api.MobileController do
  @moduledoc """
  API controller for mobile app data access.

  All endpoints require mobile authentication via bearer token.
  """
  use ToweropsWeb, :controller

  alias Towerops.Alerts
  alias Towerops.Equipment
  alias Towerops.Organizations
  alias Towerops.Sites

  @doc """
  GET /api/v1/mobile/organizations

  Returns list of organizations the user has access to.

  Response:
  {
    "organizations": [
      {
        "id": "uuid",
        "name": "Acme Corp",
        "sites_count": 3,
        "equipment_count": 15,
        "active_alerts_count": 2
      }
    ]
  }
  """
  def list_organizations(conn, _params) do
    user = conn.assigns.current_user

    organizations =
      user.id
      |> Organizations.list_user_organizations()
      |> Enum.map(fn org ->
        %{
          id: org.id,
          name: org.name,
          sites_count: Sites.count_organization_sites(org.id),
          equipment_count: Equipment.count_organization_equipment(org.id),
          active_alerts_count: Alerts.count_active_alerts(org.id)
        }
      end)

    json(conn, %{organizations: organizations})
  end

  @doc """
  GET /api/v1/mobile/organizations/:id/sites

  Returns list of sites for an organization.

  Response:
  {
    "sites": [
      {
        "id": "uuid",
        "name": "Main Office",
        "location": "New York, NY",
        "equipment_count": 5,
        "equipment_down_count": 1
      }
    ]
  }
  """
  def list_sites(conn, %{"organization_id" => org_id}) do
    user = conn.assigns.current_user

    case verify_organization_access(user, org_id) do
      {:ok, _org} ->
        sites =
          org_id
          |> Sites.list_organization_sites()
          |> Enum.map(fn site ->
            %{
              id: site.id,
              name: site.name,
              location: site.location,
              equipment_count: Equipment.count_site_equipment(site.id),
              equipment_down_count: Equipment.count_site_equipment_down(site.id)
            }
          end)

        json(conn, %{sites: sites})

      {:error, :unauthorized} ->
        conn
        |> put_status(:forbidden)
        |> json(%{error: "Access denied to this organization"})
    end
  end

  @doc """
  GET /api/v1/mobile/organizations/:id/equipment

  Returns list of equipment for an organization with current status.

  Query params:
  - site_id: Filter by site (optional)
  - status: Filter by status: "up", "down", "unknown" (optional)

  Response:
  {
    "equipment": [
      {
        "id": "uuid",
        "name": "Core Router",
        "ip_address": "192.168.1.1",
        "site_name": "Main Office",
        "status": "up",
        "uptime": "15 days, 4 hours",
        "last_seen_at": "2026-01-15T19:44:25Z"
      }
    ]
  }
  """
  def list_equipment(conn, %{"organization_id" => org_id} = params) do
    user = conn.assigns.current_user

    case verify_organization_access(user, org_id) do
      {:ok, _org} ->
        equipment_list =
          org_id
          |> Equipment.list_organization_equipment(params)
          |> Enum.map(&format_equipment/1)

        json(conn, %{equipment: equipment_list})

      {:error, :unauthorized} ->
        conn
        |> put_status(:forbidden)
        |> json(%{error: "Access denied to this organization"})
    end
  end

  @doc """
  GET /api/v1/mobile/equipment/:id

  Returns detailed equipment information including interfaces and sensors.

  Response:
  {
    "id": "uuid",
    "name": "Core Router",
    "ip_address": "192.168.1.1",
    "status": "up",
    "uptime": "15 days, 4 hours",
    "site": {"id": "uuid", "name": "Main Office"},
    "interfaces": [...],
    "sensors": [...]
  }
  """
  def get_equipment(conn, %{"id" => equipment_id}) do
    user = conn.assigns.current_user

    case Equipment.get_equipment_with_details(equipment_id) do
      nil ->
        conn
        |> put_status(:not_found)
        |> json(%{error: "Equipment not found"})

      equipment ->
        case verify_organization_access(user, equipment.organization_id) do
          {:ok, _org} ->
            json(conn, format_equipment_details(equipment))

          {:error, :unauthorized} ->
            conn
            |> put_status(:forbidden)
            |> json(%{error: "Access denied to this equipment"})
        end
    end
  end

  @doc """
  GET /api/v1/mobile/organizations/:id/alerts

  Returns list of alerts for an organization.

  Query params:
  - severity: Filter by severity: "critical", "warning", "info" (optional)
  - status: Filter by status: "active", "acknowledged", "resolved" (optional)
  - limit: Number of alerts to return (default 50, max 200)

  Response:
  {
    "alerts": [
      {
        "id": "uuid",
        "severity": "critical",
        "status": "active",
        "message": "Equipment Down: Core Router",
        "equipment_name": "Core Router",
        "equipment_id": "uuid",
        "occurred_at": "2026-01-15T19:44:25Z"
      }
    ]
  }
  """
  def list_alerts(conn, %{"organization_id" => org_id} = params) do
    user = conn.assigns.current_user

    case verify_organization_access(user, org_id) do
      {:ok, _org} ->
        limit = min(String.to_integer(params["limit"] || "50"), 200)

        alerts =
          org_id
          |> Alerts.list_organization_alerts(Map.put(params, "limit", limit))
          |> Enum.map(&format_alert/1)

        json(conn, %{alerts: alerts})

      {:error, :unauthorized} ->
        conn
        |> put_status(:forbidden)
        |> json(%{error: "Access denied to this organization"})
    end
  end

  # Private helpers

  defp verify_organization_access(user, org_id) do
    if Organizations.user_has_access?(user.id, org_id) do
      {:ok, org_id}
    else
      {:error, :unauthorized}
    end
  end

  defp format_equipment(equipment) do
    %{
      id: equipment.id,
      name: equipment.name,
      ip_address: equipment.ip_address,
      site_name: equipment.site && equipment.site.name,
      status: equipment.status || "unknown",
      uptime: format_uptime(equipment),
      last_seen_at: equipment.last_seen_at
    }
  end

  defp format_equipment_details(equipment) do
    %{
      id: equipment.id,
      name: equipment.name,
      ip_address: equipment.ip_address,
      status: equipment.status || "unknown",
      uptime: format_uptime(equipment),
      site: %{
        id: equipment.site.id,
        name: equipment.site.name
      },
      interfaces:
        Enum.map(equipment.snmp_device.interfaces || [], fn interface ->
          %{
            id: interface.id,
            name: interface.if_name,
            alias: interface.if_alias,
            status: interface.if_oper_status,
            admin_status: interface.if_admin_status,
            speed: interface.if_speed,
            mac_address: interface.if_phys_address
          }
        end),
      sensors:
        Enum.map(equipment.snmp_device.sensors || [], fn sensor ->
          %{
            id: sensor.id,
            name: sensor.name,
            type: sensor.sensor_type,
            unit: sensor.unit,
            current_value: sensor.current_value,
            status: sensor.status
          }
        end)
    }
  end

  defp format_alert(alert) do
    %{
      id: alert.id,
      severity: alert.severity,
      status: alert.status,
      message: alert.message,
      equipment_name: alert.equipment && alert.equipment.name,
      equipment_id: alert.equipment_id,
      occurred_at: alert.occurred_at
    }
  end

  defp format_uptime(equipment) do
    if equipment.snmp_device && equipment.snmp_device.sys_uptime do
      timeticks_to_string(equipment.snmp_device.sys_uptime)
    end
  end

  defp timeticks_to_string(timeticks) do
    seconds = div(timeticks, 100)
    days = div(seconds, 86_400)
    hours = div(rem(seconds, 86_400), 3600)
    minutes = div(rem(seconds, 3600), 60)

    cond do
      days > 0 -> "#{days}d #{hours}h"
      hours > 0 -> "#{hours}h #{minutes}m"
      true -> "#{minutes}m"
    end
  end
end