module ChatModeRegistry

# File lib/chat_mode_registry.rb, line 86
def active?(channel, network: nil)
  SESSIONS_MUTEX.synchronize do
    state = state_for(channel, network: network)
    !!(state && state[:running] && Time.now < state[:ends_at])
  end
end

# File lib/chat_mode_registry.rb, line 76
def clear_persisted(network:, channel:, store: RabbotDb)
  store.set_plugin_json(
    plugin: PLUGIN,
    key: SESSION_KEY,
    network: network,
    channel: channel,
    value: {}
  )
end

# File lib/chat_mode_registry.rb, line 105
def delete(channel, network: nil)
  SESSIONS_MUTEX.synchronize do
    SESSIONS.delete(channel.to_s)
    clear_persisted(network: network, channel: channel) if network
  end
end

# File lib/chat_mode_registry.rb, line 35
def deserialize_state(payload)
  return nil unless payload.is_a?(Hash) && !payload.empty?

  {
    running: payload["running"] == true,
    paused: payload["paused"] == true,
    stop: payload["stop"] == true,
    ends_at: RabbotDb.parse_time(payload["ends_at"]) || Time.now,
    mode: payload["mode"]&.to_sym || :general,
    topic: payload["topic"],
    episode_search: payload["episode_search"],
    episode: payload["episode"],
    episode_title: payload["episode_title"],
    turns_left: payload["turns_left"].to_i,
    burst_remaining: payload["burst_remaining"].to_i,
    long_break_next: payload["long_break_next"] == true
  }
end

# File lib/chat_mode_registry.rb, line 93
def get(channel, network: nil)
  SESSIONS_MUTEX.synchronize { state_for(channel, network: network)&.dup }
end

# File lib/chat_mode_registry.rb, line 66
def load_state(network:, channel:, store: RabbotDb)
  payload = store.get_plugin_json(
    plugin: PLUGIN,
    key: SESSION_KEY,
    network: network,
    channel: channel
  )
  deserialize_state(payload)
end

# File lib/chat_mode_registry.rb, line 54
def persist_state(network:, channel:, state:, store: RabbotDb)
  return unless network && channel

  store.set_plugin_json(
    plugin: PLUGIN,
    key: SESSION_KEY,
    network: network,
    channel: channel,
    value: serialize_state(state)
  )
end

# File lib/chat_mode_registry.rb, line 121
def restore_for_channels!(network:, channels:, store: RabbotDb)
  Array(channels).each do |channel|
    state = load_state(network: network, channel: channel, store: store)
    next unless state
    next unless state[:running]
    next if Time.now >= state[:ends_at]

    SESSIONS_MUTEX.synchronize { SESSIONS[channel.to_s] = state }
  end
end

# File lib/chat_mode_registry.rb, line 18
def serialize_state(state)
  {
    "running" => state[:running] == true,
    "paused" => state[:paused] == true,
    "stop" => state[:stop] == true,
    "ends_at" => RabbotDb.iso_time(state[:ends_at]),
    "mode" => state[:mode].to_s,
    "topic" => state[:topic],
    "episode_search" => state[:episode_search],
    "episode" => state[:episode],
    "episode_title" => state[:episode_title],
    "turns_left" => state[:turns_left].to_i,
    "burst_remaining" => state[:burst_remaining].to_i,
    "long_break_next" => state[:long_break_next] == true
  }
end

# File lib/chat_mode_registry.rb, line 97
def set(channel, state, network: nil)
  SESSIONS_MUTEX.synchronize do
    SESSIONS[channel.to_s] = state
    persist_state(network: network, channel: channel, state: state) if network
    state
  end
end

# File lib/chat_mode_registry.rb, line 132
def state_for(channel, network: nil)
  channel = channel.to_s
  state = SESSIONS[channel]
  return state if state
  return nil unless network

  loaded = load_state(network: network, channel: channel)
  SESSIONS[channel] = loaded if loaded
  loaded
end

# File lib/chat_mode_registry.rb, line 14
def storage_key(network, channel)
  "#{network}/#{channel}"
end

# File lib/chat_mode_registry.rb, line 112
def update(channel, network: nil)
  SESSIONS_MUTEX.synchronize do
    state = state_for(channel, network: network)
    yield state if state
    persist_state(network: network, channel: channel, state: state) if network && state
    state
  end
end