module Lookbook

def add_input_type(name, partial_path, opts = {})
  Engine.inputs.add_input(name, partial_path, opts)
end

def add_panel(name, partial_path, opts = {})
  Engine.panels.add_panel(name, partial_path, opts)
end

def add_tag(name, args = nil, &block)
  Engine.tags.add_tag(name, {
    named_args: args.to_a,
    after_parse: block
  })
end

def after_change(&block)
  Engine.hooks.add_hook(:after_change, block)
end

def after_initialize(&block)
  Engine.hooks.add_hook(:after_initialize, block)
end

def before_exit(&block)
  Engine.hooks.add_hook(:before_exit, block)
end

def broadcast(event_name, data = {})
  Engine.websocket&.broadcast(event_name.to_s, data)
end

def config
  @_config ||= ConfigStore.init_from_config
end

def configure
  yield(config)
end

def data
  @_data ||= Store.new
end

def data=(new_data)
  @_data = Store.new(new_data)
end

def debug_data
  {
    version: version,
    env: Rails.env.to_s,
    config: [
      config.to_h,
      {
        dependencies: {
          actioncable: Engine.runtime_context.actioncable_installed?,
          listen: Engine.runtime_context.listen_installed?,
          view_component: config.using_view_component
        }
      },
      {panels: Engine.panels.to_h.reject { |k, v| v[:system] }},
      {inputs: Engine.inputs.to_h.reject { |k, v| v[:system] }},
      {tags: Engine.tags.to_h.reject { |k, v| v[:system] }}
    ].inject(:merge)
  }
end

def engine
  Engine
end

def logger
  @_logger ||= if Rails.logger.present? && config.log_use_rails_logger
    Rails.logger
  else
    logger = Logger.new($stdout)
    logger.level = config.log_level
    logger
  end
end

def pages
  Engine.pages.to_a
end

def previews
  Engine.previews.to_a
end

def remove_panel(name)
  Engine.panels.remove_panel(name)
end

def update_panel(name, opts)
  Engine.panels.update_panel(name, opts)
end

def version
  Lookbook::VERSION
end