class ViteRuby::Manifest

def extension_for_type(entry_type)
  case entry_type
  when :javascript then 'js'
  when :stylesheet then 'css'
  when :typescript then 'ts'
  else entry_type
  end
end

def find_manifest_entry: (String name) -> untyped

def find_manifest_entry(name)
  if dev_server_running?
    { 'file' => prefix_vite_asset(name) }
  else
    manifest[name]
  end
end

def initialize(vite_ruby)
  @vite_ruby = vite_ruby
  @build_mutex = Mutex.new if config.auto_build
end

def load_manifest
  files = config.manifest_paths
  files.map { |path| JSON.parse(path.read) }.inject({}, &:merge).tap(&method(:resolve_references))
end

def lookup(name, **options)
  @build_mutex.synchronize { builder.build || (return nil) } if should_build?
  find_manifest_entry resolve_entry_name(name, **options)
end

def lookup!(name, **options)
  lookup(name, **options) || missing_entry_error(name, **options)
end

def manifest
  return refresh if config.auto_build
  @manifest ||= load_manifest
end

def missing_entry_error(name, **options)
  raise ViteRuby::MissingEntrypointError, OpenStruct.new(
    file_name: resolve_entry_name(name, **options),
    last_build: builder.last_build_metadata,
    manifest: @manifest,
    config: config,
  )
end

def path_for(name, **options)
  lookup!(name, **options).fetch('file')
end

def prefix_asset_with_host(path)
  File.join(vite_asset_origin || config.asset_host || '/', config.public_output_dir, path)
end

def prefix_vite_asset(path)
  File.join(vite_asset_origin || '/', config.public_output_dir, path)
end

def react_preamble_code
  if dev_server_running?
    <<~REACT_PREAMBLE_CODE
      import RefreshRuntime from '#{ prefix_asset_with_host('@react-refresh') }'
      RefreshRuntime.injectIntoGlobalHook(window)
      window.$RefreshReg$ = () => {}
      window.$RefreshSig$ = () => (type) => type
      window.__vite_plugin_react_preamble_installed__ = true
    REACT_PREAMBLE_CODE
  end
end

def react_refresh_preamble
  if dev_server_running?
    <<~REACT_REFRESH
      <script type="module">
        #{ react_preamble_code }
      </script>
    REACT_REFRESH
  end
end

def refresh
  @manifest = load_manifest
end

def resolve_absolute_entry(name)
  if dev_server_running?
    File.join(FS_PREFIX, config.root, name)
  else
    config.root.join(name).relative_path_from(config.vite_root_dir).to_s
  end
end

def resolve_entries(*names, **options)
  entries = names.map { |name| lookup!(name, **options) }
  script_paths = entries.map { |entry| entry.fetch('file') }
  imports = dev_server_running? ? [] : entries.flat_map { |entry| entry['imports'] }.compact.uniq
  {
    scripts: script_paths,
    imports: imports.map { |entry| entry.fetch('file') }.uniq,
    stylesheets: dev_server_running? ? [] : (entries + imports).flat_map { |entry| entry['css'] }.compact.uniq,
  }
end

def resolve_entry_name(name, type: nil)
  return resolve_virtual_entry(name) if type == :virtual
  name = with_file_extension(name.to_s, type)
  raise ArgumentError, "Asset names can not be relative. Found: #{ name }" if name.start_with?('.')
  # Explicit path, relative to the source_code_dir.
  name.sub(%r{^~/(.+)$}) { return Regexp.last_match(1) }
  # Explicit path, relative to the project root.
  name.sub(%r{^/(.+)$}) { return resolve_absolute_entry(Regexp.last_match(1)) }
  # Sugar: Prefix with the entrypoints dir if the path is not nested.
  name.include?('/') ? name : File.join(config.entrypoints_dir, name)
end

def resolve_references(manifest)
  manifest.each_value do |entry|
    entry['file'] = prefix_vite_asset(entry['file'])
    %w[css assets].each do |key|
      entry[key] = entry[key].map { |path| prefix_vite_asset(path) } if entry[key]
    end
    entry['imports']&.map! { |name| manifest.fetch(name) }
  end
end

def resolve_virtual_entry(name)
  manifest.keys.find { |file| file.include?(name) } || name
end

def should_build?
  config.auto_build && !dev_server_running?
end

def vite_asset_origin
  config.origin if dev_server_running? && config.skip_proxy
end

def vite_client_src
  prefix_asset_with_host('@vite/client') if dev_server_running?
end

def with_file_extension(name, entry_type)
  if File.extname(name).empty? && (ext = extension_for_type(entry_type))
    "#{ name }.#{ ext }"
  else
    name
  end
end