graph TD
    A["Phase 1: PON Engine & Adjacency Registry"] --> B["Phase 2: Decoupled Telemetry & TUI"]
    B --> C["Phase 3: Rustler JSON Parser NIF"]
    C --> D["Phase 4: 0ns Config Compiler Hot-Swap"]
    D --> E["Phase 5: Private API HMAC Authentication"]

defmodule SignalPro.Engine do
  use GenServer

  @table :tickers

  def init(state) do
    # Create the ETS table with read concurrency optimized for HFT
    :ets.new(@table, [:named_table, :public, read_concurrency: true])
    {:ok, state}
  end

  def update_ticker(symbol, bid_price, bid_qty, ask_price, ask_qty) do
    case get_ticker(symbol) do
      {:ok, existing} when existing.bid == bid_price and existing.ask == ask_price and existing.bid_qty == bid_qty and existing.ask_qty == ask_qty ->
        # Blocked Flicker: State has not mutated; abort immediately to save CPU
        :ok

      _ ->
        now = System.monotonic_time(:nanosecond)
        :ets.insert(@table, {symbol, bid_price, bid_qty, ask_price, ask_qty, now})

        # Point-to-Point Notification Dispatch
        Registry.dispatch(SignalPro.Registry, symbol, fn entries ->
          for {pid, _value} <- entries, do: send(pid, {:ticker_changed, symbol})
        end)
    end
  end
end

defmodule SignalPro.TriangleRule do
  use GenServer

  def init(cycle) do
    # Register to the 3 symbols in the cycle
    for trade <- cycle.trades do
      {:ok, _} = Registry.register(SignalPro.Registry, trade.pair, nil)
    end

    {:ok, %{cycle: cycle}}
  end

  def handle_info({:ticker_changed, _symbol}, state) do
    # Mailbox Conflation: drain stale messages to prevent queue backlog
    drain_notifications()

    evaluate_rule(state.cycle)
    {:noreply, state}
  end

  defp drain_notifications do
    receive do
      {:ticker_changed, _symbol} -> drain_notifications()
    after
      0 -> :ok
    end
  end
end

defmodule SignalPro.TelemetryLogger do
  def setup do
    :telemetry.attach("logger", [:signal_pro, :arbitrage], &__MODULE__.handle_event/4, nil)
  end

  def handle_event([:signal_pro, :arbitrage], measurements, metadata, _config) do
    path = metadata.path
    status = Map.get(metadata, :status, "UNKNOWN")
    profit = measurements.profit
    proc_latency_ns = measurements.latency
    budget_ns = SignalPro.Config.max_latency_ns() - proc_latency_ns

    type = if status == "VIABLE", do: :positive, else: :negative

    # Async Cast to the satellite TUI process
    SignalPro.TerminalDashboard.record_opportunity(type, path, profit, proc_latency_ns, budget_ns, status)
  end
end

defmodule SignalPro.TerminalDashboard do
  use GenServer

  @refresh_interval 200 # 5Hz

  def init(_opts) do
    schedule_redraw()
    {:ok, %{positives_count: 0, negatives_count: 0, last_positive: nil, last_negative: nil}}
  end

  def handle_info(:redraw, state) do
    # Clear screen and render aggregated layout
    IO.write("\e[H\e[2J")
    render_layout(state)
    schedule_redraw()
    {:noreply, state}
  end

  defp schedule_redraw, do: Process.send_after(self(), :redraw, @refresh_interval)
end

use rustler::NifTuple;
use serde::Deserialize;

#[allow(non_snake_case)]
#[derive(Deserialize)]
struct BinanceBookTicker {
    s: String, // symbol
    b: String, // bid
    B: String, // bidQty
    a: String, // ask
    A: String, // askQty
}

#[derive(NifTuple)]
struct TickerTuple {
    symbol: String,
    bid: f64,
    bid_qty: f64,
    ask: f64,
    ask_qty: f64,
}

#[rustler::nif]
fn parse_ticker(json_str: String) -> Option<TickerTuple> {
    let ticker: BinanceBookTicker = serde_json::from_str(&json_str).ok()?;
    let bid = ticker.b.parse::<f64>().ok()?;
    let bid_qty = ticker.B.parse::<f64>().ok()?;
    let ask = ticker.a.parse::<f64>().ok()?;
    let ask_qty = ticker.A.parse::<f64>().ok()?;

    Some(TickerTuple {
        symbol: ticker.s.to_lowercase(),
        bid,
        bid_qty,
        ask,
        ask_qty,
    })
}

rustler::init!("Elixir.SignalPro.Nif");

defmodule SignalPro.ConfigCompiler do
  @behaviour SignalPro.ConfigCompiler.Behaviour

  def compile_and_load(opts \\ %{}) do
    max_latency = Map.get(opts, :max_latency_ns) || 10_000_000
    default_fee = Map.get(opts, :default_taker_fee) || 0.001

    source = """
    defmodule SignalPro.Config.Dynamic do
      @moduledoc false
      def max_latency_ns, do: #{max_latency}
      def default_taker_fee, do: #{default_fee}
    end
    """

    # Compile source string in-memory and dynamically swap bytecode in VM
    Code.compiler_options(ignore_already_consolidated: true)
    [{SignalPro.Config.Dynamic, _binary}] = Code.compile_string(source)
    :ok
  end
end

defmodule SignalPro.Config do
  @default_max_latency 10_000_000
  @default_fee 0.001

  # Facade read calls (Resolves to precompiled Dynamic literals at runtime)
  def max_latency_ns do
    if Code.ensure_loaded?(SignalPro.Config.Dynamic) do
      SignalPro.Config.Dynamic.max_latency_ns()
    else
      @default_max_latency
    end
  end

  def default_taker_fee do
    if Code.ensure_loaded?(SignalPro.Config.Dynamic) do
      SignalPro.Config.Dynamic.default_taker_fee()
    else
      @default_fee
    end
  end
end

defmodule SignalPro.BinanceAuth do
  def compute_signature(query_string, secret_key) do
    :crypto.mac(:hmac, :sha256, secret_key, query_string)
    |> Base.encode16(case: :lower)
  end
end

defmodule SignalPro.FeeManager do
  use GenServer

  @refresh_interval 30 * 60 * 1000 # 30 mins

  def handle_info(:refresh_fees, state) do
    api_key = System.get_env("BINANCE_API_KEY")
    secret_key = System.get_env("BINANCE_SECRET_KEY")

    if api_key && secret_key do
      case fetch_binance_fees(api_key, secret_key) do
        {:ok, new_taker_fee} ->
          # Trigger Dynamic Facade Bytecode Compilation
          SignalPro.Config.compile_and_load(%{default_taker_fee: new_taker_fee})
        _error ->
          :ok
      end
    end

    schedule_next()
    {:noreply, state}
  end
end