class Pies

# File plugins/pies.rb, line 264
def self.address_field(place, *keys)
  data = place.data if place.respond_to?(:data)
  return nil unless data.is_a?(Hash)

  addr = data["address"] || data[:address] || {}
  keys.each do |key|
    value = addr[key] || addr[key.to_sym]
    return value.to_s.strip unless value.to_s.strip.empty?
  end

  nil
end

# File plugins/pies.rb, line 301
def self.area_search_locations(resolved, search: Geocoder.method(:search))
  locations = []
  primary = resolved[:search_query].to_s.strip
  locations << primary unless primary.empty?

  place = resolved[:place]
  return locations unless place

  suburb = place_name_from_result(place)
  if suburb && !suburb.empty? && suburb != primary
    locations << suburb unless locations.include?(suburb)
  end

  state = state_abbrev_from_result(place)
  parent = parent_area_label(place, search: search)
  locations << parent if parent && !locations.include?(parent)

  postcode = postcode_from_place(place)
  if postcode && state
    postcode_label = "#{postcode} #{state}"
    locations << postcode_label unless locations.include?(postcode_label)
  end

  locations
end

# File plugins/pies.rb, line 668
def self.banner_title(place, location)
  town = location.to_s.split(",").first.to_s.strip
  town = location.to_s.strip if town.empty?
  "#{town} · #{place}"
end

# File plugins/pies.rb, line 496
def self.build_menu_image_prompt(image_path:)
  parts = [
    "@#{image_path}",
    "",
    "View the attached image and extract all readable text from this bakery or cafe menu photo.",
    "Focus on pie names and prices if present.",
    "Output ONLY the extracted plain text, line by line. No markdown fences, no explanation, no file paths."
  ]
  AiGuard.guard_prompt(parts.join("\n"))
end

# File plugins/pies.rb, line 488
def self.cache_menu_image_text!(url, text, store: RabbotDb)
  store.set_plugin_value(
    plugin: MENU_IMAGE_CACHE_PLUGIN,
    key: menu_image_cache_key(url),
    value: text.to_s
  )
end

# File plugins/pies.rb, line 484
def self.cached_menu_image_text(url, store: RabbotDb)
  store.get_plugin_value(plugin: MENU_IMAGE_CACHE_PLUGIN, key: menu_image_cache_key(url))
end

# File plugins/pies.rb, line 432
def self.clean_facebook_snippet(snippet)
  text = snippet.to_s.strip
  return "" if text.empty?
  return "" if text.match?(FACEBOOK_SNIPPET_NOISE_PATTERN) && !text.match?(/\bpie/i)

  text = text.sub(/\d[\d,]*\s+likes?\s*[·•].*$/i, "").strip
  text = text.sub(/\d+\s+talking\s+about\s+this.*$/i, "").strip
  Duck.trim_snippet(text)
end

# File plugins/pies.rb, line 350
def self.clean_place_title(title)
  text = title.to_s.strip
  return "" if text.empty?

  if text.match?(/\A(?:home|menu|about us)\s*\|\s*/i)
    text = text.split(/\s*\|\s*/, 2).last.to_s
  else
    text = text.split(/\s*\|\s*/).first.to_s
  end

  text = text.sub(/\s+in\s+.+$/i, "").strip
  text.sub(/\s+-\s+.+$/, "").strip
end

# File plugins/pies.rb, line 180
def self.compact_search_label(place, label)
  name = place_name_from_result(place)
  state = state_abbrev_from_result(place)

  if name && state
    return "#{name} #{state}"
  elsif name
    return name
  end

  parts = label.to_s.split(",").map(&:strip).reject(&:empty?)
  return parts.first if parts.length <= 1

  town = parts.first
  abbrev = AU_STATE_ABBREV[parts[1].to_s.downcase]
  abbrev ? "#{town} #{abbrev}" : "#{town} #{parts[1]}"
end

# File plugins/pies.rb, line 507
def self.download_menu_image(url, fetch:)
  body = fetch.call(url)
  return nil if body.nil? || body.to_s.empty?

  ext = url.to_s.match(/\.(jpe?g|png|webp)/i) ? Regexp.last_match(1).downcase : "jpg"
  file = Tempfile.new(["pies_menu", ".#{ext}"])
  file.binmode
  file.write(body)
  file.close
  file.path
rescue StandardError
  nil
end

# File plugins/pies.rb, line 408
def self.extract_best_candidate_from_ddg_html(html, location:)
  doc = Nokogiri::HTML(html.to_s)
  candidates = doc.css(".result").filter_map do |result|
    title = result.at_css(".result__a")&.text&.strip
    href = Duck.clean_url(result.at_css(".result__a")&.[]("href"))
    place_candidate(title, href, location: location)
  end

  candidates.max_by { |candidate| candidate[:score] }
end

# File plugins/pies.rb, line 442
def self.extract_facebook_description(html)
  doc = Nokogiri::HTML(html.to_s)
  raw = doc.at_css('meta[property="og:description"]')&.[]("content") ||
        doc.at_css('meta[name="description"]')&.[]("content")
  return nil if raw.nil? || raw.strip.empty?

  text = CGI.unescapeHTML(raw.to_s)
  text = text.sub(/\A[^.]+\.\s*/, "").strip if text.match?(/\d[\d,]*\s+likes?/i)
  text = text.sub(/\d[\d,]*\s+likes?\s*[·•][^.]*\.\s*/i, "").strip
  text = text.sub(/\d+\s+talking\s+about\s+this\s*[·•][^.]*\.\s*/i, "").strip
  text = text.sub(/\d[\d,]*\s+were\s+here\s*[·•]?\s*/i, "").strip
  cleaned = Duck.trim_snippet(text)
  cleaned.empty? ? nil : cleaned
end

# File plugins/pies.rb, line 457
def self.extract_facebook_image_urls(html)
  doc = Nokogiri::HTML(html.to_s)
  urls = []

  og = doc.at_css('meta[property="og:image"]')&.[]("content")
  cleaned_og = Duck.clean_url(og)
  urls << cleaned_og unless cleaned_og.empty?

  doc.css('img[src], img[data-src], link[rel="preload"][as="image"]').each do |node|
    src = node["src"] || node["href"] || node["data-src"]
    next if src.nil? || src.strip.empty?

    cleaned = Duck.clean_url(src)
    next if cleaned.empty?
    next if cleaned.match?(FACEBOOK_IMAGE_SKIP_PATTERN)

    urls << cleaned unless urls.include?(cleaned)
  end

  urls.first(MAX_MENU_IMAGES)
end

# File plugins/pies.rb, line 521
def self.extract_menu_from_images(image_urls, fetch_image:, runner:, store: RabbotDb, model: AGENT_MODEL)
  image_urls.each do |url|
    text = cached_menu_image_text(url, store: store)
    if text.nil? || text.to_s.strip.empty?
      path = fetch_image.call(url)
      next if path.nil? || !File.file?(path)

      prompt = build_menu_image_prompt(image_path: path)
      result = AiAgent.run_agent(prompt, model: model, runner: runner)
      next unless result.success?

      text = AiGuard.filter_output(result.text).to_s.strip
      cache_menu_image_text!(url, text, store: store) unless text.empty?
    end

    items = extract_menu_items(text.to_s)
    return { items: items, source_text: text } unless items.empty?
  end

  { items: [], source_text: nil }
end

# File plugins/pies.rb, line 543
def self.extract_menu_items(text)
  text = text.to_s.strip
  return [] if text.empty?

  items = []
  seen = {}

  text.scan(PIE_ITEM_PATTERN) do |name, price|
    label = name.to_s.strip.sub(/\s+/, " ")
    next if label.length < 4
    next if seen[label.downcase]

    seen[label.downcase] = true
    items << { name: label, price: price.to_s.strip }
  end

  items.first(MAX_MENU_ITEMS)
end

# File plugins/pies.rb, line 562
def self.extract_menu_items_from_ddg_html(html, place:)
  doc = Nokogiri::HTML(html.to_s)
  doc.css(".result").each do |result|
    title = result.at_css(".result__a")&.text&.strip.to_s
    snippet = result.at_css(".result__snippet")&.text&.strip
    next if snippet.nil? || snippet.empty?
    next if place && !place_matches_text?(place, title) && !place_matches_text?(place, snippet)

    items = extract_menu_items(snippet)
    return items unless items.empty?
  end

  []
end

# File plugins/pies.rb, line 364
def self.extract_name_from_facebook_title(title)
  if (match = title.match(/-\s*(.+?)\s*\|\s*Facebook\z/i))
    return clean_place_title(match[1])
  end

  if (match = title.match(/\A(.+?)\s*\|\s*.+\s+-\s*Facebook\z/i))
    return clean_place_title(match[1])
  end

  if (match = title.match(/\A(?:home\s*\|\s*)?(.+?)\s*\|\s*Facebook\z/i))
    return clean_place_title(match[1])
  end

  if (match = title.match(/\A(.+?)\s+-\s+Facebook\z/i))
    return clean_place_title(match[1])
  end

  nil
end

# File plugins/pies.rb, line 605
def self.find_menu(place, location, facebook_url: nil, fetch:, fetch_page:, fetch_image: nil, runner: nil,
                  store: RabbotDb)
  description = nil
  facebook_html = nil

  if facebook_url.to_s.include?("facebook.com")
    facebook_html = fetch_page.call(facebook_url)
    description = extract_facebook_description(facebook_html)
    items = extract_menu_items(description.to_s)
    return { items: items, description: description } if items.any?
  end

  menu_search_queries(place, location).each do |query|
    html = fetch.call(query)
    items = extract_menu_items_from_ddg_html(html, place: place)
    return { items: items, description: description } unless items.empty?
  end

  if facebook_html && fetch_image && runner
    image_urls = extract_facebook_image_urls(facebook_html)
    image_result = extract_menu_from_images(
      image_urls,
      fetch_image: fetch_image,
      runner: runner,
      store: store
    )
    return { items: image_result[:items], description: description } unless image_result[:items].empty?
  end

  { items: [], description: description }
rescue StandardError
  { items: [], description: description }
end

# File plugins/pies.rb, line 577
def self.find_place(location, fetch:, extra_queries: [], state_name: "queensland")
  (place_search_queries(location, state_name: state_name) + extra_queries).each do |query|
    html = fetch.call(query)
    candidate = extract_best_candidate_from_ddg_html(html, location: location)
    return [candidate, html] if candidate
  end

  nil
end

# File plugins/pies.rb, line 587
def self.find_place_across_areas(resolved, fetch:)
  suburb = place_name_from_result(resolved[:place])
  state_name = state_name_from_place(resolved[:place])&.downcase || "queensland"
  area_search_locations(resolved).each_with_index do |location, index|
    extra = index.zero? ? [] : wider_place_search_queries(suburb, location, state_name: state_name)
    place_info = find_place(location, fetch: fetch, extra_queries: extra, state_name: state_name)
    next unless place_info

    return {
      place_info: place_info,
      search_location: location,
      wider_area: index.positive? ? location : nil
    }
  end

  nil
end

# File plugins/pies.rb, line 639
def self.format_menu_line(item)
  if item[:price] && !item[:price].empty?
    "#{item[:name]} — #{item[:price]}"
  else
    item[:name].to_s
  end
end

# File plugins/pies.rb, line 647
def self.format_menu_paragraphs(menu_items, max_bytes: MENU_PARAGRAPH_MAX_BYTES, separator: ", ")
  entries = menu_items.map { |item| format_menu_line(item) }.reject(&:empty?)
  return [] if entries.empty?

  paragraphs = []
  current = +""

  entries.each do |entry|
    candidate = current.empty? ? entry : "#{current}#{separator}#{entry}"
    if candidate.bytesize > max_bytes && !current.empty?
      paragraphs << current
      current = entry.dup
    else
      current = candidate
    end
  end

  paragraphs << current unless current.empty?
  paragraphs
end

# File plugins/pies.rb, line 692
def self.format_not_found(location)
  header = IrcFormat.report_header(tag: "PIES", title: location.to_s.strip, style: STYLE_TITLE)
  [
    header,
    "Could not find a bakery near #{location}.",
    IrcFormat.report_footer("pies lookup")
  ].join("\n")
end

# File plugins/pies.rb, line 674
def self.format_report(place:, location:, menu_items:, description:, url:, wider_area: nil)
  header = IrcFormat.report_header(tag: "PIES", title: banner_title(place, location), style: STYLE_TITLE)
  body_lines = if menu_items.any?
                 format_menu_paragraphs(menu_items)
               elsif description && !description.empty?
                 [description]
               else
                 ["No pie menu found — check the bakery page for today's pies."]
               end

  lines = [header, *body_lines]
  lines << "Nearest bakery is in the #{wider_area} area." if wider_area && !wider_area.to_s.strip.empty?
  lines << url.to_s.strip unless url.to_s.strip.empty?
  footer_location = location.to_s.split(",").first.to_s.strip
  lines << IrcFormat.report_footer("bakery", footer_location, "Facebook")
  lines.join("\n")
end

# File plugins/pies.rb, line 701
def self.lookup(location, fetch:, fetch_page: nil, fetch_image: nil, runner: nil, search: Geocoder.method(:search),
                store: RabbotDb)
  fetch_page ||= ->(_url) { "" }
  resolved = resolve_location(location, search: search)
  label = resolved[:label]

  match = find_place_across_areas(resolved, fetch: fetch)
  return format_not_found(label) unless match

  place_info = match[:place_info]
  candidate, _html = place_info
  place = candidate[:name]
  url = candidate[:url]
  search_location = match[:search_location]
  menu = find_menu(
    place,
    search_location,
    facebook_url: url,
    fetch: fetch,
    fetch_page: fetch_page,
    fetch_image: fetch_image,
    runner: runner,
    store: store
  )
  format_report(
    place: place,
    location: label,
    menu_items: menu[:items],
    description: menu[:description],
    url: url,
    wider_area: match[:wider_area]
  )
rescue StandardError
  format_not_found(location)
end

# File plugins/pies.rb, line 479
def self.menu_image_cache_key(url)
  normalized = Duck.clean_url(url.to_s.strip)
  "#{MENU_IMAGE_CACHE_PREFIX}#{Digest::SHA256.hexdigest(normalized)}"
end

# File plugins/pies.rb, line 327
def self.menu_search_queries(place, location)
  [
    "#{place} #{location} pie menu",
    "#{place} meat pie prices",
    "#{place} pie menu"
  ]
end

# File plugins/pies.rb, line 419
def self.normalize_place_text(text)
  text.to_s.downcase.gsub(/[^a-z0-9\s]/, " ").squeeze(" ").strip
end

# File plugins/pies.rb, line 281
def self.parent_area_label(place, search: Geocoder.method(:search))
  coords = GeoLookup.coordinates_for(place)
  return nil unless coords

  results = search.call(coords, params: { zoom: REVERSE_GEOCODE_ZOOM })
  parent = results.first
  return nil unless parent

  parent_name = place_name_from_result(parent)
  return nil if parent_name.nil? || parent_name.empty?

  suburb = place_name_from_result(place)
  return nil if suburb && parent_name.casecmp?(suburb)

  state = state_abbrev_from_result(parent) || state_abbrev_from_result(place)
  state ? "#{parent_name} #{state}" : parent_name
rescue StandardError
  nil
end

# File plugins/pies.rb, line 102
def self.parse_location(text)
  text = text.to_s.strip
  return { error: usage_message } if text.empty?

  if text.match?(%r{\A["']})
    unless (match = text.match(%r{\A["'](.+?)["']\z}))
      return { error: usage_message }
    end

    location = match[1].strip
    return { error: usage_message } if location.empty?

    return { location: location }
  end

  { location: text }
end

# File plugins/pies.rb, line 384
def self.place_candidate(title, href, location:)
  title = title.to_s.strip
  href = href.to_s
  return nil if title.empty?
  return nil if reject_listing_url?(href)

  name = if href.include?("facebook.com")
    extract_name_from_facebook_title(title)
  else
    clean_place_title(title)
  end
  return nil if name.nil? || name.empty?
  return nil unless valid_place_name?(name)

  score = 0
  score += 100 if href.include?("facebook.com")
  score += 80 if href.include?("google.com/maps")
  score += 60 if name.match?(BAKERY_VENUE_PATTERN)
  score += 30 if location.to_s.downcase.split.any? { |word| word.length >= 3 && name.downcase.include?(word) }
  score += 20 if href.match?(BAKERY_VENUE_PATTERN)

  { name: name, score: score, url: Duck.clean_url(href) }
end

# File plugins/pies.rb, line 423
def self.place_matches_text?(place, text)
  norm_place = normalize_place_text(place)
  norm_text = normalize_place_text(text)
  return false if norm_place.empty? || norm_text.empty?

  norm_text.include?(norm_place) ||
    norm_place.split.count { |word| word.length >= 3 && norm_text.include?(word) } >= 2
end

# File plugins/pies.rb, line 142
def self.place_name_from_result(place)
  return place.city.to_s.strip if place.respond_to?(:city) && !place.city.to_s.strip.empty?

  data = place.data if place.respond_to?(:data)
  if data.is_a?(Hash) && !data["name"].to_s.strip.empty?
    return data["name"].to_s.strip
  end

  if data.is_a?(Hash)
    addr = data["address"] || data[:address] || {}
    %w[city town village city_district hamlet suburb].each do |key|
      value = addr[key] || addr[key.to_sym]
      return value.to_s.strip unless value.to_s.strip.empty?
    end
  end

  nil
end

# File plugins/pies.rb, line 233
def self.place_search_queries(location, state_name: "queensland")
  state = state_name.to_s.downcase
  [
    "#{location} bakery facebook",
    "#{location} pie shop facebook",
    "bakery #{location} #{state}",
    "pie shop #{location}",
    "bakehouse #{location}"
  ]
end

# File plugins/pies.rb, line 277
def self.postcode_from_place(place)
  address_field(place, "postcode")
end

# File plugins/pies.rb, line 335
def self.reject_listing_url?(href)
  href.to_s.match?(LISTING_URL_PATTERN)
end

# File plugins/pies.rb, line 218
def self.resolve_location(location, search: Geocoder.method(:search))
  text = location.to_s.strip
  return { query: text, label: text, search_query: text, resolved: false } if text.empty?

  place = GeoLookup.lookup_place(text, search: search)
  if place
    label = resolved_label(place)
    search_query = compact_search_label(place, label)
    search_query = label if search_query.empty?
    { query: label, label: label, search_query: search_query, resolved: true, place: place }
  else
    { query: text, label: text, search_query: text, resolved: false }
  end
end

# File plugins/pies.rb, line 207
def self.resolved_label(place)
  data = place.data if place.respond_to?(:data)
  if data.is_a?(Hash)
    display = data["display_name"] || data[:display_name]
    text = display.to_s.strip
    return text unless text.empty?
  end

  GeoLookup.location_label(place)
end

# File plugins/pies.rb, line 161
def self.state_abbrev_from_result(place)
  if place.respond_to?(:state_code)
    code = place.state_code.to_s.strip
    return code.upcase if code.match?(/\A[A-Z]{2,3}\z/i)

    abbrev = AU_STATE_ABBREV[code.downcase]
    return abbrev if abbrev
  end

  data = place.data if place.respond_to?(:data)
  if data.is_a?(Hash)
    addr = data["address"] || data[:address] || {}
    iso = addr["ISO3166-2-lvl4"] || addr[:"ISO3166-2-lvl4"]
    return iso.to_s.split("-").last if iso.to_s.include?("-")
  end

  nil
end

# File plugins/pies.rb, line 198
def self.state_name_from_abbrev(abbrev)
  AU_STATE_FULL_NAMES[abbrev.to_s.upcase]
end

# File plugins/pies.rb, line 202
def self.state_name_from_place(place)
  abbrev = state_abbrev_from_result(place)
  state_name_from_abbrev(abbrev)
end

# File plugins/pies.rb, line 98
def self.usage_message
  'Usage: !pies <location> — quote multi-word locations, e.g. !pies "blackbutt qld"'
end

# File plugins/pies.rb, line 339
def self.valid_place_name?(name)
  text = name.to_s.strip
  return false if text.empty? || text.length > 80
  return false if text == "No results found"
  return false if text.match?(REJECT_PLACE_PATTERN)
  return false if text.match?(/#\w+|\d+\s*views|watch the latest videos/i)
  return false unless text.match?(BAKERY_VENUE_PATTERN)

  true
end

# File plugins/pies.rb, line 244
def self.wider_place_search_queries(suburb, wider_area, state_name: "queensland")
  suburb = suburb.to_s.strip
  area = wider_area.to_s.strip
  state = state_name.to_s.downcase
  return [] if area.empty?

  queries = [
    "bakery #{area} #{state}",
    "#{area} bakery facebook"
  ]
  if !suburb.empty? && !area.downcase.include?(suburb.downcase)
    queries.unshift(
      "bakery near #{suburb} #{area}",
      "#{suburb} bakery #{area} #{state}",
      "#{suburb} pie shop facebook"
    )
  end
  queries
end

# File plugins/pies.rb, line 766
def execute(m, args_text)
  parsed = self.class.parse_location(args_text)
  if parsed[:error]
    m.reply(parsed[:error])
    return
  end

  flood_safe_reply(m, lookup(parsed[:location]))
end

# File plugins/pies.rb, line 750
def fetch_html(query)
  url = "#{Duck::DDG_HTML_URL}?q=#{CGI.escape(query)}"
  RabbotHttp.fetch(url, user_agent: USER_AGENT)
end

# File plugins/pies.rb, line 759
def fetch_menu_image(url)
  self.class.download_menu_image(
    url,
    fetch: ->(image_url) { RabbotHttp.fetch(image_url, user_agent: USER_AGENT) }
  )
end

# File plugins/pies.rb, line 755
def fetch_page(url)
  RabbotHttp.fetch(url, user_agent: USER_AGENT)
end

# File plugins/pies.rb, line 737
def lookup(location, fetch: method(:fetch_html), fetch_page: method(:fetch_page), fetch_image: method(:fetch_menu_image),
           runner: AiAgent.method(:default_runner), search: Geocoder.method(:search), store: RabbotDb)
  self.class.lookup(
    location,
    fetch: fetch,
    fetch_page: fetch_page,
    fetch_image: fetch_image,
    runner: runner,
    search: search,
    store: store
  )
end