Proyecto: Monitor Web Autónomo

defmodule SensorWeb do
  @moduledoc """
  Componente de percepción. Transforma datos del entorno
  digital (APIs, HTML) en perceptos estructurados.
  """

  @doc """
  Obtiene el precio actual de Bitcoin desde CoinGecko.
  """
  def precio_bitcoin do
    url = "https://api.coingecko.com/api/v3/simple/price" <>
          "?ids=bitcoin&vs_currencies=usd&include_24hr_change=true"

    case Req.get(url) do
      {:ok, %{status: 200, body: body}} ->
        btc = body["bitcoin"]
        {:ok, %{
          asset: "bitcoin",
          precio_usd: btc["usd"],
          cambio_24h: Float.round(btc["usd_24h_change"] || 0.0, 2),
          timestamp: DateTime.utc_now()
        }}

      {:ok, %{status: status}} ->
        {:error, "HTTP #{status}"}

      {:error, exception} ->
        {:error, Exception.message(exception)}
    end
  end

  @doc """
  Sensor genérico: extrae texto de una página web usando un selector CSS.
  """
  def scrape_texto(url, selector) do
    case Req.get(url) do
      {:ok, %{status: 200, body: html}} when is_binary(html) ->
        texto =
          html
          |> Floki.parse_document!()
          |> Floki.find(selector)
          |> Floki.text()
          |> String.trim()

        {:ok, texto}

      {:ok, %{status: status}} ->
        {:error, "HTTP #{status}"}

      {:error, exception} ->
        {:error, Exception.message(exception)}
    end
  end
end

defmodule AgenteMonitor do
  use GenServer
  require Logger

  @moduledoc """
  Agente autónomo que monitorea precios de criptomonedas.
  Implementa el ciclo: Percibir → Decidir → Actuar.
  """

  defstruct [
    :intervalo,
    :umbral,
    :ultimo_precio,
    historial: [],
    alertas: 0
  ]

  # --- API Pública ---

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  @doc "Consulta el estado actual del agente."
  def estado, do: GenServer.call(__MODULE__, :estado)

  @doc "Consulta el historial de precios observados."
  def historial, do: GenServer.call(__MODULE__, :historial)

  # --- Callbacks del GenServer ---

  @impl true
  def init(opts) do
    state = %__MODULE__{
      intervalo: Keyword.get(opts, :intervalo, 60_000),
      umbral: Keyword.get(opts, :umbral, 5.0)
    }

    Logger.info("🤖 Agente Monitor iniciado")
    Logger.info("   📊 Intervalo: #{div(state.intervalo, 1000)}s")
    Logger.info("   🎯 Umbral de alerta: #{state.umbral}%")

    # Primer chequeo inmediato
    send(self(), :ciclo_percepcion)
    {:ok, state}
  end

  @impl true
  def handle_info(:ciclo_percepcion, state) do
    state = ejecutar_ciclo(state)

    # Programar siguiente ciclo
    Process.send_after(self(), :ciclo_percepcion, state.intervalo)
    {:noreply, state}
  end

  @impl true
  def handle_call(:estado, _from, state) do
    resumen = %{
      ultimo_precio: state.ultimo_precio,
      total_observaciones: length(state.historial),
      alertas_emitidas: state.alertas,
      umbral: state.umbral
    }
    {:reply, resumen, state}
  end

  @impl true
  def handle_call(:historial, _from, state) do
    {:reply, Enum.take(state.historial, 10), state}
  end

  # --- Lógica del Agente ---

  defp ejecutar_ciclo(state) do
    case SensorWeb.precio_bitcoin() do
      {:ok, percepto} ->
        procesar_percepto(state, percepto)

      {:error, razon} ->
        Logger.error("❌ Fallo en percepción: #{razon}")
        state
    end
  end

  defp procesar_percepto(state, %{precio_usd: precio, cambio_24h: cambio} = percepto) do
    Logger.info("📊 BTC: $#{precio} | Cambio 24h: #{cambio}%")

    # DECISIÓN: ¿El cambio supera nuestro umbral?
    state = if abs(cambio) > state.umbral do
      # ACCIÓN: Emitir alerta
      emitir_alerta(precio, cambio)
      %{state | alertas: state.alertas + 1}
    else
      state
    end

    # Actualizar modelo interno
    %{state |
      ultimo_precio: precio,
      historial: [percepto | Enum.take(state.historial, 99)]
    }
  end

  defp emitir_alerta(precio, cambio) do
    {emoji, direccion} = if cambio > 0, do: {"📈", "SUBIDA"}, else: {"📉", "BAJADA"}

    Logger.warning("""
    ⚠️  ALERTA DE #{direccion} #{emoji}
        Precio: $#{precio}
        Cambio: #{abs(cambio)}% en 24h
    """)
  end
end

defmodule WebSensorApp do
  use Application

  @impl true
  def start(_type, _args) do
    children = [
      {AgenteMonitor, intervalo: 60_000, umbral: 5.0}
    ]

    opts = [strategy: :one_for_one, name: WebSensor.Supervisor]
    Supervisor.start_link(children, opts)
  end
end